> My favorite trick for controlling the reasoning level is the hack First described here I think, specifically for Qwen models: https://arxiv.org/abs/2501.19393, although it seems unclear how much it actually improves the final response unless you create a new fine-tuned model with this in mind, and also if it's possible to replicate for other models. Still, got inspired and gonna give it a try with DiffusionGemma although slightly differently
s1: Simple test-time scaling
Niklas Muennighoff, Zitong Yang, Weijia Shi
Show all 10 authors
Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, Tatsunori Hashimoto
2025 · arXiv
- HN score
- 0
- Mentions
- 10
- Readers
- 10
- Months
- 5
From the abstract
Test-time scaling is a promising new approach to language modeling that uses extra test-time compute to improve performance. Recently, OpenAI's o1 model showed this capability but did not publicly share its methodology, leading to many replication efforts. We seek the simplest approach to achieve test-time scaling and strong reasoning performance. First, we curate a small dataset s1K of 1,000 questions paired with reasoning traces relying on three criteria we validate through ablations: difficulty, diversity, and quality. Second, we develop budget forcing to control test-time compute by forcefully terminating the model's thinking process or lengthening it by appending "Wait" multiple times to the model's generation when it tries to end. This can lead the model to double-check its answer, often fixing incorrect reasoning steps. After supervised finetuning the Qwen2.5-32B-Instruct language model on s1K and equipping it with budget forcing, our model s1-32B exceeds o1-preview on competition math questions by up to 27% (MATH and AIME24). Further, scaling s1-32B with budget forcing allows extrapolating beyond its performance without test-time intervention: from 50% to 57% on AIME24. Our model, data, and code are open-source at https://github.com/simplescaling/s1
Metadata: arXiv. Abstracts retain their original authors’ rights.
In the conversation
Original HN comments, with labels from simple text rules. A label describes the whole comment and may miss context or irony. Read the discussion to make up your own mind. About the labels
10 selected excerpts · 10 total mentions
This is the same reasoning behind why Yann Lecun thought test-time scaling would not work for LLMs: compounding error. Instead, the more tokens LLMs use, the better their performance on many tasks. LLMs can self-correct, evidenced by the power of getting models to question themselves by emitting "Wait," in S1. https://arxiv.org/abs/2501.19393
>One theory is that the knowledge required to solve the task is already stored in the parameters of the model, and only the style has to change for task success >In particular, learning to generate longer outputs may be possible in few parameters Reminded me of: https://arxiv.org/abs/2501.19393 >we develop budget forcing to control test-time compute by forcefully terminating the model’s thinking process or lengthening it by appending “Wait” multiple times to the model’s generation when it tries to end. This can lead the model to double-check its answer, often fixing incorrect reasoning steps Maybe, indeed, the model simply learns to insert the EOS token (or similar) later, and the capability is already in the base model
a paper with a similar idea on scaling test time reasoning, this is sorta how all the thinking models work under the hood. https://arxiv.org/abs/2501.19393
I don’t think you have an accurate understanding of how LLMs work. https://arxiv.org/abs/2501.19393 These tokens DO extend the thinking time. We are talking about causal autoregressive language models, and so these tokens can be used to guide the generation.
If that's an issue, there's a workaround using structure generation to force it to output a </thiking> token after some threshold and force it to write the final answer. It's a method used to control thinking token generation showcased in this paper: https://arxiv.org/abs/2501.19393
Yes, the authors explicitly highlighted those two points in the abstract, in terms of them being the elicitation threshold for complex reasoning, namely, an extremely complete pre-trained foundation model, and a set of extremely high quality examples post-training. To your question on finetuning on the initial 10 million pool - intuitively, it would require tremendous amount of finetuning data to move the needle - you really won't be able to move the gradients much with just 817 examples, that initial pool is effectively enforcing pretty rigid regularization. There is now an increasing interest in showing that small data with inference time scaling is providing significant yield. Couple of recent examples: * TinyZero: https://github.com/Jiayi-Pan/TinyZero * s1 Simple Test Time Scaling: https://arxiv.org/abs/2501.19393
nope you have the article right. "if you copy an existing model, you can get a pretty comparable model!" Really, [what the underlying paper](https://arxiv.org/abs/2501.19393) shows is how much you can improve existing models with several of the techniques released by openai recently (extending thought processes via "wait") It shows we can get a lot of mileage out of that technique.
Agreed. Here are three things that I find surreal about the s1 paper. (1) The abstract changed how I thought about this domain (advanced reasoning models). The only other paper that did that for me was the "Memory Resource Management in VMware ESX Server". And that paper got published 23 years ago. (2) The model, data, and code are open source at https://github.com/simplescaling/s1. With this, you can start training your own advanced reasoning models. All you need is a thousand well-curated questions with reasoning steps. (3) More than half the references in the paper are from 2024 and Jan 2025. Just look at the paper's first page. https://arxiv.org/pdf/2501.19393 In which other field do you see this?
The file explains it a bit, but my blogpost https://xeiaso.net/notes/2025/s1-simple-test-time-scaling/ could probably be better explained. I'll write out more but just for you I'll summarize what I'm gonna end up writing up. AI models fundamentally work on the basis of "given what's before, what comes next?" When you pass messages to an API like: [ { "role": "system", content": "You are an expert in selling propane and propane accessories. Whenever someone talks about anything that isn't propane, steer them back." }, { "role": "user", "content": "What should I use to cook food on my grill?" }, { "role": "assistant", "content": "For cooking food on your grill, using…
Read the full comment
propane is a great choice due to its convenience and efficiency. [...]" } ] Under the hood, the model actually sees something like this (using the formatting that DeepSeek's Qwen 2.5 32b reasoning distillation uses): You are an expert in selling propane and propane accessories. Whenever someone talks about anything that isn't propane, steer them back. <|User|>What should I use to cook food on my grill?<|endofsentence|> <|Assistant|> And then the model starts generating tokens to get you a reply. What the model returns is something like: For cooking food on your grill, using propane is a great choice due to its convenience and efficiency. [...]<|endofsentence|> The runtime around the model then appends that as the final "assistant" message and sends it back to the user so there's a façade of communication. What I'm doing here is manually assembling the context window such that I can take advantage of that and then induce the model that it needs to think more, so the basic context window looks like: Follow this JSON schema: [omitted for brevity] <|User|>Tell me about Canada.<|endofsentence|> <|Assistant|><think>Okay And then the model will output reasoning steps until it sends a </think> token, which can be used to tell the runtime that it's done thinking and to treat any tokens after that as the normal chat response. However, sometimes the model stops thinking too soon, so what you can do is intercept this </think> token and then append a newline and the word "Wait" to the context window. Then when you send it back to the model, it will second-guess and double-check its work. The paper s1: Simple test-time scaling (https://arxiv.org/abs/2501.19393) concludes that this is probably how OpenAI implemented the "reasoning effort" slider for their o1 API. My index.js file applies this principle and has DeepSeek's Qwen 2.5 32b reasoning distillation think for three rounds of effort and then output some detailed information about Canada. In my opinion, this is the kind of thing that people need to be more aware of, and the kind of stuff that I use in my own research for finding ways to make AI models benefit humanity instead of replacing human labor.
Keep following the thread.
More in Language modelsMore from the same topics.
Sparks of Artificial General Intelligence: Early experiments with GPT-4
Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan +11
Artificial intelligence (AI) researchers have been developing and refining large language models (LLMs) that exhibit remarkable capabilities across a variety of domains and tasks, challenging our understanding of learning and cognition.
A Critique of the CAP Theorem
Martin Kleppmann
The CAP Theorem is a frequently cited impossibility result in distributed systems, especially among NoSQL distributed databases.
Language Models are Few-Shot Learners
Tom B. Brown, Benjamin Mann, Nick Ryder +28
Recent work has demonstrated substantial gains on many NLP tasks and benchmarks by pre-training on a large corpus of text followed by fine-tuning on a specific task.
Design Patterns for Securing LLM Agents against Prompt Injections
Luca Beurer-Kellner, Beat Buesser, Ana-Maria Creţu +11
As AI agents powered by Large Language Models (LLMs) become increasingly versatile and capable of addressing a broad spectrum of tasks, ensuring their security has become a critical challenge.