Inufu

For EU / UK: https://geizhals.eu/?cat=hde7s&offset=0&sort=r&hloc=at&hloc=...

Works for an amazingly large set of products!

In that case the CLI only needs to import the plugin that defined that sub command, not all plugins?

Author here.

The standard way to do this is Reinforcement Learning: we do not teach the model how to do the task, we let it discover the _how_ for itself and only grade it based on how well it did, then reinforce the attempts where it did well. This way the model can learn wildly superhuman performance, e.g. it's what we used to train AlphaGo and AlphaZero.

Well, growth has been on this exponential already for 5+ years (for the METR eval), and we are at the point where models are very close to matching human expert capabilities in many domains - only one or two more years of growth would put us well beyond that point.

Personally I think we'll see way more growth than that, but to see profound impacts on our economy you only need to believe the much more conservative assumption of a little extra growth along the same trend.

Author here.

The argument is not that it will keep growing exponentially forever (obviously that is physically impossible), rather that:

- given a sustained history of growth along a very predictable trajectory, the highest likelihood short term scenario is continued growth along the same trajectory. Sample a random point on an s-curve and look slightly to the right, what’s the most common direction the curve continues?

- exponential progress is very hard to visualize and see, it may appear to hardly make any progress while far away from human capabilities, then move from just below to far above human very quickly

Yeah exactly!

It’s likely that it will slow down at some point, but the highest likelihood scenario for the near future is that scaling will continue.

You don’t have to randomize the first part of your object keys to ensure they get spread around and avoid hotspots.

Sorry, this is absolutely still the case if you want to scale throughput beyond the few thousand IOPS a single shard can serve. S3 will automatically reshard your key space, but if your keys are sequential (eg leading timestamp) all your writes will still hit the same shard.

Source: direct conversations with AWS teams.

It means you can for example no longer do things like get multiple disjoint references into the same buffer for parallel reads/writes of independent chunks.

Or well you can, using unsafe, Arc and Mutex - but at that point the safety guarantees aren’t much better than what I get in well designed C++.

Don’t get me wrong, I still much prefer Rust, but I wish async and references worked together better.

Source: I recently wrote a high-throughput RPC library in Rust (saturating > 100 Gbit NICs)

Requiring ownership transfer gives up on one of the main selling points of Rust, being able to verify reference lifetime and safety at compile time. If we have to give up on references then a lot of Rusts complexity no longer buys us anything.

You can use Claude Code with your own API key if you want to use more tokens than included in the Pro / Max plans.

AlphaZero did not run game logic on TPUs (neither chess nor other games), implementing it in C++ is more than fast enough and much simpler.

TPUs were used for neural network inference and training, but game logic as well as MCTS was on the CPU using C++.

JAX is awesome though, I use it for all my neural network stuff!

This is not a fake imitation, it's steaming results live as they are being generated by the model.

The 12 bit part refers to the colours being specified using three hex letters.

Yes, parameters are usually stored as float32, activations as bfloat16 or float16.

On many natural language tasks there can be significant overlap, making it difficult to judge performance. That's why I like more complex code generation tasks such the dataset we used for AlphaCode.

Efficiency is the main concern for a fusion reactor!

We've known how to produce fusion reactions for a long time, the difficult part is to generate net energy.

Yes, this is how you increase prosperity (see: agricultural revolution, industrial revolution, etc). You can now create more with the same number of people.

I agree, I expect programmers will just move up the levels of abstraction. I enjoyed this recent blog post on the topic: https://eli.thegreenplace.net/2022/asimov-programming-and-th...

Best viewed on a larger screen :)

If you are interested in this topic, I recommend "Crazy Like Us" by Ethan Watters - it describes how mental illnesses get exported by media coverage and cultural attitudes from Western countries, and how cultural expectations shape the manifestation of mental illness. It was also reviewed in depth by Scott Alexander: https://astralcodexten.substack.com/p/book-review-crazy-like...

Self diagnosis waves on tiktok seem like the next evolution of this, but even faster and more globalised.

I've been wondering if this phenomenon could be harnessed to reduce the impact of mental illness: purposely spread content that encourages self-diagnosis with the mildest possible symptoms.

This looks great, thank you for the hard work!

Have you considered to also expose this information in an interactive web interface? Using a zoomable timeline view (https://www.tensorflow.org/tensorboard/tensorboard_profiling...), both for after the fact analysis (taking a fixed N second trace and then inspecting it) as well as interactive visualization (automatically scrolling timeline with option to pause and scrub).

Doesn't sound too different from the diet a lot of humans eat ;)

The author keeps referring to the "PSPACE" complexity of chess and Go in the context of AlphaGo; this is incorrect - these games are only PSPACE for arbitrary large board size N, at fixed board size as actually used by humans and current AI they are just constant O(1), complexity class is not relevant for this.

The article was also written before the best evidence we currently have for this was published: scaling laws for natural language understanding (https://arxiv.org/abs/2001.08361), performance of RL algorithms with respect to data (eg AlphaGo Elo vs training time), image model accuracies, etc all show that exponentially increasing amounts of data/computation are required for linear improvements in performance.

I posted some graphs with more details here: http://www.furidamu.org/blog/2020/05/03/the-case-against-the...

tl;dr: current evidence suggests AI performance scales with log of data or computation

This sort of approach is known as Genome Wide Association study, finding the correlation of hundreds or thousands of genes that will predict a trait: https://en.wikipedia.org/wiki/Genome-wide_association_study

If you are interested in the topic, I recommend https://en.wikipedia.org/wiki/Blueprint_(book)

If you've made your own MuZero implementation, please let me know and I'll be happy to link it from my blog post :)

JavaScript can parse binary serialised protobufs.

I built (at Google) a prototype system in Go, then rewrote complete in C++:

- Go was too slow and GC too much overhead (real time analytics)

- Error handling and propagation is insanely verbose in Go, the C++ actually was more concise

- lack of generics made it impossible to reuse complex high-performance data structures and algorithms even within the project

Haven't looked back and between C++, Rust, Swift and Python, I'd never choose to use Go again.

What value does adding the real name of the person to the article bring to you, the reader? Would you interpret it any differently if the name was different?

Seems like a pretty clear cut case for not mentioning the name.

Nice visualizations and explanation!

You might want to make it clearer that the agents don't actually receive any visual observations, but rather directly the xy positions of all other agents and objects.

This also seems very similar to "Capture the Flag: the emergence of complex cooperative agents" (https://deepmind.com/blog/article/capture-the-flag-science)?

Regarding the conclusion:

We’ve provided evidence that human-relevant strategies and skills, far more complex than the seed game dynamics and environment, can emerge from multi-agent competition and standard reinforcement learning algorithms at scale. These results inspire confidence that in a more open-ended and diverse environment, multi-agent dynamics could lead to extremely complex and human-relevant behavior.

This has been well established for a while already, e.g. the DeepMind Capture the Flag paper above, AlphaGo discovering the history of Go openings and techniques as it learns from playing itself, AlphaZero doing the same for chess, etc.

L7 at Google here (joined as L3 right out of university).

Having feedback from L+1 or +2 peers is very important, otherwise it can be very hard for the committee to judge performance.

Actually "leading" a project less so - often a single "project" can be viewed as multiple components / projects for promo purposes, what counts (depending on level) is initiative, leadership, and technical contributions. It's not necessary to be the formal lead of a big project for this purpose, but rather for your senior peers to attest how well you did in those areas and how it helped the project launch X months faster, improved QPS by X or whatever metric.

As pointed out in other comments, it can be hard for the committee to see impact, so the more hard evidence you have (before/after resource usage, bugs fixed, etc) the better. Same for improving the codebase, document and show the evidence!