Weekly ML digest
The ML papers worth reading, ranked and explained.
Every week we score new arXiv papers by real signal (community upvotes, our own relevance model) and write a plain-English summary of the ones that clear the bar. One email. Before your Monday coffee. The digest is free and stays free.
See what premium includes →Latest issue
Issue #9
Orca: The World is in Your Mind
arXiv:2606.30534 · 235▲ · cs.CV
Orca is an encoder-decoder model that learns a shared 'world latent space' from video and language by predicting the latent representation of adjacent frames (unconscious learning) and event-conditioned future states described by text (conscious learning), plus a standard VQA loss. After pretraining, the backbone (built on a Qwen VLM) is frozen and small task-specific decoders are trained for text, image prediction, and robot action generation to test whether the shared latent transfers.
Program-as-Weights: A Programming Paradigm for Fuzzy Functions
arXiv:2607.02512 · 106▲ · cs.LG, cs.AI, cs.CL
The paper introduces Program-as-Weights (PAW), a system that compiles a natural-language description of a fuzzy task (things like log alerting, JSON repair, or intent classification that resist clean rule-based code) into a small neural artifact. A 4B compiler reads the spec plus an auto-generated pseudo-program of paraphrase-and-examples, then emits a per-function LoRA adapter that gets hot-attached to a frozen 0.6B interpreter model, which runs the task locally.
Scaling the Horizon, Not the Parameters: Reaching Trillion-Parameter Performance with a 35B Agent
arXiv:2606.30616 · 90▲ · cs.CL
A recipe for training a 35B mixture-of-experts agent (Agents-A1) to handle long-horizon agentic tasks by scaling trajectory length rather than parameters. The method has three stages: full-domain supervised fine-tuning on ~100K long trajectories (average 45K tokens), training domain-specific teacher models, then consolidating them into one student via domain-routed on-policy distillation with salient vocabulary alignment (SVA), which aligns student and teacher on the teacher's top-k token support instead of just the sampled token.
Start here
Foundational papers
The classics worth knowing, explained the same way as every issue.
Adam: A Method for Stochastic Optimization
This paper introduces Adam, a first-order stochastic optimization algorithm that maintains per-parameter adaptive learning rates using exponential moving averages of the gradient (first moment) and squared gradient (second raw moment), with a bias-correction step for the zero-initialized averages. It combines ideas from AdaGrad (sparse gradients) and RMSProp (non-stationary objectives), and also presents AdaMax, a variant based on the infinity norm.
An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale
This paper introduces the Vision Transformer (ViT), which applies a standard Transformer encoder directly to image classification by splitting an image into fixed-size patches (for example 16x16 pixels), linearly embedding each patch as a token, adding position embeddings, and processing the sequence with self-attention. It deliberately avoids convolutions and image-specific inductive biases except for the initial patch extraction and position embedding interpolation at fine-tuning time.
Attention Is All You Need
This paper introduces the Transformer, a sequence-to-sequence architecture for machine translation that replaces recurrent and convolutional layers entirely with stacked self-attention and position-wise feed-forward layers. It uses scaled dot-product attention with multiple attention heads, plus sinusoidal positional encodings to inject word order since there is no recurrence.
Auto-Encoding Variational Bayes
This paper introduces the reparameterization trick (rewriting a latent variable z as a deterministic function of the parameters plus fixed noise) so that the variational lower bound becomes differentiable and trainable with ordinary stochastic gradient descent. Applying this to an encoder/decoder pair of neural networks gives the variational auto-encoder (VAE), trained end to end with the AEVB algorithm.
Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift
This paper introduces Batch Normalization, a layer inserted before each nonlinearity that normalizes activations to zero mean and unit variance using per-mini-batch statistics, then applies a learned scale and shift. The normalization is part of the network architecture so gradients backpropagate through it, and at inference time it uses population statistics computed from moving averages.
BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding
BERT is a language representation model that pre-trains a deep bidirectional Transformer encoder using two self-supervised tasks: masked language modeling (predicting randomly hidden tokens from both left and right context) and next sentence prediction. The pre-trained model is then fine-tuned end-to-end for specific tasks by adding a single output layer, with no task-specific architecture changes.
Chain-of-Thought Prompting Elicits Reasoning in Large Language Models
The paper introduces chain-of-thought prompting: instead of giving a large language model few-shot examples that map questions directly to answers, each exemplar includes the intermediate reasoning steps that lead to the answer. The model then generates its own step-by-step reasoning before producing a final answer, with no finetuning involved.
Denoising Diffusion Probabilistic Models
This paper introduces Denoising Diffusion Probabilistic Models (DDPMs), a generative model that learns to reverse a fixed Markov chain that gradually adds Gaussian noise to images. The key practical simplification is training a U-Net to predict the noise added at each timestep using a plain weighted mean-squared-error objective, which the authors show is equivalent to denoising score matching over multiple noise levels.
Direct Preference Optimization: Your Language Model is Secretly a Reward Model
This paper introduces Direct Preference Optimization (DPO), a method for aligning language models to human preferences using a single binary cross-entropy classification loss instead of the standard RLHF pipeline. It shows that the KL-constrained reward maximization objective used in RLHF has a closed-form optimal policy, which lets you reparameterize the reward as a function of the policy itself and skip both the separate reward model and the reinforcement learning loop.
Efficient Estimation of Word Representations in Vector Space
This is the original word2vec paper. It introduces two log-linear model architectures, Continuous Bag-of-Words (CBOW) and Skip-gram, that learn dense word vectors by removing the expensive non-linear hidden layer used in prior neural language models and training on billions of words.
FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness
FlashAttention is an exact attention algorithm that restructures the computation to avoid writing the large N x N attention matrix to GPU high bandwidth memory (HBM). It uses tiling to compute softmax block by block in fast on-chip SRAM and recomputes the attention matrix during the backward pass instead of storing it, all fused into a single CUDA kernel.
Generative Adversarial Networks
This is the original Generative Adversarial Nets (GAN) paper. It trains two neural networks simultaneously in a minimax game: a generator G that maps random noise to fake samples, and a discriminator D that tries to tell real training data from generated data, with both trained by ordinary backpropagation.
Improving neural networks by preventing co-adaptation of feature detectors
This is the original dropout paper: during training, each hidden unit is randomly omitted with probability 0.5 on every training case, which stops units from co-adapting to rely on specific other units. At test time you use the full network with outgoing weights halved, which approximates averaging over the exponentially many thinned networks.
Language Models are Few-Shot Learners
This is the GPT-3 paper: the authors train an autoregressive transformer language model with 175 billion parameters and evaluate it on over two dozen NLP tasks using in-context learning, where the model gets task demonstrations in its prompt at inference time with no gradient updates. They test three settings (zero-shot, one-shot, and few-shot with 10 to 100 examples in the context window) across eight model sizes to measure how performance scales.
Learning Transferable Visual Models From Natural Language Supervision
This is the CLIP paper. It trains an image encoder and a text encoder jointly on 400 million (image, text) pairs scraped from the internet, using a contrastive objective that predicts which caption goes with which image within a batch rather than predicting exact caption words. After pre-training, you build a classifier for any dataset by feeding the class names (as text prompts) through the text encoder, so the model classifies images it was never explicitly trained to label.
LLaMA: Open and Efficient Foundation Language Models
LLaMA is a family of transformer language models (7B to 65B parameters) trained only on publicly available datasets, using architectural changes like pre-normalization with RMSNorm, SwiGLU activations, and rotary positional embeddings. The models are trained on far more tokens than Chinchilla scaling laws recommend (up to 1.4T tokens), trading extra training compute for cheaper inference.
LoRA: Low-Rank Adaptation of Large Language Models
LoRA (Low-Rank Adaptation) freezes a pre-trained model's weights and injects trainable rank-decomposition matrices (a pair of small matrices B and A whose product approximates the weight update) into each Transformer layer, so only those small matrices are trained. In their Transformer experiments the authors apply it mostly to the query and value attention projection matrices.
Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer
The paper introduces the Sparsely-Gated Mixture-of-Experts (MoE) layer, a neural network component containing up to thousands of feed-forward expert sub-networks where a trainable gating network selects only a few experts to run per input token. It uses noisy top-k gating plus auxiliary load-balancing losses, and applies the layer between stacked LSTM layers for language modeling and machine translation.
Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
This paper introduces Retrieval-Augmented Generation (RAG), a fine-tuning recipe that pairs a pre-trained seq2seq generator (BART-large) with a neural retriever (Dense Passage Retriever) that pulls passages from a dense vector index of Wikipedia. It presents two variants: RAG-Sequence, which conditions the whole output on one retrieved document, and RAG-Token, which can draw a different document per generated token, with both retriever and generator trained end-to-end using only input/output pairs.
Sequence to Sequence Learning with Neural Networks
This paper introduces the sequence-to-sequence (seq2seq) encoder-decoder architecture: one multilayer LSTM reads an input sentence into a fixed-length vector, and a second LSTM decodes that vector into the output sentence one word at a time. It applies this to English-to-French machine translation and adds a key trick of reversing the word order of the source sentence before feeding it in.
Training Compute-Optimal Large Language Models
The paper studies how to split a fixed training compute budget between model size and number of training tokens, fitting three empirical estimators (minimum-over-training-curves, IsoFLOP profiles, and a parametric loss function) across over 400 models trained from 70M to 16B parameters. It finds model size and training tokens should scale in roughly equal proportion (doubling one means doubling the other), then validates this by training Chinchilla, a 70B model on 1.4T tokens, at the same compute as the 280B Gopher.
Training language models to follow instructions with human feedback
This is the InstructGPT paper, which fine-tunes GPT-3 to follow instructions using reinforcement learning from human feedback (RLHF). The pipeline has three stages: supervised fine-tuning on labeler-written demonstrations, training a reward model on human rankings of model outputs, and then optimizing the policy against that reward model using PPO.
Subscribe
Get the next issue.
Free. One email a week. Unsubscribe any time: no account, no dark patterns.