GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo
arXiv preprint

TinyStories: How Small Can Language Models Be and Still Speak Coherent English?

Trained on GPT-written stories that use only words a 3-year-old knows, models under 10 million parameters wrote fluent, consistent stories. GPT-4 graded them like a teacher grading students.

Breakdown by FDE Interviews · 10 min read · Updated

About the original · 2023
AUTHORS
Eldan, Li
FROM
Microsoft Research
PUBLISHED
May 2023 · arXiv preprint
CITED BY
590Semantic Scholar · Nov 2026
IN THIS BREAKDOWN · 10 SECTIONS

You can read 27% of this breakdown.

01

The paper in one minute

Models with around 125 million parameters, such as GPT-2 small, trained on broad web text, struggle to write a coherent paragraph. Eldan and Li ask whether that is about scale or about the data. A web corpus asks a model to learn grammar, facts about everything, and reasoning all at once. What if the corpus kept the core of language and reduced the world it describes?

They had GPT-3.5 and GPT-4 write TinyStories: short stories of a few paragraphs using only words a 3 to 4 year old would understand. To prevent the generators from repeating themselves, each prompt required one random noun, one random verb and one random adjective from a list of about 1,500 basic words, plus a random subset of features such as dialogue, a plot twist, a bad ending or a moral. A second version, TinyStories-Instruct, prefixes each story with instructions (words to include, a sentence to contain, features, or a summary) so models can be tested on following them.

They trained small GPT-Neo-style models, mostly from about 1M to 35M parameters (up to about 80M in one comparison) and from 1 to 8 layers, each in under 30 hours on one GPU. Evaluation used about 50 hand-written story beginnings: each model wrote 10 completions per beginning, and GPT-4 graded each like a teacher on grammar, creativity and consistency, plus plot and instruction-following for the instruct variant.

Even tiny models wrote fluent stories, and models with about 28M parameters tracked characters and plot consistently. Grammar emerged earliest; consistency and creativity needed more size. Depth helped context tracking, width helped factual knowledge. Attention heads and neurons in the smallest models had readable roles. The authors check for memorization with n-gram overlap and conclude the models produce new stories, while noting that copying of plot templates cannot be ruled out.

THE IDEA, VISUALLY
THE RECIPE (SECTION 2) 1 noun 1 verb 1 adjective from ~1,500 child-level words + random features: dialogue, twist, bad ending, moral... GPT-3.5 / GPT-4 writes a story train 1M-35M parameter models GPT-4 grades completions ~100M+ word triples x 64 feature subsets: billions of distinct prompts (our count), so the generator cannot repeat itself much. GPT-4 GRADES FOR ONE PROMPT (FIGURE 6) grammar creativity consistency 1M, 8 layers 6 3 2 2.5M, 8 layers 5 6 3 8.3M, 8 layers 7 5 5 28M, 8 layers 9 6 9 21M, 1 layer 8 3 7 The 1-layer model's completion has Lucy 'rescue Lucy'; the grader still gave consistency 7 of 10. ROUGE-2 CANNOT SEE A COPIED PLOT 0.29 completion vs closest story (paper) 0.33 our 14-word swap of a story 'Sara and Ben ... snowman ... dog' became 'Mia and Leo ... castle ... crab': same plot, same sentences, word-pair overlap as low as a new story. arXiv 2305.07759, Microsoft Research
Left: the recipe. Each story prompt picks one noun, one verb and one adjective from about 1,500 words a young child knows, plus a random subset of six story features, and GPT-3.5 or GPT-4 writes the story; with any split of the vocabulary that is billions of distinct prompts. Models from 1M to 33M parameters train on the result and are graded by GPT-4 on grammar, creativity and consistency. Right: the paper rules out copying with Rouge-2 overlap, reporting 0.29 between a completion and its closest training story; a story we made by swapping 14 words in a training story scores 0.33, so the check cannot catch copied plots.
Research notes: the problem, approach and results
below 10M

parameters at which models trained on TinyStories write fluent, consistent stories (abstract)

about 1,500

words in the child-level vocabulary; each prompt draws a noun, a verb and an adjective (Section 2)

0.29 vs 0.33

Rouge-2 of a completion to its closest training story (paper) and of our word-swapped copy to its source

THE PROBLEM

Small language models (around 100M parameters) trained on broad web text rarely produce coherent text beyond a few words. Is that because coherent language needs scale, or because broad corpora ask a small model to learn too much at once?

THE IDEA

Shrink the world, not the language. Generate a corpus of short stories with GPT-3.5 and GPT-4 restricted to a child's vocabulary, made diverse by random word and feature constraints, train tiny models on it, and grade their outputs with GPT-4 on grammar, creativity and consistency.

THE RESULT

Models below 10M parameters, and models with a single transformer layer, wrote fluent, mostly consistent multi-paragraph stories and showed simple reasoning. Grammar came first with size, consistency and creativity later; depth mattered for context tracking and width for facts. Small models were also easier to interpret.

02

Why it matters to an FDE

Narrow the domain to shrink the model. When a customer needs language generation in a tight domain (status messages, simple summaries, form-filling dialogue), a small model trained on a focused corpus can be enough. TinyStories is the clean demonstration that data scope, not only parameter count, decides what a small model can do.

Use random constraints to make synthetic data diverse. Asking a model for "a story" a million times gives near-copies. Forcing random combinations of required words and features spreads the outputs. The same trick works for synthetic tickets, emails or forms: sample required entities, intents and attributes per item.

A model grader gives multidimensional scores cheaply. GPT-4 scored grammar, creativity and consistency separately, which revealed that capabilities emerge at different sizes. For customer evaluations, separate rubric dimensions are more useful than one number, provided you calibrate the grader against people.

Overlap checks catch copying of words, not of structure. The paper's Rouge-2 tests show completions do not repeat training text word for word. Our test shows a training story with 14 words swapped scores as low as the paper's evidence of novelty. For customer models trained on templates, test for template reuse directly.

Watch the grader's leniency. In the paper's own table, a 1-layer model's completion in which a girl climbs a ladder "and rescued Lucy", herself, received 7 of 10 for consistency.

THE FULL BREAKDOWN

Understand the mechanism. Try it on a real problem.

Unlock this breakdown and 290 more papers.

Premium opens every paper in full, plus every answer, concept, course and guide on the site. One payment for six months of access.

6 months · One payment · No auto-renewal

Get Premium · ₹2,000 / $25
  • ◇1 architecture diagram
  • </>1 runnable code experiment
  • ▦2 results tables
  • ?5 interview questions with answers
  1. 03Key takeaways

    The dataset, model sizes, GPT-Eval, emergence by capability, depth vs width, limits

    Free account
  2. 04How it works

    Story generation, the instruct format, models, GPT-Eval, and the diversity checks

    Premium
  3. 05The numbers that matter

    Model sizes, example grades, where capabilities appear, and the overlap measurements

    Premium
  4. 06Try it yourself

    Count the prompt combinations, implement the paper's Rouge-2, and test it on a copied plot

    Premium
  5. 07Where it breaks

    A toy world, one grader, template copying, generator dependence, and no human calibration

    Premium
  6. 08Using it on a deployment

    Narrow corpora, constraint sampling, per-dimension grading, and template checks

    Premium
  7. 09Interview angles

    Five questions this paper prepares you for, with answer hints

    Premium
Back to the paper library →