← Latest papers
🤖 machine learning

Bridging Compute- and Data-Optimal Pretraining

This paper introduces Compute-Data (CD) scaling laws, a unified framework that models the diminishing returns of derived data through a token-effectiveness function to bridge compute- and data-optimal pretraining regimes, revealing that classical compute-optimal allocation is suboptimal for most practical settings.

Original authors: Tian Qin, Kimia Hamidieh, David Alvarez-Melis

Published 2026-07-29
📖 6 min read🧠 Deep dive

Original authors: Tian Qin, Kimia Hamidieh, David Alvarez-Melis

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a giant, super-smart robot how to speak human language. For years, scientists believed the secret sauce was simple: just keep feeding the robot more and more new stories, facts, and books. The bigger the robot's brain (its "model size") and the more fresh books you gave it, the smarter it would get. This idea, known as "scaling laws," suggested that if you had enough computer power, you could just buy more data and the robot would keep getting better forever.

But there's a catch. We are running out of fresh, high-quality books. The internet is finite, and writing new, perfect stories takes time and money. Meanwhile, our computers are getting faster and cheaper by the day. This creates a weird problem: we have a super-powerful engine (compute) but a nearly empty gas tank (data). The big question for scientists became: If we can't get more fresh books, can we just make the robot read the same books over and over again, or rewrite them in different ways, to make it smarter? Does reading a story a second time help as much as reading a brand new one?

This is the puzzle that researchers Tian Qin, Kimia Hamidieh, and David Alvarez-Melis tackled in their new paper. They wanted to figure out the perfect recipe for training these AI models when fresh data is scarce. They developed a new set of rules called "Compute-Data (CD) scaling laws." Think of it as a new map for a journey where the old map said "keep driving straight," but the new map says, "Hey, the road is ending! Here's how to navigate the detours."

The team found that simply re-reading old data isn't a magic fix. They discovered that "derived tokens"—which are like re-reading a book or rewriting a sentence in your own words—are worth less than fresh, original text. The more you repeat or paraphrase, the less value each new word adds. It's like eating a delicious cake: the first slice is amazing, the second is good, but by the tenth slice, you're just full and not really enjoying it anymore.

To prove this, they trained dozens of AI models, ranging from tiny ones with 14 million "neurons" to medium-sized ones with 600 million, using a massive library of text called Dolma-3. They tested two main strategies: Multi-epoch repetition (reading the same book over and over) and Paraphrasing (rewriting the book in different styles, like turning a news article into a math problem or a FAQ).

Their results were surprising and very specific. They found that the "value" of re-reading or rewriting depends heavily on how big the robot's brain is and how much fresh data it already saw.

  • For small robots (under 600 million parameters) with limited fresh data, paraphrasing is a great trick. It's like giving the robot a new perspective on the same story, which helps it learn.
  • For big robots (over 7 billion parameters) or when you already have a lot of fresh data, paraphrasing stops working. It's like trying to teach a PhD student by rewriting a children's book; they've already learned the basics, and the new version doesn't add anything new.
  • Repetition (reading the same book again) works better for larger models, but even then, there's a limit. You can't just keep reading the same book forever and expect the robot to get infinitely smarter.

The paper introduces a special number, which they call η\eta (eta), to measure exactly how much a "derived" word is worth compared to a "fresh" word. If η\eta is 1, the new word is as good as a fresh one. If it's 0, it's useless. They found that η\eta isn't a fixed number; it drops as the model gets bigger and as you use more derived data.

This leads to three distinct "zones" of training, which helps engineers decide what to do next:

  1. Compute-Bound: You have plenty of fresh data but not enough computer power. Here, you should just keep training on fresh data.
  2. Data-Bound: You have run out of fresh data. Here, you can spend more computer power on repetition or paraphrasing, but you have to be careful because the returns drop off quickly.
  3. Model-Bound: You have used all the data you can, and the computer is maxed out. The only way to get smarter now is to build a bigger brain (a larger model).

One of the most practical takeaways is about how many times to read a book. A popular rule of thumb in the past was to read a dataset 4 times (4 epochs). The authors found this is only a good idea for medium-sized models with a specific amount of data. If you have a huge model or a massive dataset, reading it 4 times is a waste of time and money; you should stop much earlier. Conversely, for very small models with very little data, you might need to read it many more times.

They also compared the two strategies side-by-side. They found a "tipping point." If your model is small (under 600 million) and you don't have much data, paraphrasing is the winner. But once your model gets bigger (over 7 billion) or you have a huge dataset, repetition becomes the better choice, and paraphrasing actually becomes ineffective.

In short, this paper tells us that the era of "just buy more data" is over. We are entering a new era where we have to be smart about how we use the data we have. We can't just throw more computer power at the problem and expect it to work; we have to know exactly when to stop repeating, when to try rewriting, and when to admit that we need a bigger brain. The authors suggest that for most practical situations, the old "Chinchilla" rule (which assumed data was endless) is no longer the best guide. Instead, we need to balance our computer power, our model size, and our data budget carefully, using these new rules to avoid wasting time on tricks that don't work.

The researchers are pretty confident in these findings because they tested them across many different model sizes and data amounts, and the math held up. They even checked if the models trained with these tricks actually got better at real-world tasks (like answering questions or solving math problems), and yes, they did. The lower the "loss" (a measure of how confused the robot is), the better the robot performed.

So, the next time you hear about a new AI model, remember: it's not just about how much it read, but how it read it. And if you're the one training the AI, don't just keep hitting "repeat" on the same playlist; sometimes you need a remix, and sometimes you just need to stop and get a bigger brain.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →