Interactive AI paper explainers

Train each block of a network on its own, as a denoiser for one range of noise levels.

One algorithm, given only the rules, taught itself chess, shogi, and Go by playing against itself.

Exact attention, computed while moving far less data through slow GPU memory.

Plan ahead in a game without ever being told its rules, by learning a model that predicts only what planning needs.

Fit a small network to a scene’s photos, and render it from any new camera angle.

Q-learning, a convnet and a replay memory learn seven Atari games from raw pixels and the score.

Store a scene as millions of tiny 3D Gaussians and a GPU renders new views of it in real time, no neural network in the loop.

Standardize every layer’s inputs over each mini-batch, and an ImageNet classifier reaches its original accuracy in 14 times fewer training steps.

Run a diffusion model with the label and without it, then amplify the difference.

Fix the architecture, then steer sampling with a classifier gradient: a diffusion model overtakes BigGAN on ImageNet while covering more of the distribution.

Compress images with an autoencoder, run the diffusion model on the small code, decode once at the end.

Every NLP task becomes the same task: text in, text out.

One plain Transformer, trained on 680,000 hours of noisy web transcripts, transcribes new audio without fine-tuning.

Run many copies of an agent in parallel, and deep RL trains stably on a CPU, no replay buffer needed.

Each word gathers information from every other word directly, in one parallel step.

An agent learns a task from a person picking the better of two short clips of its behavior, with no hand-written reward.

The first diffusion model: dissolve data into noise one tiny step at a time, then learn to run every step backward.

Mix each node's features with its neighbors', and 140 labels are enough to classify every node of a 2,708-node graph.

A big model’s probabilities for the wrong answers teach a small model how to generalize.

Train a small model far too long, so it is cheap to run.

Hide 75% of an image, reconstruct the missing patches, and a plain ViT encoder learns to see.

Test loss falls as a power law in model size, data and compute, so small training runs predict large ones.

Gradually noising data is a stochastic differential equation, and running that equation backward with a learned score generates new data.

A segmentation model that outlines any object from a click or a box.

Hold everything fixed but depth: a uniform stack of tiny 3×3 filters, 16–19 layers deep, that reset how convnets are built.

Get 1,000-step diffusion quality from 20 to 100 steps, with the same trained network.

A transformer predicts a fixed set of 100 boxes, trained by one-to-one matching to the real objects, so detection needs no anchors and no duplicate removal.

A robot policy that generates a short sequence of future actions by denoising random noise.

Cut the noised latent into patches, run a plain transformer over them, and image quality follows the forward-pass Gflops, not the parameter count.

Connect a frozen vision model to a frozen language model with a trained bridge, and it learns new tasks from a few examples.

Fine-tuned on human feedback, a 1.3B model's answers are preferred to the 175B GPT-3's.

Normalize each example across its own features, not across the batch, so it needs no batch and steadies RNNs.

A model too big for one GPU trains anyway, by splitting each layer’s matrix multiplies across many.

Finetune a 65B model on one 48 GB GPU: store the frozen model in 4 bits and train a small 16-bit adapter through it.

Add each block's input to its output, and deeper networks train better instead of worse.

Standard image networks reach 100% training accuracy on random labels, so model complexity and regularization cannot be what makes them generalize.

One LSTM reads a sentence into one fixed vector; another decodes the translation from it. Reverse the source and it trains.

Reward an agent for succeeding and for staying random, and off-policy control gets both sample-efficient and stable.

A single network pass turns an image into all of its object boxes and class labels.

A vision-language model that outputs a robot’s next 50 actions by refining random noise.

For SGD, weight decay equals L2 regularization. For Adam it does not, and decoupling them lets Adam generalize like SGD.

A translator that rereads every source word, with learned weights, before it writes each word of the output.

Hide words in a sentence and train a Transformer to fill them in from both sides.

A network outputs one action per state and is trained along the gradient of a learned Q-function, so deep Q-learning works for continuous actions such as joint torques.

Label each logged step with the reward that followed it, train a GPT on that, then prompt it with the score you want. No value function, no Bellman backup.

Four derivations of the same diffusion model: as a variational autoencoder, as a chain of denoising steps, by score matching, and as a stochastic differential equation.

An agent learns a model of its environment, practices inside it, and one fixed set of hyperparameters works on over 150 tasks.

Prune a trained network, reset the survivors to their original initial values, and the 10% that remain train as fast and as accurately as the whole.

Storing the KV cache in fixed-size blocks, like operating-system pages, raises LLM serving throughput 2-4×.

Bound how much the policy changes each step, measured in KL, and the update can be large without collapsing.

A convolutional network that labels every pixel of a microscope image, trained on a few dozen annotated examples.

Data parallelism keeps a full copy of the training state on every GPU. ZeRO gives each GPU one slice and fetches the rest when a step needs it.

Finetune a language model on many tasks written as instructions, and it follows instructions for task types it never trained on.

A generator learns to produce data by training against a classifier that tries to catch its fakes.

Map CLIP’s image patches into a language model’s word space with one linear layer, then train on 158K conversations that text-only GPT-4 wrote from captions and boxes.

Serving a language model splits into two jobs, prefill and decode. Pool the KV cache between them.

Learn the gradient of the data density at many noise levels, then walk noise into images with annealed Langevin dynamics.

Let an ODE solver run the network, and train it with memory that does not grow with depth.

Route each token to one expert, so parameters scale to a trillion while the compute spent per token stays flat.

Cut an image into 16×16 patches, feed them to a standard Transformer, and with enough pre-training data it beats convolutional networks.

Two running averages give every weight its own learning rate.

A small trained module turns an image into 32 vectors that a frozen language model reads as its prompt.

A 7B vision-language model that outputs a robot arm’s next move as seven tokens.

Clipping the probability ratio lets a policy train on each batch of experience for several epochs.

A language model writes a thought, calls a tool, reads the result, and repeats until it can answer.

Rotate each query and key by an angle set by its position, and the attention score depends on position only through the distance between the two tokens.

A linear state space layer that keeps 64 numbers of state per channel and solved a 16,384-step task every earlier model failed.

A few huge activation channels break 8-bit quantization of large language models. An exact rescale moves that range into the weights, which quantize cleanly.

A 7B model that outscores Llama 2 13B, with two attention changes that cut its serving memory.

Predict a transformer’s own next hidden state during training, and it compresses history into a compact world model.

Encode a robot action as a short string of integers, and a vision-language model can output it.

A video model trained on over a million hours of internet video and 62 hours of robot video plans a robot arm's motions in labs it has never seen.

Put worked examples in a prompt, and large models solve multi-step problems.

A short list of written principles replaces the human labels that mark harmful answers.

A network learns image features by predicting the output of a slowly averaged copy of itself, with no labels.

FlashAttention-2 computes the same attention as FlashAttention about twice as fast, by changing how the work is split across the GPU.

Let the state rotate as it fades, and a fixed-size memory can keep a count.

A diffusion model can generate without being told its noise level, unless it is trained to predict the noise.

A voxel grid that records where a mesh’s surface crosses each cell, so open sheets, sealed interiors, and edges where three or more panels meet all fit.

Scale each layer’s initialization and learning rate with width, and the best hyperparameters of a small model also work for a large one.

A pretrained image-to-image diffusion model, sampled in 6 network calls instead of 119, with no retraining.

Store a few activations and recompute the rest: square-root memory for one extra forward pass.

Learn image features by predicting the embeddings of hidden image blocks, not their pixels.

Let all attention heads share one key and one value, and the cache a decoder rereads at every step shrinks by the number of heads.

Let a language model look up Wikipedia passages before it answers.

Fine-tune a large model by freezing its weights and training a low-rank update beside them.

Distill a diffusion model to 1 to 4 sampling steps and keep both the sharpness and the variety of its outputs.

Cut activation memory 5× and recover over 90% of the time lost to recomputation, with sequence parallelism and selective recompute.

A video encoder learns by predicting the features of hidden parts of a clip, with no labels, text, or pixel targets.

Encode a video once, then ask for the 3D position of any pixel at any moment.

Mamba's recurrence, rewritten as a structured matrix so a GPU can compute it with matrix multiplications.

Distill a black-box LLM like GPT-4 by aligning an open proxy to it, then learning from the proxy’s full distribution.

Reward an agent only for the prediction error its world model can still reduce, and curiosity stops chasing random noise.

Vector search that recomputes embeddings instead of storing 173 GB of them.

A random rotation lets one fixed quantizer compress any vector to within 2.7× of the best possible error, with no training.

Tune a language model on preference pairs with one classification loss, no reward model and no RL.

Adapting an LLM to French medical QA: a cheap supervised fine-tune usually matches the continual-pretraining recipe that costs four times more.

An agent learns a model of its game, then trains inside that model.

A linear-time sequence model whose state update depends on the token it reads.

An autoencoder you can sample from, trained by backpropagating through a random draw.

Destroy an image with noise, then learn to reverse it.

Scale a language model to 175 billion parameters and it can do a new task from a few examples in its prompt.

At a fixed training budget, a smaller model trained on more text reaches a lower loss.

Train on 400 million web images and their captions, and any list of class names becomes an image classifier.

Train a generative model by regressing the straight-line velocity from a noise sample to a data sample.