Twitxy Saved

Michael Y. Li

Verified account This account is verified. Learn more

@michaelyli_

CS PhD @StanfordAILab @StanfordNLP advised by @noahdgoodman and Emily Fox.

Prev: undergrad @princeton
michaelyli.github.io Joined March 2024
548 Following 3.4K Followers 177 Posts

Latest posts 5

Pinned post

Michael Y. Li Verified account @michaelyli_
Can an LM, starting from random init (!!), learn to generate all of its pretraining data?

Introducing Self-Play Pretraining with Zero Data. Two models start from random initialization: a generator proposes programs for a universal Turing machine and a learner trains on their outputs. We never train on any real data, but see predictable scaling on natural datasets: zero-shot val loss on images, text, audio, and melodies decreases predictably with self-play compute. And the learner develops in-context learning capabilities.

A fun proof-of-concept, co-led with @AdityaCowsik and @KfirDolev and co-authors @gbruno_dl, @ANourya @noahdgoodman, and @YoavLevine.
85 replies 457 reposts 3.6K likes 756K views View on X
Michael Y. Li Verified account @michaelyli_
Some cool theory from Thomas on understanding when self-improvement via self-play is possible!
Thomas Chen @thomaschen__ Nov 8
How can an LLM self-improve at theorem proving? Inspired by STP (Dong & Ma, 2025), we propose a theoretical framework for understanding prover-conjecturer self-play algorithms. arxiv.org/abs/2606.01861. NeurIPS 2026, Sydney Poster Session 2, Tue 5-8pm @ Hall 1-4. 1/8
View quoted post on X
1 replies 10 reposts 90 likes 8.4K views View on X
Michael Y. Li Verified account @michaelyli_
A super elegant idea to use privileged information to fit smooth task-specific scaling laws!!

Really awesome and exciting work!
Suze van Adrichem Verified account @suze_va Nov 3
Can we forecast benchmark accuracy from models that score zero?

We (co-leads @LukeBailey181 @rckpudi) turn a benchmark into a series of easier hinted versions. Jointly modeling scale C and hint level H enables forecasting GSM8K acc (H=0) within 3 pts from 5600x less compute 🧵
View quoted post on X
1 replies 3 reposts 22 likes 1.4K views View on X
Michael Y. Li Verified account @michaelyli_
You're wasting FLOPs when scaling inference compute: by independently sampling parallel attempts, you burn compute rediscovering the same solutions.

Introducing QuasiMoTTo: we scale parallel sampling with correlated samples instead! These samples have higher coverage, are marginally exact draws from the LLM, and can be generated in parallel.

Result: same performance with 25-47% fewer samples in test-time scaling + 50% fewer training steps in RL!

In our new paper, we explore the design space of correlated samplers. Work with co-authors @probablynotaz9 (co-lead), @gandhikanishk, @noahdgoodman, and Emily Fox!
14 replies 72 reposts 291 likes 76K views View on X
Michael Y. Li Verified account @michaelyli_
Excited to share our new work on training language models to use multiple axes of inference compute — sequential, parallel, and aggregative — end-to-end, led by @jubayer_hamid and @ifdita_hasan.
LLMs already use many forms of compute at test time, so they should learn to use them during training too.

How do we train this? Learning to synthesize a better answer from multiple attempts can be handled with standard RL. The harder problem is teaching models to generate a set of traces that are useful together for a downstream synthesizer to produce a better final response. This leads naturally to a set RL formulation for training models to generate these traces.
Jubayer Ibn Hamid @jubayer_hamid Jun 23
The most capable reasoning systems in AI scale inference compute along several axes: sequential compute to think longer, parallel compute to sample many independent attempts, and aggregative compute to synthesize prior traces into a new improved one. But during training, we only optimize how models use sequential compute. This creates a fundamental mismatch between how we ultimately deploy these systems and how we train them, leaving much of search and synthesis unoptimized.

We introduce SPIRAL, an RL framework for making all inference-compute primitives end-to-end learnable: models learn to coordinate sequential, parallel, and aggregative reasoning using only the reward of the final output. Work with @ifdita_hasan (co-lead), @michaelyli_ , @oshaikh13 , @yoonholeee , @DorsaSadigh , @chelseabfinn , @noahdgoodman 🧵
View quoted post on X