serialx

Look into all-smi https://github.com/lablup/all-smi It supports all GPUs thinkable including Apple Silicon and many AI accelerator cards.

Yeah, attention sinks were applied to gpt-oss

Ah sorry, you might be right. I meant "sparse reward" as a reward system that is mostly 0 but occasionally 1. Your "sparse reward" means only providing reward at the end of each output.

I don't think it's only using sparse rewards because of the format rewards. The training recipe is pretty comprehensive and involves multiple stages.[1] The paper mentions that when only using the RL technique, the output is often not suitable for reading. (Language mixing, etc) That feels like a AlphaZero moment for LLMs?

[1]: https://www.reddit.com/r/LocalLLaMA/comments/1i8rujw/notes_o...

So to my understanding, this work reproduces DeepSeek R1's reinforcement learning mechanism in a very small language model.

The AI gets "rewards" (like points) for doing two things correctly:

Accuracy : Getting the right answer. For example, math answers must be in a specific format (e.g., inside a box) so a computer can easily check them. For coding problems, test cases verify if the code works.

Format : Using the <think> and <answer> tags properly. This forces the AI to organize its responses clearly.

So in this case, the training program can extract the model's answer by parsing <answer> tag. We can eval the answer and evaluate if it's correct or not. If it's correct give reward, else: no reward.

Create N such answers from a single question, create N reward array. This is enough for the RL algorithm to guide the model to be more smart.

Change the currency to USD

What are the compute requirements for solving efficient energy grid transmission? Is there a efficient algorithm that is able to solve this?

Is there any plans to add Well-known URI[1] as a standard? It would be awesome if we can add services just by inputting domain names of the services.

[1]: https://en.wikipedia.org/wiki/Well-known_URI

PSA: You can also use singleflight[1] to solve the problem. This prevents the thundering herd problem. Pocache is an interesting/alternative way to solve thundering herd indeed!

[1]: https://pkg.go.dev/golang.org/x/sync/singleflight

Actually, llama.cpp running on Apple silicon uses GPU(Metal Compute Shader) to inference LLM models. Token generation is also very memory bandwidth bottlenecked. On high end Apple silicon it's about 400MB/s to 800MB/s, comparable to NVIDIA RTX 4090, which has memory bandwidth of 1000MB/s. Not to mention that Apple silicon has unified memory architecture and has high memory models (128GB, up to 192GB), which is necessary to run large LLMs like Llama 3 70B, which roughly takes 40~75GB of RAM to work reasonably.

Well, iPhone already does that with photos. :)

Now we just need VkDNN

Interesting! Maybe using small cells like these might make the frame and cell blend together?

https://a.aliexpress.com/_oDCStIL

No since it’s stateful in the sense that inferencing is dependent on the past generated tokens.

This is just awesome. I wish there are open and arduino like dev env for FPGAs.

The difference reminds me of the energy efficiency a EV has.

They also sell cut tape. So you can order from 1 to 100 parts. There are however some parts that have MOQ of ~50, but those are so cheap that 100 of them would be less than 10 USD.

If you want small servos, just use steppers with drivers like TMC2130.

Anything bigger, many people seem to like ClearPath servos. Price to performance seem to be pretty good.

This is fixed now. The README now state GPL + Classpath Excemption

Looking at paper like this, I can't help to think about PDP. Will we be able to confirm Parallel distributed processing (PDP) theory in the near future?

I'm using Cloudflare as a free DNS.

Worth mentioning https://cipherli.st/ too. But I think more warning about HSTS is needed, since misconfiguring HSTS will cause the domain to be inaccessible for long periods.

QUIC uses TCP friendly backoff algorithm called CUBIC. Linux TCP implementation currently uses CUBIC too. One difference between TCP and QUIC is that the parameter beta of CUBIC is different.

One QUIC connection is equivalent to two TCP connections in that regard. So QUIC will only backoff half amount compared to TCP. In the design docs, they mention it's okay since one QUIC connection is equivalent to multiple TCP connections that a browser makes.

It would be more interesting to see more modern approaches with KV storages like forestdb[1]. Couchbase already replaced their storage engine with forestdb[2].

[1]: https://www.computer.org/csdl/trans/tc/preprint/07110563.pdf [2]: https://github.com/couchbase/forestdb

This, changes everything.

The theme seaborn uses is actually a direct clone from ggplot2 from R

Guys have a look at SSLShader[1]

[1]: http://shader.kaist.edu/sslshader/

There's QUIC support in Wireshark. Use the beta version. :)

Or you can use binary search with slightly off-center binary or quaternary (four-way) searches to provide more consistent lookup times:

http://www.pvk.ca/Blog/2012/07/30/binary-search-is-a-patholo...

If you write the code within the `gen_server` guidelines, state migration is supported by `code_change`:

http://www.erlang.org/doc/man/gen_server.html#Module:code_ch...

For example:

http://stackoverflow.com/questions/1840717/achieving-code-sw...

BTW, You can even support downgrade. :)

> Every fan in South Korea has an automatic shut-off feature - you can’t even buy a fan that will run all night. Impossible to purchase.

This statement is simply not true. I live in South Korea and I always run it all night in summer.