Scaling Instruction-Finetuned Language Models

ArXiv: 2210.11416

🎯 Pitch

Adding just nine chain-of-thought datasets to instruction finetuning rescues—and actually improves—a model's reasoning ability, reversing the severe degradation seen when finetuning on non-CoT tasks alone. Scaling the number of tasks to 1.8K and model size to 540B yields a striking +9.4% average lift over PaLM, all for only 0.2% of pretraining compute.

---

1. Executive Summary

This paper studies how scaling three dimensions of instruction finetuning—the number of finetuning tasks, model size, and the inclusion of chain-of-thought data—affects performance and generalization across model families (PaLM, T5, U-PaLM), prompting setups (zero-shot, few-shot, CoT), and evaluation benchmarks (MMLU, BBH, TyDiQA, MGSM). The named mechanism is Flan (Finetuning language models), a multi-task instruction finetuning procedure that combines 1,836 tasks from four mixtures—Muffin, T0-SF, NIV2, and a novel CoT mixture of nine reasoning datasets—using templates that mix exemplar and zero-shot formats alongside chain-of-thought annotations. Scaling to 540B parameters and 1.8K tasks yields a +9.4% normalized average improvement over PaLM 540B, with Flan-PaLM achieving new state-of-the-art on five-shot MMLU at 75.2%, while the joint finetuning of non-CoT and CoT data improves all evaluations and unlocks zero-shot reasoning via "let's think step-by-step"—establishing that instruction finetuning generalizes across architectures and combines with other adaptation techniques like UL2R, but that scaling the number of tasks shows diminishing returns beyond 282 tasks and CoT performance degrades when CoT data is excluded from the finetuning mixture.

2. Context and Motivation

The Core Problem: Pretrained Language Models Perform Better When Instruction-Finetuned, But We Don't Know How Scaling Affects This

The central question this paper addresses is deceptively simple: if instruction finetuning improves language model performance, what happens when you aggressively scale it? Instruction finetuning—training a pretrained language model on a collection of tasks phrased as natural language instructions—had emerged in the year preceding this paper as a promising technique for improving model generalization to unseen tasks and reducing dependence on few-shot exemplars. However, prior work had explored this idea at relatively small scale: models up to 137B parameters, task mixtures up to a few hundred tasks, and without systematic attention to how reasoning tasks (specifically chain-of-thought reasoning) fit into the picture.

This gap matters because the scaling behavior of instruction finetuning—whether performance improvements continue as models grow larger, whether adding more tasks yields diminishing returns, and whether reasoning abilities survive the finetuning process—directly determines whether instruction finetuning is a technique worth investing compute in as models scale to hundreds of billions of parameters. Without understanding these scaling dynamics, researchers and practitioners cannot make principled decisions about how to allocate compute between pretraining and finetuning, or how many tasks to include in their finetuning mixture.

The practical stakes are high. As the authors note in Section 7, instruction finetuning consumed only 0.2% of pretraining compute for PaLM 540B while delivering a +9.4% normalized average improvement—this is an enormous return on a tiny compute investment. But without evidence that this efficiency holds at larger scales (or with more tasks), the community lacked confidence that instruction finetuning should become a standard, expected step in the LLM training pipeline rather than an optional post-processing trick.

The Brittleness of Pretrained Models Without Finetuning

A secondary motivation, discussed specifically in Section 6, is usability. Pretrained language models, even very capable ones like PaLM 540B, exhibit several failure modes when presented with zero-shot instructions:

• They continue generating related text instead of directly answering the question
• They repeat the input question with minor modifications rather than producing an answer
• They don't know when to stop generating text

The authors attribute these failures to an artifact of pretraining objectives: models trained solely on next-token prediction (without end-of-sequence tokens marking completion in the pretraining data) haven't learned the conversational turn-taking or task-completion semantics that instruction finetuning implicitly teaches. Figure 9 provides concrete examples—PaLM 540B, given a prompt asking it to "make up a word," instead keeps asking more questions; given a math problem with few-shot exemplars, it repeats the input and generates continuously rather than producing an answer.

This usability gap is significant because it limits who can practically use these models. Without instruction finetuning, users need to engage in careful prompt engineering and provide few-shot exemplars to get models to behave correctly. Instruction finetuning addresses this by exposing models to tasks formatted as instructions with clear input-output boundaries, teaching them the pattern of receiving a request and producing an appropriate response.

Prior Work Operated at Smaller Scale on Fewer Axes

The paper's positioning relative to prior work is carefully constructed in Section 8. Instruction finetuning was not a new idea in 2022, but prior studies had explored only fragments of the full scaling picture:

Wei et al. (2021) introduced FLAN, showing that instruction finetuning a 137B-parameter model on 62 tasks improved zero-shot performance on unseen tasks. But this work was limited to a single model size and a modest number of tasks, with no exploration of chain-of-thought reasoning.

Sanh et al. (2021) applied instruction finetuning to T5 models up to 11B parameters using the T0 task mixture (193 tasks). This demonstrated generalization across architectures but at a scale an order of magnitude smaller than this paper's largest models, and again without CoT data.

Wang et al. (2022c) scaled to 1,600+ tasks with Natural Instructions v2 but used only a 3B-parameter model, leaving open the question of whether task scaling benefits compound with model size scaling.

Ouyang et al. (2022) showed that instruction finetuning (via supervised finetuning and RLHF) improved human preference ratings and zero-shot capabilities, but this work used a very different methodology (human demonstrations and reinforcement learning from human feedback) and didn't systematically study the relationship between model size, number of tasks, and downstream benchmark performance.

What was missing was a joint scaling analysis: what happens when you simultaneously scale the model size (by two orders of magnitude, from 8B to 540B), the number of tasks (by an order of magnitude, from tens to 1.8K), and introduce chain-of-thought reasoning data into the finetuning mixture? No prior work had explored the interactions between these three dimensions, nor examined whether instruction finetuning's benefits generalize across model architectures (encoder-decoder vs. decoder-only), pretraining objectives (causal LM, span corruption, prefix LM), and evaluation paradigms (direct prompting, chain-of-thought prompting, zero-shot, few-shot) simultaneously.

The Chain-of-Thought Blind Spot in Prior Instruction Finetuning

A critical, and initially surprising, finding that motivates this work is what the authors call a degradation of reasoning abilities when instruction finetuning excludes CoT data. Section 4.2 demonstrates that finetuning a model on only non-CoT tasks (the standard practice in prior work) actually decreases performance on held-out CoT benchmarks compared to no finetuning at all. Figure 5-left shows this clearly: the "Non-CoT" finetuning line (green) falls below the "No finetuning" line on held-out CoT benchmarks.

The authors explain this as a prompting paradigm mismatch: when finetuning data trains the model to produce direct answers (e.g., "yes" or "no"), the model learns to suppress the chain-of-thought behavior of generating intermediate reasoning steps before the final answer. On non-reasoning tasks, this is fine—direct answers are appropriate. But on tasks that genuinely require multi-step reasoning (arithmetic, symbolic manipulation, logical deduction), the model loses its ability to engage in the extended deliberation that CoT prompting normally elicits.

Prior instruction finetuning work had not identified this problem because (1) they typically evaluated only on non-CoT NLP tasks (e.g., sentiment analysis, natural language inference), and (2) the models they used were often too small for CoT reasoning to emerge in the first place (CoT is an emergent ability that only appears at sufficient scale, as shown in Wei et al., 2022a). This paper's recognition of the CoT degradation problem—and its solution through joint finetuning on both CoT and non-CoT data—is a key motivation that distinguishes it from prior work.

The Diminishing Returns Question: Does Scaling Tasks Matter?

Another open question the paper addresses is whether increasing the number of finetuning tasks continues to improve performance or plateaus quickly. Prior work had observed that multi-task finetuning improves generalization to unseen tasks, but the shape of the scaling curve was unknown. If adding tasks yields strong diminishing returns after a few dozen tasks, the community's effort would be better spent on diversifying task templates (different ways of phrasing the same task) rather than hunting for more distinct tasks.

Figure 4 (right panel) reveals that the answer is nuanced: the majority of improvement comes from scaling from 0 to 282 tasks (the Muffin + T0-SF combination), with additional gains from scaling to 1,836 tasks being positive but much smaller. This suggests that instruction finetuning's primary benefit is teaching the model to better express knowledge it already possesses from pretraining, rather than teaching it fundamentally new capabilities through additional task examples. The authors explicitly note that the finetuning data contains only 1.4B tokens—just 0.2% of the pretraining token count—which makes it implausible that the model is learning substantial new world knowledge from the finetuning data. Instead, the finetuning data teaches the model how to respond when given task instructions, a meta-skill that saturates relatively quickly.

This finding has practical implications: for researchers building instruction finetuning mixtures, hunting down hundreds of additional niche tasks may not be worth the engineering effort when the bulk of the benefit comes from a moderate-sized, diverse mixture.

How This Paper Positions Itself

The paper explicitly frames itself as a scaling study, not a proposal of a fundamentally new method. The authors acknowledge that each individual component—instruction finetuning, multi-task training, chain-of-thought—was established in prior work. Their contribution is demonstrating how these components interact at scale and establishing empirical regularities (scaling curves, CoT degradation thresholds, diminishing returns points) that guide future research and deployment decisions.

This positioning is reinforced by the paper's structure: rather than introducing a novel loss function, architecture, or training algorithm, the authors apply a consistent finetuning recipe (Section 2.2: Adafactor optimizer, constant learning rate, packing, single checkpoint) across a wide range of model families and scales, varying only the key experimental variables (number of tasks, inclusion of CoT data, model size). The scientific contribution is in the systematic empirical characterization of scaling behavior, not in algorithmic innovation.

The paper also positions itself at the intersection of compute-efficiency and capability improvement. Table 2 is central to this framing: it shows that instruction finetuning requires only 0.2–1.6% of pretraining compute across all model sizes. This makes instruction finetuning one of the most compute-efficient known methods for improving language model performance—more efficient than continued pretraining with larger datasets, architectural improvements, or simply scaling model size. By demonstrating this across architectures (T5 encoder-decoder, PaLM decoder-only, U-PaLM with UL2 objective), the authors make the case that instruction finetuning should be a default step in the language model development pipeline, comparable to how pretraining itself became standard after the BERT/GPT era.

3. Technical Approach

3.1 Reader orientation

This paper develops Flan—a multi-task instruction finetuning procedure that transforms a standard pretrained language model into one that reliably follows natural language instructions across hundreds of unseen tasks. The system takes an existing pretrained checkpoint (PaLM, T5, or U-PaLM, spanning 80M to 540B parameters), trains it on a carefully constructed mixture of 1,836 tasks formatted with diverse instruction templates, and produces a single fine-tuned checkpoint that performs well across zero-shot, few-shot, and chain-of-thought evaluation paradigms without any task-specific adaptation at test time. The "shape" of the solution is a scaling study: rather than introducing a novel algorithm, the paper systematically varies the number of finetuning tasks, model size, and the inclusion of chain-of-thought reasoning data to characterize how instruction finetuning's benefits scale, where they plateau, and where they interact with model architecture and pretraining objective.

3.2 Big-picture architecture (diagram in words)

The Flan pipeline has four major components:

1. Pretrained base models — the starting checkpoints. These span three architectural families: PaLM (decoder-only, causal LM objective), T5 (encoder-decoder, span corruption objective), and U-PaLM (decoder-only, prefix LM + span corruption via UL2). Sizes range from Flan-T5-small (80M parameters) to PaLM/U-PaLM (540B parameters).

2. The finetuning data mixture — a collection of 1,836 tasks drawn from four source mixtures (Muffin, T0-SF, NIV2, and a novel CoT mixture). Each task consists of examples paired with instruction templates that specify the task in natural language. The templates are formatted in four combinatorial variants: with or without few-shot exemplars, and with or without chain-of-thought reasoning.

3. The finetuning procedure — a single-stage supervised finetuning process using the Adafactor optimizer with a constant learning rate schedule, packing multiple training examples into each sequence, and training for a fixed number of steps (typically 14K–98K depending on model size). The procedure consumes only 0.2–1.6% of the compute used for pretraining.

4. Evaluation protocol — the fine-tuned model is tested on four held-out benchmark suites (MMLU, BBH, TyDiQA, MGSM) under multiple prompting paradigms (direct prompting, CoT prompting, zero-shot, few-shot). None of these evaluation tasks appear in the finetuning data.

Information flows linearly: a pretrained checkpoint enters the finetuning pipeline → the model is trained on the 1,836-task mixture with the appropriate hyperparameters (learning rate, batch size, dropout, number of steps, chosen separately per model size) → the resulting single Flan checkpoint is evaluated across all benchmarks and prompting setups without any further task-specific adaptation.

3.3 Roadmap for the deep dive

• First, the finetuning data mixture construction, since it is the foundation that everything else depends on. This includes the four source mixtures (Muffin, T0-SF, NIV2, CoT), their task counts and categories, the template formatting rules, and how exemplar and CoT variants are generated.

• Second, the finetuning procedure itself—the optimizer, learning rate schedule, packing mechanism, hyperparameter selection, and checkpoint selection strategy—since these are the engineering choices that determine whether the data mixture actually improves the model.

• Third, the evaluation protocol and metrics, including the normalized average computation, the specific prompting setups for each benchmark, and the distinction between direct and CoT evaluation.

• Fourth, the scaling experiment design in Section 3, which iteratively adds task mixtures and varies model size to produce the joint scaling curves in Figure 4.

• Fifth, the chain-of-thought finetuning experiments in Section 4, including the ablation that reveals CoT degradation and the zero-shot reasoning evaluation.

• Sixth, the cross-model generalization experiments in Section 5, which apply the same Flan recipe to T5, cont-PaLM, and U-PaLM.

3.4 Detailed, sentence-based technical breakdown

This is primarily a scaling empirical study whose core idea is that instruction finetuning benefits transfer across architectures and scales, but that specific design choices—including CoT data in the mixture, balancing task mixtures appropriately, and selecting hyperparameters per model size—determine whether the resulting model improves across all evaluation paradigms or degrades on reasoning tasks.

---

Finetuning Data Mixture Construction

The finetuning data comprises 1,836 total tasks drawn from four previously existing mixtures plus a novel chain-of-thought reasoning mixture, as summarized in Figure 2. The paper distinguishes carefully between three levels of granularity: a Dataset is an original data source (e.g., SQuAD), a Task Category is a unique task setup (e.g., the SQuAD dataset can be configured for extractive question answering, query generation, or context generation), and a Task is a unique (dataset, task category) pair, potentially with multiple templates that preserve the task category.

Muffin (80 tasks). This mixture comprises 62 tasks from Wei et al. (2021)—the original FLAN mixture—plus 26 new tasks added in this work, including dialog data from Taskmaster (Byrne et al., 2019), QReCC (Anantha et al., 2021), and Wiki Dialog (Dai et al., 2022), plus program synthesis data from Dr Repair (Yasunaga and Liang, 2020) and DeepMind Coding Contests (Li et al., 2022). The dialog and code additions are notable because they extend the task types beyond traditional NLP classification and QA into interactive and generative domains. Table 24 provides explicit citations for each individual dataset. Muffin contains 55 datasets across 14 task categories.

T0-SF (193 tasks). "SF" stands for "sans Flan"—this is the T0 mixture from Sanh et al. (2021) with tasks that overlap with Muffin removed to avoid duplication. T0-SF contains 69 datasets across 27 task categories. The removal of overlapping tasks is important because duplicating tasks in the finetuning mixture would effectively overweight those tasks during training, potentially distorting the model's behavior toward the duplicated task types.

NIV2 (1,554 tasks). This is Natural Instructions v2 from Wang et al. (2022c), containing 372 datasets across 108 task categories. The authors removed 44 tasks related to MMLU from NIV2 because MMLU serves as one of the primary held-out evaluation benchmarks—including MMLU tasks in finetuning would contaminate the evaluation and inflate apparent performance. This careful data hygiene (removing evaluation-related tasks from training) is essential for claiming generalization to unseen tasks. NIV2 tasks span cause-effect classification, commonsense reasoning, named entity recognition, toxic language detection, question answering, question generation, program execution, text categorization, and many other categories.

CoT mixture (9 tasks). This is a novel contribution of this work: a collection of nine reasoning datasets for which human raters manually wrote chain-of-thought annotations for the training corpus. The nine datasets are: GSM8K (grade-school math, Cobbe et al., 2021), StrategyQA (multi-hop reasoning, Geva et al., 2021), AQuA (algebraic question answering, Ling et al., 2017), CREAK (commonsense reasoning over entity knowledge, Onoe et al., 2021), ECQA (explanations for CommonsenseQA, Aggarwal et al., 2021), ESNLI (natural language inference with explanations, Camburu et al., 2018), QASC (question answering via sentence composition, Khot et al., 2020), QED (explanations in question answering, Lamm et al., 2021), and SenseMaking (sense making and explanation, Wang et al., 2019b). The CoT mixture contains 74,730 total training examples, with per-dataset counts reported in FAQ A.4: AQuA (2,715), CREAK (6,910), ECQA (7,110), ESNLI (36,170), GSM8K (7,470), QASC (1,080), QED (5,145), Sensemaking (6,070), StrategyQA (2,060). Each dataset has exactly 10 manually composed instruction templates.

Template formatting. For each task in the four mixtures, instructional templates are applied that express the task in natural language. The paper uses four formatting variants created by crossing two binary choices (Figure 3):

1. Instruction without exemplars (zero-shot format): The input consists of an instruction phrase followed by the specific input. For example: "Answer the following yes/no question. Can you write a whole Haiku in a single tweet?" The target is simply the answer: "yes."

2. Instruction with exemplars (few-shot format): The input includes one or more exemplar input-output pairs before the target question, delimited by markers like "Q:" and "A:". For example: "Q: Answer the following yes/no question. Could a dandelion suffer from hepatitis? A: no Q: Answer the following yes/no question. Can you write a whole Haiku in a single tweet? A:" The model must produce the answer for the final question.

3. Instruction with CoT but without exemplars (zero-shot CoT format): The instruction includes a chain-of-thought trigger phrase. For example: "Answer the following yes/no question by reasoning step-by-step. Can you write a whole Haiku in a single tweet?" The target includes the reasoning chain: "A haiku is a japanese three-line poem. That is short enough to fit in 280 characters. The answer is yes."

4. Instruction with CoT and exemplars (few-shot CoT format): The input includes exemplars with reasoning chains, followed by the target question. For example: "Q: Answer the following yes/no question by reasoning step-by-step. Could a dandelion suffer from hepatitis? A: Hepatitis only affects organisms with livers. Dandelions don't have a liver. The answer is no. Q: Answer the following yes/no question by reasoning step-by-step. Can you write a whole Haiku in a single tweet? A:" The model must produce both reasoning and answer.

For the CoT mixture specifically, the authors manually wrote approximately 10 instruction templates per dataset. For few-shot templates, they wrote a variety of exemplar delimiters (e.g., "Q:"/"A:" variants) and applied them randomly at the example level. This template diversity is important because it prevents the model from overfitting to a specific phrasing pattern and encourages it to extract the underlying task semantics from varied surface forms.

An important distinction: only the nine CoT datasets use the CoT formatting (variants 3 and 4 above). For all other tasks in Muffin, T0-SF, and NIV2, only the non-CoT formats (variants 1 and 2) are used. Additionally, some data formats use only few-shot exemplars without explicit instructions, following the approach of Min et al. (2022)—these are noted but not shown in Figure 3. This mixture of formats means the model sees instructions alongside exemplars, instructions alone, and occasionally exemplars alone, teaching it to respond appropriately in all three scenarios.

Task sampling and balancing. Within each of the four mixtures, tasks are weighted by their number of examples during sampling. However, to prevent very large datasets (some WMT translation datasets have millions of examples) from dominating the mixture, the authors apply a maximum example cap per task. Table 23 specifies these caps and the resulting mixture proportions:

• Muffin: max cap 30,000 examples, proportion 52% (Proportion A) or 46.0% (Proportion B)
• T0-SF: max cap 20,000 examples, proportion 15% (A) or 27.9% (B)
• CoT: max cap 100,000 examples, proportion 3% (A) or 1.8% (B)
• NIV2: max cap 5,000 examples, proportion 30% (A) or 24.2% (B)

Two proportion schemes were used. Proportion A was used for the scaling and ablation experiments in Sections 3 and 4. Based on those experiments—which showed strong gains from the T0-SF mixture—the authors updated to Proportion B for the remaining models. The caps and proportions determine how often each mixture's examples appear in a training batch: for Proportion B, roughly 46% of training examples come from Muffin, 28% from T0-SF, 2% from CoT, and 24% from NIV2. The CoT mixture's relatively small proportion (1.8–3%) is noteworthy because Section 4 shows that even this small amount of CoT data is sufficient to prevent degradation on reasoning tasks.

Data scale. The total finetuning data contains approximately 1.4 billion tokens, compared to the 780 billion tokens used in PaLM pretraining—a ratio of roughly 0.2%. This stark asymmetry is central to one of the paper's key claims: the model is not learning substantially new factual knowledge during finetuning (the finetuning data is too small to meaningfully add to the knowledge encoded in 780B pretraining tokens), but rather learning the meta-skill of interpreting and responding to task instructions.

---

Finetuning Procedure

The finetuning procedure is designed to be simple, consistent across model families, and compute-efficient. The authors explicitly state that no exotic techniques are introduced; the contribution is in the systematic application of established methods at scale.

Optimizer and schedule. All models use the Adafactor optimizer (Shazeer and Stern, 2018) with a constant learning rate schedule—no warmup, no decay, the learning rate stays fixed throughout finetuning. Adafactor is a memory-efficient variant of Adam that factorizes the second-moment accumulator, making it practical for very large models. The constant schedule choice is unusual (most training recipes use cosine decay or linear warmup-decay) but the authors found it worked well, likely because finetuning runs are short relative to pretraining and the model starts from a well-initialized checkpoint.

Packing. The procedure uses packing (Raffel et al., 2020), which concatenates multiple training examples into a single sequence until the sequence reaches the maximum input length. Examples are separated by an end-of-sequence token, and a masking mechanism prevents tokens from one packed example from attending to tokens from another packed example across the boundary. Packing increases training throughput by reducing wasted computation on padding tokens—instead of having each short example in its own sequence with padding to reach max length, multiple short examples share the same sequence. The authors note that packing makes the effective batch size larger than the reported global batch size, because each sequence contributes gradients from multiple examples.

Hyperparameter selection. Table 22 provides the complete hyperparameter configuration for all finetuned models. The three most important hyperparameters identified by the authors are learning rate, batch size, and dropout:

• Flan-T5 models (80M–11B): Batch size 64, dropout 0.05, learning rate 5×10⁻⁴. Number of steps decreases with model size: 98K for Small, 84K for Base, 64K for Large, 38K for XL, 14K for XXL. The decreasing step count with increasing model size is typical—larger models learn faster per example and require fewer updates, plus each update is more expensive.

• Flan-PaLM 8B and 62B: Batch size 32, dropout 0.05, learning rate 3×10⁻³, 40K steps. The higher learning rate (3×10⁻³ vs. 5×10⁻⁴ for T5) reflects differences in model architecture and pretraining objective—decoder-only models trained with causal LM may have different optimal finetuning learning rates than encoder-decoder models.

• Flan-PaLM 540B: Batch size 32, dropout 0.1, learning rate 1×10⁻³, 21K steps. The increased dropout (0.1 vs. 0.05) for the largest model suggests overfitting becomes more of a concern at 540B scale, even with a short 21K-step finetuning run. The lower learning rate (1×10⁻³ vs. 3×10⁻³ for 8B/62B) is also consistent with larger models being more sensitive to learning rate.

• Flan-cont-PaLM 62B: Batch size 32, dropout 0.05, learning rate 3×10⁻³, 60K steps. The increased step count (60K vs. 40K for standard Flan-PaLM 62B) reflects that continued-pretrained models may benefit from longer finetuning.

• Flan-U-PaLM 540B: Batch size 32, dropout 0.1, learning rate 1×10⁻³, 30K steps (vs. 21K for Flan-PaLM 540B), again suggesting that the UL2 continued pretraining changes the finetuning dynamics.

Checkpoint selection. For each model, a single checkpoint is used for all evaluations. The optimal step is chosen based on periodic evaluations (every 2K steps for smaller models, every 10K steps for the 540B model) on the set of held-out evaluation tasks. The same number of checkpoint steps is used across all ablation runs for a given model—this means the comparisons between different task mixtures (e.g., 9 tasks vs. 282 tasks in Table 3) control for training duration and isolate the effect of the mixture composition. The authors do not use validation loss for checkpoint selection because, in a multi-task finetuning setting with diverse output formats, validation loss correlates poorly with downstream task performance.

Compute cost. Table 2 reports the finetuning FLOPs and the percentage of pretraining compute for each model:

• Flan-T5-Small (80M): 2.9×10¹⁸ FLOPs, 1.6% of pretraining compute
• Flan-T5-XXL (11B): 7.6×10¹⁹ FLOPs, 0.2% of pretraining compute
• Flan-PaLM 540B: 5.6×10²¹ FLOPs, 0.2% of pretraining compute

The 540B model's finetuning required approximately 512 v4 TPU chips for 37 hours. This cost asymmetry—0.2% of pretraining compute yielding a +9.4% normalized average improvement—is the economic argument for instruction finetuning as a default step in the LLM pipeline.

Hardware and framework. All models are trained using the JAX-based T5X framework (Bradbury et al., 2018; Roberts et al., 2022) on TPU v3 or TPU v4 accelerators (Jouppi et al., 2020).

---

Evaluation Protocol and Metrics

The evaluation protocol is designed to measure generalization to unseen tasks across multiple dimensions: world knowledge, reasoning ability, multilinguality, and mathematical problem solving. All evaluation benchmarks are held-out—none appear in the finetuning mixture.

Evaluation benchmarks. Four benchmark suites are used, all of which were also used in the PaLM paper (Chowdhery et al., 2022) and found to have no meaningful data contamination with pretraining data:

1. MMLU (Massive Multitask Language Understanding, Hendrycks et al., 2020): 57 tasks covering exam questions from domains including mathematics, history, law, and medicine. Evaluated with five-shot in-context exemplars—the model sees five example question-answer pairs before being asked to answer the target question. MMLU is evaluated both via direct prompting (the model directly predicts the answer letter or text) and CoT prompting (the model generates a reasoning chain before the final answer). The MMLU results in the main tables use the "validation" set; Table 4 and Table 1 report test set results.

2. BBH (BIG-Bench Hard, Suzgun et al., 2022): 23 challenging tasks from BIG-Bench (Srivastava et al., 2022), specifically those where PaLM performed below average human raters. Evaluated with three-shot exemplars. BBH tasks are stratified into NLP tasks and algorithmic tasks for analysis. Evaluated both via direct and CoT prompting.

3. TyDiQA (Clark et al., 2020): A question-answering benchmark across 8 typologically diverse languages (Arabic, Bengali, Finnish, Indonesian, Korean, Russian, Swahili, Telugu—English is not included in the average). Evaluated with one-shot exemplars, measuring exact match (EM) score with direct prompting only (CoT is not used since highlighting answer spans in a passage does not require multi-step reasoning).

4. MGSM (Multilingual Grade School Math, Shi et al., 2022): Math word problems from the GSM8K benchmark manually translated into 10 languages (Bengali, German, Spanish, French, Japanese, Russian, Swahili, Telugu, Thai, Chinese). Evaluated with 8-shot exemplars using CoT prompting only (direct prompting has very low performance). For MGSM, exemplars and chains of thought are provided in the same language as the target language (e.g., for Chinese evaluation, all exemplars and reasoning chains use Chinese text), following the "native language" protocol from Shi et al. (2022).

Normalized average metric. To produce a single aggregate metric across all benchmarks, the paper reports a normalized average following the "normalized preferred metric" convention from BIG-Bench (Srivastava et al., 2022). The normalization scales each benchmark's raw score with respect to a task-specific lower bound (typically random guessing) so that 0% represents random-guessing-level performance and 100% represents perfect performance. Specifically:

$\text{Normalized score} = 100 \times \frac{\text{Raw score} - \text{Lower bound}}{\text{Upper bound} - \text{Lower bound}}$

where the lower bound is the accuracy of random guessing (e.g., 25% for a 4-way multiple choice task) and the upper bound is 100% accuracy.

The normalized average is the macro-average (unweighted mean) over six normalized scores: MMLU-Direct, MMLU-CoT, BBH-Direct, BBH-CoT, TyDiQA-Direct, and MGSM-CoT. This treats each of the six evaluation settings as equally important, regardless of the absolute difficulty or number of subtasks within each benchmark.

Direct vs. CoT evaluation distinction. For MMLU and BBH, the model is evaluated in two separate ways: direct prompting (the model outputs the answer immediately) and CoT prompting (the model outputs a reasoning chain followed by "The answer is [X]"). For TyDiQA, only direct prompting is used since the task involves extracting answer spans from a passage, which the paper argues does not require multi-step reasoning. For MGSM, only CoT prompting is used because direct prompting produces very low accuracy on math word problems. The separate reporting of direct and CoT scores is important because Section 4 demonstrates that the relationship between finetuning data composition and CoT performance is qualitatively different from the relationship with direct performance—specifically, finetuning on only non-CoT data can improve direct performance while degrading CoT performance.

Few-shot exemplar counts. The number of in-context exemplars follows conventions from prior work: five-shot for MMLU, three-shot for BBH, one-shot for TyDiQA, and 8-shot for MGSM. For MMLU, the "dev" set serves as the source of few-shot exemplars.

Answer grading. MMLU uses multiple-choice scoring (selecting the correct option letter); BBH uses exact match or multiple-choice scoring depending on the task; TyDiQA uses exact match of the answer span; MGSM uses exact match of the final numerical answer. The paper references the grading functions from the respective benchmark papers.

Open-ended generation evaluation (Section 6). In addition to the benchmark evaluations, the paper conducts a human rater study on 190 open-ended examples across five categories (creativity, reasoning over contexts, complex reasoning, planning, and explanation) with 20 questions each. For 60 of these (from complex reasoning, planning, and explanation), a CoT trigger phrase variant is created. Additionally, 30 few-shot inputs are included. For both PaLM and Flan-PaLM, five responses are generated using temperature sampling with τ = 0.7, ranked by log probability score without length normalization, and the best-scoring response is selected after filtering out generations with scores better than half the median score (a heuristic to remove degenerate repetitions). Human raters then compare the PaLM and Flan-PaLM outputs pairwise and select the preferred response, with each pair scored by one rater. The rating instructions (Appendix I) ask raters to prioritize correctness and informativeness.

---

Scaling Experiment Design (Section 3)

The core scaling experiments systematically vary two factors: model size (8B, 62B, 540B PaLM models) and number of finetuning tasks (by sequentially adding task mixtures: starting from CoT-only with 9 tasks, then adding Muffin to reach 89 tasks, then T0-SF to reach 282 tasks, then NIV2 to reach 1,836 tasks).

Sequential mixture stacking. The mixtures are added in order of increasing size, from smallest to largest: CoT (9 tasks) → Muffin (80 tasks, cumulative 89) → T0-SF (193 tasks, cumulative 282) → NIV2 (1,554 tasks, cumulative 1,836). This design allows measuring the marginal benefit of each additional mixture. The intermediate sizes (89, 282) are not arbitrary—they represent specific combinations of known mixture collections, enabling comparison with prior work that used individual mixtures (e.g., Wei et al. 2021 used 62 tasks similar to Muffin; Sanh et al. 2021 used T0 with ~193 tasks). The baseline is "no finetuning" (0 tasks), representing the pretrained checkpoint evaluated with standard few-shot prompting.

Why this stacking order matters. The order is deliberately chosen so that earlier mixtures (CoT, Muffin) are smaller and more curated, while later mixtures (NIV2) are larger and more diverse but potentially noisier. If the order were reversed, the marginal benefit of adding a small, curated mixture might appear larger simply because it cleans up noise from a large, diverse mixture rather than because it provides genuinely new signal. By starting small and adding, the experiment measures the signal contribution of each mixture independently.

The joint scaling plot. Figure 4 shows two complementary views:

• Left panel (model size on x-axis): For each of five mixture sizes (0, 9, 89, 282, 1,836 tasks), a curve showing normalized average performance across the three model sizes (8B, 62B, 540B). This reveals whether the benefit of more tasks interacts with model size—e.g., does adding more tasks help large models more than small models? The answer from the figure is that the gap between the 1,836-task line and the 0-task line is roughly constant across model sizes (approximately 15 percentage points for 8B, 10 for 62B, 9 for 540B), suggesting that task scaling benefits are additive rather than multiplicative with model scale.

• Right panel (number of tasks on x-axis): For each of the three model sizes, a curve showing normalized average performance across the five mixture sizes. This reveals the shape of the task-scaling curve—specifically, whether it plateaus or continues to rise. The answer is clear: the majority of the gain comes between 0 and 282 tasks, with the jump from 282 to 1,836 tasks providing a much smaller improvement (approximately 1–2 percentage points across model sizes).

Interpretation of the plateau. The authors offer two explanations for the diminishing returns beyond 282 tasks (Section 3): (1) the additional 1,554 NIV2 tasks are not sufficiently diverse—they may cover task types already present in the earlier mixtures—so they don't teach the model anything new; (2) instruction finetuning's primary benefit is teaching the model to better express knowledge it already has from pretraining, and once the model has seen enough task formats (roughly 282 tasks' worth), it has learned the meta-skill of instruction-following and additional tasks provide minimal further improvement. The second explanation is favored because the finetuning data is only 1.4B tokens compared to 780B pretraining tokens—the model cannot be learning substantial new factual knowledge from the finetuning data.

Table 3 results structure. The full results for the scaling experiment are in Table 3, which reports per-benchmark accuracy (MMLU-direct, MMLU-CoT, BBH-direct, BBH-CoT, TyDiQA-direct, MGSM-CoT) and the normalized average for each combination of model size (8B, 62B, 540B) and mixture composition (0, 9, 89, 282, 1,836 tasks). The table also reports the delta from the baseline (no finetuning) for each step, making the marginal benefit of each added mixture explicit.

---

Chain-of-Thought Finetuning Experiments (Section 4)

The CoT experiments address three questions: (1) Does including CoT data in the finetuning mixture improve held-out reasoning performance? (2) What happens to reasoning ability when CoT data is excluded? (3) Does CoT finetuning enable zero-shot reasoning?

The CoT degradation ablation (Section 4.2, Figure 5). This is the most scientifically significant experiment in the CoT section. The authors compare three finetuning configurations:

• CoT + non-CoT: The full 1,836-task mixture including both CoT and non-CoT tasks.
• Non-CoT only: The 1,836-task mixture with the 9 CoT datasets removed (leaving 1,827 non-CoT tasks).
• CoT only: Only the 9 CoT datasets (no other instruction finetuning data).

These are evaluated on two separate sets of benchmarks: held-out CoT benchmarks (MMLU-CoT, BBH-CoT, MGSM-CoT) and held-out non-CoT benchmarks (MMLU-direct, BBH-direct, TyDiQA-direct). Figure 5 shows two panels:

• Left panel (held-out CoT benchmarks): The CoT + non-CoT configuration (blue) outperforms both non-CoT only (green) and CoT only (orange) across all model sizes. Critically, the non-CoT only line falls substantially below the no finetuning line (gray)—meaning that finetuning on only non-CoT tasks degrades CoT reasoning ability compared to not finetuning at all. For the 540B model, non-CoT-only finetuning drops CoT performance from approximately 49% (no finetuning) to approximately 37%—a ~12 percentage point drop. This is the central finding: finetuning on tasks that require direct answers teaches the model to suppress the chain-of-thought behavior that reasoning tasks need.

• Right panel (held-out non-CoT benchmarks): CoT + non-CoT finetuning (blue) and non-CoT-only finetuning (green) perform similarly, both substantially above no finetuning. Importantly, CoT-only finetuning (orange) underperforms, showing that the 9 CoT datasets alone are not sufficient for general instruction-following. The combined mixture gets the best of both worlds: it doesn't degrade CoT (because CoT data is present) and it improves non-CoT (because the bulk of the finetuning data is non-CoT tasks that teach instruction-following).

Why the degradation happens. The authors' interpretation (Section 4.2) is that there is a prompting paradigm mismatch: when 99.5% of the finetuning data (1,827 out of 1,836 tasks) trains the model to produce direct answers without reasoning chains, the model learns to map instructions directly to answers. When subsequently prompted with CoT instructions like "let's think step-by-step" at evaluation time, the model's learned behavior—jump directly to the answer—conflicts with the desired behavior of generating intermediate reasoning. The CoT data, which constitutes only 0.5% of the mixture, is sufficient to preserve the reasoning capability because it provides explicit counterexamples to the "answer directly" pattern, reminding the model that some tasks require extended reasoning.

Zero-shot reasoning experiment (Section 4.3, Figure 6). A separate experiment evaluates whether CoT finetuning enables zero-shot CoT reasoning on BBH tasks. The evaluation uses the phrase "let's think step-by-step" (from Kojima et al., 2022) appended to the zero-shot prompt, without any few-shot CoT exemplars. Four configurations are compared:

• PaLM: Zero-shot (standard zero-shot prompting, no CoT trigger)
• PaLM: Zero-shot + CoT (zero-shot with "let's think step-by-step")
• Flan-PaLM: Zero-shot (standard zero-shot prompting)
• Flan-PaLM: Zero-shot + CoT (zero-shot with "let's think step-by-step")

Figure 6 shows that Flan-PaLM benefits substantially from the CoT trigger phrase across all three model sizes (8B, 62B, 540B), with the 540B model improving from approximately 45% (zero-shot without CoT) to approximately 57% (zero-shot with CoT) on BBH accuracy. In contrast, PaLM shows essentially no benefit from the CoT trigger phrase—the "PaLM: Zero-shot" and "PaLM: Zero-shot + CoT" lines overlap. This demonstrates that CoT finetuning teaches the model the behavior of generating step-by-step reasoning in response to CoT trigger phrases, a behavior that pretraining alone does not reliably instill.

Figure 7 provides qualitative examples: on three BBH tasks (Snarks, Boolean Expressions, Disambiguation QA), PaLM 540B fails to produce coherent chains of thought when prompted with "Let's think step by step"—it either produces wrong answers, doesn't answer the question, or never stops generating. Flan-PaLM 540B, in contrast, produces structured, step-by-step reasoning that leads to the correct answer. These examples make concrete the abstract pattern in Figure 6.

CoT + self-consistency results (Table 4). The paper also reports results combining CoT prompting with self-consistency (SC; Wang et al., 2022b), a technique that samples multiple CoT reasoning paths and selects the most common final answer. Flan-PaLM 540B with CoT + SC achieves 75.2% on five-shot MMLU (test set), 78.4% on BBH-NLP, 66.5% on BBH-algorithmic, and 72.0% on MGSM—all new state-of-the-art results at the time of publication. The self-consistency results are reported only in Table 4, not in the main scaling tables, because self-consistency involves additional computation (multiple sampling passes) beyond the single-generation evaluations used in the scaling analyses.

---

Cross-Model Generalization Experiments (Section 5)

The cross-model experiments test whether the Flan recipe transfers to models with different architectures, pretraining objectives, and training stages. Five model families are evaluated (Table 5):

T5 models (80M–11B). Encoder-decoder architecture, trained with span corruption objective (masking spans of text and generating the missing spans). Without instruction finetuning, T5 models used as baselines are "LM-adapted" versions (Lester et al., 2021)—T5 checkpoints further trained on 100B additional tokens from C4 with a standard language modeling objective, which improves their few-shot prompting ability compared to raw T5. Despite this strong baseline, Flan-T5 models show the largest improvements: Flan-T5-XXL (11B) improves normalized average from -2.9% to 23.7% (+26.6 percentage points). T5 models benefit disproportionately because they are not multilingual (unlike PaLM) and start from a much lower baseline on challenging benchmarks like MMLU and TyDiQA. Flan-T5-XL (3B) achieves 52.4% on MMLU-direct, surpassing GPT-3 175B's 43.9%.

PaLM models (8B, 62B, 540B). Decoder-only architecture, trained with causal language modeling objective. The improvements are substantial but smaller than T5 because PaLM's baseline is higher: +15.5% for 8B, +10.4% for 62B, +9.3% for 540B.

cont-PaLM (62B). A PaLM 62B checkpoint initialized from the standard PaLM-62B and then pretrained for an additional 500B tokens. Instruction finetuning on top of this continued pretraining yields +8.6% normalized average (46.7% vs. 38.1% for the no-finetuning baseline). This shows that instruction finetuning combines productively with continued pretraining—the gains are not redundant.

U-PaLM (540B). A PaLM 540B checkpoint further pretrained with the UL2 objective (Tay et al., 2022a,b) for 20,000 additional steps. UL2 combines causal language modeling, prefix language modeling, and span corruption into a unified objective. Flan-U-PaLM achieves 59.1% normalized average vs. 50.2% for the no-finetuning baseline (+8.9%). This is the strongest model in the paper, demonstrating that UL2 continued pretraining and instruction finetuning are complementary compute-efficient methods—UL2 improves the model's representations through a better pretraining objective, while Flan teaches the model to use those representations for instruction-following.

The generality claim. The consistent improvements across all five model families—despite differences in architecture (encoder-decoder vs. decoder-only), pretraining objective (span corruption, causal LM, UL2), scale (80M to 540B), and baseline performance (from negative normalized averages for small T5 models to ~50% for 540B PaLM)—support the paper's central claim that instruction finetuning is a general technique that should be applied to virtually all pretrained language models. The relative compute cost (0.2–1.6% of pretraining, Table 2) makes this recommendation economically feasible.

---

Design Choices and Their Justifications

Constant learning rate over decay schedules: The finetuning runs are short (14K–98K steps) relative to pretraining, so a constant rate avoids the complexity of tuning a decay schedule without meaningful downside—the model starts from a strong initialization and doesn't need to be annealed to a low learning rate to converge.

Packing over per-example sequencing: Packing increases throughput by reducing padding waste. The masking mechanism ensures packed examples don't cross-contaminate via attention, maintaining the same gradient signal as separate sequences. The end-of-sequence separator teaches the model to recognize task boundaries.

Single checkpoint over checkpoint averaging or ensembling: Using a single checkpoint selected by periodic evaluation on held-out tasks is simple and standard. The same step count is used across all ablation runs for a given model, ensuring fair comparison. The authors explicitly note they did not use validation loss for selection because it correlates poorly with downstream task performance in multi-task setups.

Mixing CoT and non-CoT data rather than separate models: Training a single model on both data types is motivated by the observation (Section 4.2) that finetuning on only one type degrades the other. The joint training produces a single checkpoint that works across all evaluation paradigms, which is practically valuable (users don't need to know in advance whether their task requires reasoning or not). The small proportion of CoT data (1.8–3% of the mixture) is sufficient because it provides counterexamples to the dominant "answer directly" pattern.

Two-stage mixture proportions: Using Proportion A for scaling experiments and Proportion B for final models reflects an iterative optimization: early experiments revealed that T0-SF was undervalued in the initial proportions, so the authors increased its weight for the production models. This is a practical engineering choice rather than a principled design, but it highlights the importance of mixture balancing.

Maximum example caps over proportional sampling: Capping per-task example counts at 5,000–100,000 prevents very large datasets (some WMT translation datasets have millions of examples) from dominating training. Without caps, the model would spend most of its training on translation, at the expense of the diverse NLP tasks that instruction finetuning is meant to improve. The specific cap values were presumably chosen empirically, though the paper does not detail this process.

Removing MMLU-related tasks from NIV2: This is a data hygiene measure essential for valid evaluation. Including MMLU-like tasks in finetuning would make MMLU a partially held-in benchmark, inflating apparent generalization performance. The removal of 44 tasks is a small price for methodological validity.

The normalized average as an aggregate metric: Macro-averaging across benchmarks with normalization to a random-guessing baseline prevents any single benchmark from dominating the aggregate. The normalization also makes the metric more interpretable—a score of 0% means "no better than guessing," while a score of 100% would mean perfect performance. This is borrowed directly from BIG-Bench conventions.

4. Key Insights and Innovations

Innovation 1: Instruction Finetuning Degrades Chain-of-Thought Reasoning Unless CoT Data Is Included—A Diagnostic Finding That Reframes How We Think About Multi-Task Training

This is the paper's most intellectually distinctive contribution: not a new method, but a diagnostic discovery that reveals a previously invisible failure mode of multi-task instruction finetuning. Before this work, the dominant assumption—inherited from Wei et al. (2021), Sanh et al. (2021), and related work—was that instruction finetuning on a diverse set of tasks improves generalization to unseen tasks across the board. The implicit model was that finetuning teaches a general "instruction-following" meta-skill that transfers positively to any task phrased as an instruction, regardless of whether the unseen task requires reasoning chains or direct answers.

The paper shatters this assumption with a clean ablation. Figure 5-left shows that finetuning on only non-CoT tasks (1,827 tasks, representing 99.5% of the full mixture) causes a substantial drop in held-out CoT benchmark performance compared to no finetuning at all. For the 540B model, this is approximately a 12-percentage-point normalized average decline. This is not a small negative transfer effect—it is a complete reversal of the expected benefit. The model that saw 1,827 tasks of instruction training performs worse on reasoning than the pretrained checkpoint that saw none.

What makes this a genuine innovation rather than an obvious observation is that the degradation was invisible to prior work because prior work evaluated instruction-finetuned models primarily on non-CoT tasks (sentiment analysis, natural language inference, extractive QA) using models too small for CoT reasoning to emerge in the first place. The degradation only becomes visible when you (1) use a model large enough for CoT to work (62B+), and (2) explicitly evaluate on held-out CoT benchmarks. The field had simply never looked for this problem at the right scale.

The underlying mechanism—which the paper correctly diagnoses—is a prompting paradigm mismatch. When the finetuning data trains the model to map instructions directly to answers (the format for all non-CoT tasks), the model learns to suppress the chain-of-thought behavior of generating intermediate reasoning steps. This is fundamentally different from catastrophic forgetting (where the model loses knowledge); instead, it is a behavioral shift: the model still possesses the knowledge and reasoning capability, but it has been trained not to use the extended generation format that reasoning tasks require. The degradation is in output formatting, not in capability.

The significance of this finding extends beyond the paper's own solution (jointly finetuning on CoT and non-CoT data). It establishes a new principle for multi-task finetuning: tasks that require different output paradigms (direct answer vs. chain-of-thought, single-turn vs. multi-turn, classification vs. generation) can be in competition during training, not just additive. You cannot assume that "more tasks = better generalization" without verifying that the tasks aren't teaching conflicting behaviors. This principle has implications for the design of any multi-task instruction mixture beyond the specific CoT/non-CoT distinction—it suggests that researchers must actively balance representation of qualitatively different output formats, not just task types.

The paper's solution—including just nine CoT datasets (0.5% of the mixture) to prevent the degradation—is notable for its asymmetry. You don't need equal representation of CoT and non-CoT data; you just need enough CoT examples to serve as counterexamples to the dominant "answer directly" pattern. The 9 datasets contain only 74,730 examples total, yet they are sufficient to preserve reasoning ability in a 540B model. This is a practical insight: the mixing ratio between conflicting paradigms need not be balanced; a small minority of counterexamples can prevent catastrophic behavioral shift.

This finding also reconciles previously contradictory results in the literature. Huang et al. (2022) showed that CoT finetuning improves reasoning on held-in tasks, while instruction finetuning papers without CoT data reported no benefits for reasoning. The contradiction wasn't about whether reasoning can be improved through finetuning—it was about whether the specific finetuning mixtures used in different papers happened to include CoT data. This paper makes that diagnosis explicit.

Innovation 2: Joint Scaling Curves for Model Size and Number of Finetuning Tasks Reveal Diminishing Returns, Reframing the Resource Allocation Question from "Collect More Tasks" to "Diversify Smarter"

Before this paper, the community had two separate, incomplete pictures of instruction finetuning scaling. Wei et al. (2021) showed that scaling model size (from small models to 137B) improved instruction-finetuned performance, but used only 62 tasks. Wang et al. (2022c) showed that scaling tasks (to 1,600+) improved performance, but used only a 3B model. What was missing was the joint scaling picture—how these two axes interact, and whether the benefits compound or saturate.

Figure 4 provides this joint picture, and the result is a nuanced one that challenges simplistic "scale everything" intuitions. The left panel (performance vs. model size for different numbers of tasks) shows that the gap between the 1,836-task line and the 0-task line remains roughly constant across model sizes—approximately 15 percentage points of normalized average for 8B, 10 for 62B, 9 for 540B. This is a roughly additive relationship: scaling tasks and scaling model size provide independent, non-interacting benefits. There is no super-linear compounding where more tasks help large models disproportionately more.

The right panel (performance vs. number of tasks for different model sizes) reveals the shape of the task-scaling curve: the majority of the gain comes between 0 and 282 tasks, with the jump from 282 to 1,836 tasks providing only 1–2 additional percentage points. This diminishing return is robust across all three model sizes.

This finding reframes the resource allocation question for instruction finetuning. If you have a fixed budget for curating finetuning data, the curve suggests you should prioritize a moderate-sized, diverse mixture (on the order of a few hundred tasks covering qualitatively different task types) rather than exhaustively collecting every available dataset. The marginal benefit of the 1,554 additional NIV2 tasks is small relative to the engineering effort of integrating them. This is a practical, actionable insight that the paper's scaling curves make quantitative.

The paper offers two explanations for the diminishing returns, and the choice between them has different implications. Explanation 1: The additional tasks are not sufficiently diverse—they cover task types already present in the first 282 tasks, so they are redundant. If true, the solution is to find complementary task types rather than more tasks. Explanation 2: Instruction finetuning's primary benefit is teaching the model a meta-skill (instruction-following) that saturates after exposure to a few hundred task formats, because the model isn't learning new knowledge from the finetuning data (which is only 0.2% of pretraining tokens). If true, increasing task diversity beyond a saturation point will never help, and effort should shift to other approaches (better pretraining data, continued pretraining, larger models).

The paper favors Explanation 2, but the data doesn't conclusively distinguish between them. The key fact supporting Explanation 2 is the token count asymmetry: 1.4B finetuning tokens vs. 780B pretraining tokens. It's implausible that the finetuning data teaches substantial new world knowledge. But this doesn't rule out Explanation 1—it's possible that a curated set of 282 genuinely diverse tasks saturates the space of "ways to format NLP instructions," and adding 1,554 more from the same distribution adds no new formats. Future work could test this by constructing a set of 1,800 tasks with deliberately maximized diversity (e.g., spanning modalities, languages, and output formats not covered by the first 282) and measuring whether the curve continues upward.

Innovation 3: Instruction Finetuning Unlocks Zero-Shot Chain-of-Thought Reasoning, Demonstrating That the "Let's Think Step-by-Step" Capability Is Learned Rather Than Emergent

Kojima et al. (2022) discovered that appending the phrase "Let's think step-by-step" to a prompt could elicit chain-of-thought reasoning in large language models, improving performance on reasoning tasks without few-shot exemplars. However, that paper showed this working primarily on InstructGPT (which was instruction-finetuned) and on PaLM for math word problems only. The generalizability of zero-shot CoT to diverse reasoning tasks—and whether it required instruction finetuning or was a pure emergent property of scale—was unclear.

Figure 6 provides the clarifying evidence. On the 23 challenging BBH tasks, PaLM 540B (without instruction finetuning) shows essentially zero benefit from the "let's think step-by-step" trigger phrase—the zero-shot and zero-shot+CoT lines overlap. Flan-PaLM 540B, in contrast, gains approximately 12 percentage points from the CoT trigger. At smaller scales (8B, 62B), the pattern is similar: Flan-PaLM benefits from the trigger, PaLM does not.

This finding demonstrates that zero-shot CoT reasoning is not a purely emergent property of model scale—it requires instruction finetuning that includes CoT-format data. The pretrained PaLM 540B has the reasoning capability (it can do CoT when given few-shot exemplars, as shown in Table 4), but it hasn't learned to associate the phrase "let's think step-by-step" with the behavior of generating intermediate reasoning steps. Instruction finetuning on data that pairs CoT trigger phrases with reasoning chains teaches this association.

The significance is both practical and conceptual. Practically, zero-shot CoT is valuable because few-shot exemplars for CoT require careful prompt engineering—choosing exemplars with high-quality reasoning chains, formatting them correctly, and fitting them within context length constraints. A model that can be activated with a simple trigger phrase dramatically reduces the barrier to getting good reasoning performance. Conceptually, this finding separates two things that were previously conflated in discussions of emergent abilities: the capability to reason step-by-step (which may emerge with scale) and the behavior of doing so in response to a zero-shot trigger (which requires training on that specific input-output pattern). Scale alone is not sufficient for the latter.

The qualitative examples in Figure 7 make this vivid. PaLM 540B, prompted with "Let's think step by step" on the Boolean Expressions task, produces a garbled chain that doesn't answer the question. On Snarks, it rambles without reaching a conclusion. On Disambiguation QA, it correctly identifies the ambiguity but never stops generating. Flan-PaLM produces structured, goal-directed reasoning that reaches the correct answer. These are not differences in underlying logical capability—PaLM can do these tasks with few-shot exemplars—but differences in whether the model has learned to map the CoT trigger to the appropriate reasoning format.

This result also explains the apparent contradiction in Kojima et al. (2022): zero-shot CoT worked on InstructGPT (which the authors of this paper hypothesize included some CoT-like instruction finetuning data) and on PaLM for math word problems (a narrow domain where the model's pretraining may have incidentally taught it to generate step-by-step solutions), but not on PaLM for broader reasoning tasks. The missing ingredient was explicit training on CoT-formatted data across diverse reasoning types.

Innovation 4: Instruction Finetuning Combines Additively with Other Compute-Efficient Adaptation Methods, Establishing a Modular Improvement Stack for Language Models

Section 5 demonstrates that instruction finetuning can be applied on top of other model improvement techniques—specifically UL2 continued pretraining (U-PaLM) and extended pretraining (cont-PaLM)—and that the benefits are approximately additive. Flan-U-PaLM 540B achieves a normalized average of 59.1%, compared to 50.2% for U-PaLM without finetuning (+8.9 points) and 49.1% for base PaLM without finetuning. The total gain from base PaLM to Flan-U-PaLM is 10.0 points, which decomposes roughly into +1.1 from UL2 continued pretraining (50.2 - 49.1) and +8.9 from instruction finetuning (59.1 - 50.2).

This additivity is not obvious a priori. UL2 continued pretraining changes the model's pretraining objective (adding span corruption and prefix LM to the standard causal LM), which could have made the model's representations less compatible with instruction finetuning. The fact that instruction finetuning works equally well on top of UL2 (U-PaLM: +8.9%), standard PaLM (+9.3%), and continued-pretrained PaLM (cont-PaLM: +8.6%) suggests that instruction finetuning operates on a different axis of model capability than pretraining objective optimization.

This finding reframes instruction finetuning as a modular improvement that can be stacked with other techniques rather than a competing approach. The paper makes this framing explicit: "instruction finetuning and UL2 continued pre-training are complementary compute-efficient methods to improve the performance of language models without increasing model scale." This is significant because the field has many proposed methods for improving language models—better architectures, improved training objectives, larger datasets, continued pretraining, parameter-efficient finetuning—and understanding which combine productively versus redundantly is essential for practical model development.

The compute efficiency of instruction finetuning (0.2% of pretraining compute for the 540B model) makes this modularity particularly valuable. You can take an existing checkpoint that has already been optimized through architecture search, pretraining objective selection, and continued pretraining, and then apply instruction finetuning as a final, low-cost step that provides a substantial capability boost without requiring retraining from scratch. The paper's release of Flan-T5 checkpoints (which include the instruction finetuning on top of publicly available T5 models) operationalizes this modular approach for the research community.

The generality across architectures (encoder-decoder T5 vs. decoder-only PaLM), pretraining objectives (span corruption, causal LM, UL2), and scales (80M to 540B) further supports the modularity claim. Instruction finetuning is not coupled to any specific architectural choice or pretraining recipe—it is a general post-processing step that improves instruction-following behavior as long as the underlying model has sufficient capability to benefit.

Innovation 5: The CoT Degradation Finding Implies a New Constraint on Multi-Task Training—Conflicting Output Paradigms Require Explicit Counterexamples

This is the most conceptual of the innovations, building on Innovation 1 to extract a general principle. The CoT degradation experiment (Section 4.2) reveals that when a model is trained on tasks that share input formats (instructions in natural language) but differ in output formats (direct answers vs. reasoning chains), the dominant output format can suppress the minority format. This is not a simple matter of imbalanced data—it is a behavioral competition where the model learns a default mapping from "instruction → direct answer" that overrides the "instruction → reason then answer" mapping, even though the model retains the capability to reason.

This principle has implications beyond CoT. Any multi-task training setup where tasks differ in their expected output structure—single-label classification vs. multi-label generation, single-turn response vs. multi-turn dialogue, extractive answer vs. abstractive summary—may exhibit similar suppression effects if one paradigm dominates. The finding suggests a design rule for instruction mixtures: for each qualitatively distinct output paradigm you want the model to preserve, you must include explicit training examples that demonstrate that paradigm, even if they constitute only a small fraction of the total data.

The small fraction part is empirically important. The nine CoT datasets comprise only ~75,000 examples out of millions in the full mixture, yet they are sufficient to prevent degradation. This suggests a threshold effect rather than a proportional relationship: you don't need balanced representation of all paradigms, you just need enough examples of each paradigm to prevent the model from learning that "instructions always map to direct answers." The paper doesn't identify the threshold (how few CoT examples would still work?), but the existence of a threshold at all is a useful diagnostic concept for future mixture design.

This innovation is more theoretical than empirical—the paper doesn't test other conflicting output paradigms, so the generalizability of the principle is speculative. But the pattern is clear enough and the mechanism plausible enough that it should influence how researchers think about multi-task instruction tuning. The naive "more tasks = better generalization" assumption that dominated early instruction finetuning work (including Wei et al., 2021) is replaced by a more nuanced understanding: more tasks help only if the additional tasks don't teach conflicting behaviors, and conflicting behaviors need explicit representation in the training data to coexist in the model.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The primary evaluation uses four held-out benchmark suites: MMLU (57 tasks, exam questions from mathematics, history, law, medicine; Hendrycks et al., 2020), BBH (23 challenging tasks from BIG-Bench where PaLM performed below average human raters; Suzgun et al., 2022), TyDiQA (question answering across 8 typologically diverse languages; Clark et al., 2020), and MGSM (multilingual math word problems translated into 10 languages; Shi et al., 2022). These benchmarks were also used in the PaLM paper (Chowdhery et al., 2022) and found to have no meaningful data contamination with pretraining data. For MMLU, the main tables report "validation" set performance, while Table 4 and Table 1 use the test set. MMLU-related tasks were explicitly removed from the finetuning mixture to preserve held-out status.

• Base model(s). Experiments span five model families: PaLM (8B, 62B, 540B) — decoder-only, causal LM objective; T5 (80M, 250M, 780M, 3B, 11B) — encoder-decoder, span corruption objective; cont-PaLM (62B) — PaLM-62B continued-pretrained for 500B additional tokens; U-PaLM (540B) — PaLM-540B continued-pretrained with the UL2 objective for 20K steps. These span the full range from 80M to 540B parameters, three architectural paradigms, and multiple pretraining objectives. T5 models without instruction finetuning are "LM-adapted" versions (Lester et al., 2021), which were trained on 100B additional tokens from C4 with a language modeling objective to improve few-shot performance—this is a stronger baseline than raw T5 checkpoints.

• Metrics. The primary metric is normalized average across six evaluation configurations: MMLU-Direct, MMLU-CoT, BBH-Direct, BBH-CoT, TyDiQA-Direct, and MGSM-CoT. Each benchmark score is normalized following the BIG-Bench convention: normalized score = 100 × (raw score − lower bound) / (upper bound − lower bound), where the lower bound is typically random guessing accuracy (e.g., 25% for 4-way multiple choice). The normalized average is the unweighted macro-average of the six normalized scores. Raw per-benchmark metrics use accuracy (exact match for TyDiQA and MGSM, multiple choice for MMLU, task-dependent for BBH). For the open-ended generation evaluation in Section 6, the metric is human rater preference between PaLM and Flan-PaLM outputs.

• Baselines. The primary baseline is the pretrained model without instruction finetuning, evaluated under the same few-shot prompting protocol. For T5 models, this baseline uses LM-adapted checkpoints. Additional baselines include: prior state-of-the-art models such as code-davinci-002 (Chen et al., 2021), text-davinci-002/003, Chinchilla (Hoffmann et al., 2022), and PaLM (Chowdhery et al., 2022). For MMLU specifically, Table 1 benchmarks against GPT-3 5-shot (43.9%), Chinchilla 5-shot (67.6%), and PaLM 5-shot (69.3%). For BBH, baselines stratified by NLP and algorithmic tasks come from Suzgun et al. (2022). For TyDiQA, the prior best is finetuned ByT5 (Xue et al., 2022) at 81.9%. For MGSM, the prior best is PaLM + Google Translate API with CoT prompting (Shi et al., 2022) at 55.0%.

• Generation budget / compute accounting. For the finetuning procedure, compute is measured in FLOPs (floating point operations) using standard approximations from the scaling laws literature. Pretraining FLOPs and finetuning FLOPs are reported for each model in Table 2. The finetuning portion ranges from 0.2% (Flan-PaLM 540B: 5.6×10²¹ FLOPs finetuning vs. 2.5×10²⁴ FLOPs pretraining) to 1.6% (Flan-T5-Small 80M: 2.9×10¹⁸ vs. 1.8×10²⁰). At inference time, all evaluations use a single generation (no beam search, no multiple samples except for the CoT + self-consistency results reported separately in Table 4). This makes the evaluation cost negligible compared to the reported finetuning costs.

• Cross-validation / statistical protocol. No formal cross-validation or statistical significance testing is reported for the benchmark evaluations. Checkpoint selection uses periodic evaluations (every 2K steps for smaller models, every 10K steps for 540B) on the held-out evaluation tasks; the optimal step is chosen and the same step count is used across all ablation runs for a given model. The open-ended generation evaluation (Section 6) uses 190 examples with one human rater per example, with PaLM and Flan-PaLM outputs presented in randomized order to blind the rater to which model produced which output.

Main Quantitative Results

Scaling Model Size and Number of Finetuning Tasks (Section 3, Figure 4, Table 3)

Headline finding: Instruction finetuning improves normalized average performance by 9.4–15.5 percentage points across all model sizes (8B, 62B, 540B), with the majority of the gain coming from scaling to 282 tasks and diminishing returns beyond that.

The joint scaling experiment in Figure 4 and Table 3 varies two factors simultaneously: model size (8B, 62B, 540B PaLM) and number of finetuning tasks (0, 9, 89, 282, 1,836). At the full 1,836-task setting, Flan-PaLM 540B achieves a normalized average of 58.5%, compared to 49.1% for PaLM 540B without finetuning (+9.4 points). The absolute gains for smaller models are larger: 21.9% vs. 6.4% for 8B (+15.5), 38.8% vs. 28.4% for 62B (+10.4).

The task-scaling curve (Figure 4, right panel) shows a pronounced elbow. For the 540B model, performance moves from 49.1% (0 tasks) → 52.6% (9 tasks, +3.5) → 57.0% (89 tasks, +7.9) → 57.5% (282 tasks, +8.4) → 58.5% (1,836 tasks, +9.4). The jump from 0 to 282 tasks accounts for 8.4 of the total 9.4-point gain for 540B; adding the remaining 1,554 NIV2 tasks (from 282 to 1,836) yields only +1.0 additional points. The pattern is consistent across model sizes: for 8B, the 0→282 gain is +14.1 points (from 6.4% to 20.5%), and the 282→1,836 gain is +1.4 points (to 21.9%); for 62B, the 0→282 gain is +9.5 points (28.4% to 37.9%), and the 282→1,836 gain is +0.9 points (to 38.8%).

The model-size scaling curve (Figure 4, left panel) shows that the gap between finetuned and non-finetuned models remains roughly constant as models scale: the 1,836-task line is approximately 15 points above the 0-task line at 8B, approximately 10 points above at 62B, and approximately 9 points above at 540B. The authors note that whether this represents a decreasing or constant effect depends on whether you measure absolute gain (which shrinks slightly: 15.5 → 10.4 → 9.4) or relative error reduction (which is more stable: 16.6% for 8B, 14.5% for 62B, 18.4% for 540B).

Per-benchmark breakdown (Table 3). At 540B with 1,836 tasks, Flan-PaLM achieves 73.2% on MMLU-direct, 68.1% on MMLU-CoT, 58.8% on BBH-direct, 65.6% on BBH-CoT, 67.4% on TyDiQA-direct, and 61.3% on MGSM-CoT. Comparing to the no-finetuning baseline, the largest improvements are on TyDiQA (+14.5 percentage points, from 52.9% to 67.4%) and MGSM (+15.4 points, from 45.9% to 61.3%), while MMLU-direct shows a more modest gain (+1.9 points, from 71.3% to 73.2%) because it was already high.

An anomalous pattern appears in the CoT-only finetuning (9 tasks) results in Table 3: for the 62B model, the normalized average with CoT-only finetuning is 29.0%, only +0.4 points above the no-finetuning baseline of 28.4%. Digging into per-benchmark numbers, CoT-only finetuning actually degrades MMLU-direct (48.5% vs. 55.1% for no finetuning) and BBH-direct (34.5% vs. 37.4%), while improving MGSM-CoT (32.6% vs. 18.2%). This foreshadows the Section 4.2 finding: finetuning exclusively on CoT data hurts non-CoT performance, just as finetuning on only non-CoT data hurts CoT performance.

Chain-of-Thought Finetuning Effects (Section 4, Figures 5–7, Table 4)

Headline finding: Joint finetuning on CoT and non-CoT data improves performance on both CoT and non-CoT evaluations, while finetuning on only one paradigm degrades the other. Including just nine CoT datasets (0.5% of the mixture) is sufficient to preserve and enhance reasoning ability.

The CoT degradation ablation (Figure 5). Figure 5 partitions evaluation benchmarks into held-out CoT benchmarks (MMLU-CoT, BBH-CoT, MGSM-CoT) and held-out non-CoT benchmarks (MMLU-direct, BBH-direct, TyDiQA-direct). Three finetuning configurations are compared across model sizes: CoT + non-CoT (the full 1,836-task mixture), non-CoT only (1,827 tasks with CoT data removed), and CoT only (9 tasks).

On held-out CoT benchmarks (Figure 5-left), the non-CoT-only configuration (green line) falls below the no-finetuning baseline (gray line) for all three model sizes. For the 540B model, non-CoT-only finetuning drops the normalized average on CoT benchmarks from approximately 49% (no finetuning) to approximately 37%—a ~12-point degradation. The CoT + non-CoT configuration (blue line) is substantially above both the non-CoT-only line and the no-finetuning line, reaching approximately 56% for 540B. The CoT-only configuration (orange line) sits between no-finetuning and the combined configuration, showing it provides some benefit for CoT but is suboptimal.

On held-out non-CoT benchmarks (Figure 5-right), the pattern reverses: non-CoT-only finetuning (green) and CoT + non-CoT finetuning (blue) perform similarly and substantially above no-finetuning. CoT-only finetuning (orange) is closer to no-finetuning, showing that 9 CoT datasets alone do not teach general instruction-following.

The practical implication is that the combined mixture achieves the best of both worlds: it improves CoT performance (unlike non-CoT-only finetuning, which degrades it) while maintaining strong non-CoT performance (unlike CoT-only finetuning, which doesn't improve it). The 3% mixture proportion for CoT data (Proportion A) is sufficient for this protective effect.

CoT + self-consistency state-of-the-art results (Table 4). Flan-PaLM 540B with CoT prompting and self-consistency (SC; Wang et al., 2022b) achieves new state-of-the-art on several benchmarks: 75.2% on five-shot MMLU (test set), surpassing PaLM's 69.3% (direct) and 69.5% (CoT + SC); 78.4% on BBH-NLP, compared to PaLM's 78.2%; 66.5% on BBH-algorithmic, compared to PaLM's 62.2%; and 72.0% on MGSM, compared to PaLM's 57.9% with CoT + SC. The MGSM result is particularly striking—a +14.1-point improvement—and includes strong performance on under-represented languages like Bengali (69.6%). For reference, PaLM with CoT + SC achieved only 63.6% on French and 61.2% on German, both high-resource languages.

Zero-shot CoT reasoning (Figure 6). On 23 challenging BBH tasks, Flan-PaLM models benefit substantially from appending "let's think step-by-step" to zero-shot prompts, while PaLM models show no benefit. For the 540B model: PaLM zero-shot (approximately 47%) vs. PaLM zero-shot + CoT (approximately 47%)—no gain; Flan-PaLM zero-shot (approximately 46%) vs. Flan-PaLM zero-shot + CoT (approximately 58%)—a +12-point gain. At 8B, the pattern is similar: Flan-PaLM gains approximately 8 points from the CoT trigger, PaLM gains nothing. At 62B, both models show a gap, but Flan-PaLM's is larger.

Qualitative CoT examples (Figure 7). On three BBH tasks (Snarks, Boolean Expressions, Disambiguation QA), PaLM 540B fails to generate coherent zero-shot CoT: on Boolean Expressions it mangles the logical evaluation, on Snarks it produces an incomplete analysis, and on Disambiguation QA it never stops generating. Flan-PaLM 540B produces structured, step-by-step reasoning and reaches the correct answer in all three cases. These examples concretize the quantitative pattern in Figure 6.

MMLU test set results (Table 1). Flan-PaLM achieves 72.2% on five-shot MMLU (without CoT) and 75.2% with CoT + SC, compared to prior bests of 69.3% (PaLM 5-shot) and forecasts made in July 2022 by competitive human forecasters predicting 73.2–87.6% for the best model by June 2023–2024. The 75.2% with CoT + SC already exceeds the lower end of those forecasts.

Cross-Model Generalization (Section 5, Table 5)

Headline finding: Instruction finetuning improves normalized average performance by 6.1 to 26.6 percentage points across all model families, architectures, and pretraining objectives tested, with the largest absolute gains for T5 models and complementary benefits when combined with UL2 continued pretraining.

Table 5 reports per-benchmark results for all model variants. For T5 models, the gains are largest because the baseline is lowest (T5 was not designed for few-shot prompting): Flan-T5-Small (80M) improves from -9.2% to -3.1% (+6.1), Flan-T5-Base (250M) from -5.1% to 6.5% (+11.6), Flan-T5-Large (780M) from -5.0% to 13.8% (+18.8), Flan-T5-XL (3B) from -4.1% to 19.1% (+23.2), Flan-T5-XXL (11B) from -2.9% to 23.7% (+26.6). Notably, Flan-T5-XL (3B) achieves 52.4% on MMLU-direct, surpassing GPT-3 175B's 43.9% (Table 1). Flan-T5-XXL (11B) achieves 45.3% on BBH-direct, outperforming PaLM 62B's 37.5%.

For the PaLM family, the pattern holds: Flan-PaLM 8B gains +15.5 points (6.4% → 21.9%), Flan-PaLM 62B gains +10.4 points (28.4% → 38.8%), Flan-PaLM 540B gains +9.3 points (49.1% → 58.4%). The slight discrepancy between the 58.4% reported here and the 58.5% in Table 3 is due to the different mixture proportions used (Proportion A for Table 3, Proportion B for Table 5).

For extended pretraining variants, the gains compound: Flan-cont-PaLM 62B achieves 46.7% vs. 38.1% for cont-PaLM without finetuning (+8.6 points), and 46.7% vs. 28.4% for base PaLM 62B (+18.3 total gain from continued pretraining + instruction finetuning). Flan-U-PaLM 540B achieves 59.1% vs. 50.2% for U-PaLM without finetuning (+8.9), and 59.1% vs. 49.1% for base PaLM 540B (+10.0 total gain). The additivity decomposition: UL2 continued pretraining contributes approximately +1.1 points (50.2 - 49.1), and instruction finetuning adds +8.9 points (59.1 - 50.2). The near-identical gains for instruction finetuning on top of U-PaLM (+8.9), standard PaLM (+9.3), and cont-PaLM (+8.6) support the claim that instruction finetuning operates on an independent axis of model capability.

Per-benchmark highlights for Flan-U-PaLM 540B (the strongest model): 74.1% on MMLU-direct, 69.8% on MMLU-CoT, 59.3% on BBH-direct, 64.9% on BBH-CoT, 68.3% on TyDiQA-direct, 60.4% on MGSM-CoT. These exceed Flan-PaLM 540B on every metric except BBH-direct (59.3% vs. 57.9%).

Open-Ended Generation Human Evaluation (Section 6, Figure 8)

Headline finding: Flan-PaLM 540B is preferred by human raters over PaLM 540B 79% of the time across 190 challenging open-ended prompts spanning creativity, reasoning, planning, and explanation.

Figure 8 breaks down rater preferences by category. On zero-shot creativity tasks (20 examples), Flan-PaLM is preferred approximately 70% of the time. On context reasoning (20 examples), approximately 80%. On complex reasoning without CoT (20 examples), approximately 70%; with CoT trigger (20 examples), this rises to approximately 85%. On planning without CoT (20 examples), approximately 80%; with CoT, approximately 95%. On explanation without CoT (20 examples), approximately 70%; with CoT, approximately 85%. On few-shot prompts (30 examples), Flan-PaLM and PaLM are roughly tied at approximately 45% each, with 10% ties.

The key pattern: Flan-PaLM's advantage is largest on CoT tasks (complex reasoning, planning, explanation with the CoT trigger phrase), where rater preference exceeds 85%. The near-parity on few-shot prompts suggests that PaLM's base capabilities with exemplars are already strong, and instruction finetuning primarily improves zero-shot behavior. The authors note that PaLM's zero-shot failures include three common patterns identified through qualitative inspection: continuing to generate related text instead of answering the question, repeating the input question with minor modifications, and not knowing when to stop generating. Figure 9 provides concrete examples: PaLM, asked to "make up a word," instead keeps asking more questions; given a math problem with few-shot exemplars, it repeats the input rather than producing an answer. Flan-PaLM handles all of these prompts correctly.

Responsible AI Benchmarks (Appendix C)

Headline finding: Flan models show reduced toxicity degeneration and improved toxicity classification compared to PaLM, though group-level biases persist.

RealToxicityPrompts (Appendix C.1, Table 6, Figure 12). For both toxic and non-toxic input prompts from the RealToxicityPrompts dataset (Gehman et al., 2020), Flan-PaLM models produce fewer toxic continuations than PaLM. On non-toxic prompts, the probability of generating at least one toxic continuation in 25 samples drops from 0.44 for all PaLM sizes to 0.14–0.18 for Flan-PaLM. On toxic prompts, it drops from 0.77–0.80 for PaLM to 0.52–0.58 for Flan-PaLM. Flan-T5-XXL shows even lower toxicity on non-toxic prompts (0.06) but comparable to Flan-PaLM on toxic prompts (0.26). The scaling analysis in Figure 12 shows that Flan models have lower toxicity probability of continuation (TPC) across all bins of prompt toxicity probability (TPP) compared to PaLM-540B, with no clear scaling trend across Flan-PaLM model sizes (8B, 62B, 540B perform similarly).

Toxicity in identity-term prompts (Appendix C.2, Figures 13–14). When prompts are constructed from templates referencing specific identity groups (gender, ethnicity, religion, occupation, country), the percentage of continuations with toxicity score ≥ 0.5 is lower for Flan models across all identity dimensions. However, group-level disparities persist: within the religion dimension, prompts referencing Judaism still elicit higher upper-quartile toxicity than other religious groups, mirroring the bias pattern in PaLM (Figure 14b). Within gender, similar biased patterns appear (Figure 14c). This indicates that while instruction finetuning reduces overall toxicity, it does not eliminate differential treatment of identity groups.

CivilComments toxicity classification (Appendix C.3, Table 7). Instruction finetuning substantially improves zero-shot and few-shot toxicity classification on CivilComments (Borkan et al., 2019b). Flan-PaLM 540B achieves 86.5% AUC-ROC in zero-shot classification, compared to 71.4% for PaLM 540B. Ten-shot classification shows a smaller gap (87.1% vs. 82.1%). Interestingly, the zero-shot Flan-PaLM models outperform their 10-shot PaLM counterparts: Flan-PaLM 540B zero-shot (86.5%) beats PaLM 540B ten-shot (82.1%). Flan-T5-XXL achieves 84.1% zero-shot, competitive with Flan-PaLM models. For reference, the Perspective API achieves 97.0% on the same task.

Winogender coreference resolution (Appendix C.4, Figures 15–16). Instruction finetuning improves Winogender accuracy across all PaLM model sizes, particularly for zero-shot. Flan-PaLM 540B achieves near-human multiple-choice baseline performance. Disaggregated analysis shows models perform better on stereotypical examples than "gotcha" examples (where the correct pronoun violates gender stereotypes), and this pattern persists in instruction-finetuned models. Flan-T5-XXL achieves the highest overall performance, outperforming all Flan-PaLM variants.

Translation misgendering (Appendix C.5, Table 10). Across 26 languages and 1,954 passages, the impact of instruction finetuning on translation misgendering accuracy is mixed. Flan-PaLM 540B achieves 95% overall accuracy vs. 97% for PaLM 540B—a small regression. Flan-T5-XXL achieves 97%, comparable to PaLM 540B. All models show a consistent "she" pronoun disadvantage: accuracy on examples where the correct English translation should use "she" is 5–9 percentage points lower than on "he" examples across both PaLM and Flan-PaLM. Flan-PaLM 8B does show improvement over PaLM 8B (88% vs. 90% overall, with "she" accuracy improving from 81% to 83%). The worst-performing language varies across models: Spanish (late binding) for PaLM 8B (44%), Bhojpuri for Flan-PaLM 62B (78%), Hindi for Flan-PaLM 540B (85%).

State-of-the-Art Comparisons (Table 4, Table 1, Appendix D)

Headline finding: Flan-PaLM 540B establishes new state-of-the-art results on MMLU, BBH, MGSM, and GSM8K when combined with CoT prompting and self-consistency, though it does not surpass specialized models on all subtasks.

On MMLU (test set, Table 4): Flan-PaLM achieves 75.2% with CoT + SC, compared to prior best of 69.3% (PaLM direct) and 69.5% (PaLM CoT + SC). On BBH-NLP: 78.4% vs. 78.2% for PaLM (within margin of error). On BBH-algorithmic: 66.5% vs. 62.2% for PaLM, but still below code-davinci-002 at 73.9% (Table 19). On MGSM: 72.0% vs. 57.9% for PaLM, a +14.1-point improvement. On GSM8K (not in main tables, mentioned in text): 83.9% with CoT + SC, a new state of the art.

On TyDiQA: Flan-PaLM achieves 67.8% direct prompting exact match vs. 52.9% for PaLM, but this is still substantially below the prior best of 81.9% from finetuned ByT5 (Xue et al., 2022), which was trained specifically on TyDiQA training data. This illustrates the paper's acknowledged limitation: instruction finetuning does not match specialized single-task finetuning.

The appended results for text-davinci-003 and code-davinci-002 in Appendix D provide useful comparisons to contemporaneous OpenAI models. On MMLU, Flan-PaLM 540B direct (73.2% averaged across 57 tasks; Table 11–16, validation set) exceeds text-davinci-003 (64.8%) and approaches code-davinci-002 (68.2%). On BBH, Flan-PaLM 540B CoT (66.3% average across 27 tasks; Table 17–19) trails code-davinci-002 CoT (73.7%), particularly on algorithmic tasks like word sorting and tracking shuffled objects where code-davinci-002's code pretraining provides an advantage.

Ablation Studies and Robustness Checks

Mixture composition order (Table 3, the sequential stacking): The paper tests four cumulative mixtures (9 tasks, 89 tasks, 282 tasks, 1,836 tasks) by sequentially adding CoT, Muffin, T0-SF, and NIV2. The result is not just that more tasks help, but that the marginal benefit of each added mixture decreases. The first addition (CoT-only, 9 tasks) provides +3.5 points for 540B; the second (adding Muffin, to 89 tasks) provides +4.4 points; the third (adding T0-SF, to 282 tasks) provides +0.5 points; the fourth (adding NIV2, to 1,836) provides +1.0 points. The fact that T0-SF adds almost nothing to 540B (from 57.0% to 57.5%) while it added +5.7 points to 62B (from 33.4% to 37.9%) and +5.7 points to 8B (from 14.8% to 20.5%) suggests that larger models saturate faster on task diversity. This is a non-obvious, scale-dependent pattern that would be missed without the joint scaling analysis.

Mixture proportion sensitivity (Proportion A vs. Proportion B, Table 23): The paper uses two different mixture weighting schemes. Proportion A (Muffin 52%, T0 15%, CoT 3%, NIV2 30%) was used for Sections 3–4; Proportion B (Muffin 46%, T0 28%, CoT 2%, NIV2 24%) was used for the final models in Section 5. The shift was motivated by observing "strong gains from T0-SF" in the earlier experiments. The fact that final models use different proportions than the scaling experiments means the scaling curves in Figure 4 do not directly predict the final model performance—they characterize the relationship between task count and performance under one specific weighting scheme. The paper reports both sets of results transparently but does not ablate the effect of proportion changes in isolation.

CoT-only finetuning as a minimal counterexample (Figure 5, Table 3): The 9-task CoT-only finetuning configuration serves as an ablation demonstrating that the CoT preservation effect requires both CoT and non-CoT data. CoT-only finetuning on the 540B model produces 52.6% normalized average (Table 3), which is better than no finetuning (49.1%) but substantially worse than CoT + non-CoT (58.5%). More importantly, it degrades non-CoT benchmarks (Figure 5-right, orange line): the model overfits to the CoT output format. This is the symmetric counterpart to the Section 4.2 finding that non-CoT-only finetuning degrades CoT—it completes the picture that both paradigms need representation to avoid behavioral collapse.

Single checkpoint per model, same step across ablations: The authors use a single checkpoint for all evaluations, selected by periodic evaluation on held-out tasks, with the same number of steps used across all ablation runs for a given model. This controls for training duration as a confound—the differences between mixture compositions are not attributable to different amounts of training. Table 22 reports the step counts used (e.g., 40K for Flan-PaLM 8B and 62B, 21K for 540B, 14K for Flan-T5-XXL). The decreasing step count with model size (98K for 80M, 14K for 11B T5 models) is consistent with larger models learning faster per example.

Prompting paradigm combinations (Figure 3 format variants): The finetuning data includes all four combinations of exemplars (present/absent) and CoT (present/absent). The paper does not ablate this choice against a version using only, say, zero-shot formats or only few-shot formats. However, the fact that the resulting model performs well on zero-shot, few-shot, direct, and CoT evaluations simultaneously is evidence that the combinatorial formatting achieves its intended goal—the model learns to handle all prompting paradigms. A missing ablation would be finetuning on only zero-shot formats (without exemplars) or only few-shot formats (without zero-shot) and measuring the cross-paradigm transfer.

Language coverage and multilinguality (TyDiQA and MGSM per-language results, Appendix D.3–D.4): The instruction finetuning data includes multilingual tasks (translation, multilingual QA from NIV2), but the paper does not ablate the effect of removing multilingual data from the finetuning mixture. The TyDiQA per-language results (Table 20) show that Flan-PaLM 540B improves over PaLM consistently across all 8 languages, with the largest absolute gains for Arabic (+18.7 points, from 45.1% to 63.8%) and Swahili (+14.5 points, from 63.9% to 78.4%). The MGSM per-language results (Table 21) show improvements across all 10 languages for Flan-PaLM 540B, with the largest gains for Bengali (+13.6 points, from 41.6% to 55.2%) and Spanish (+10.4 points, from 57.6% to 68.0%). The consistency across languages suggests the multilingual benefit is not driven by a few languages dominating the average.

Maximum example caps and their effect (Table 23): The paper caps per-task examples at values ranging from 5,000 (NIV2) to 100,000 (CoT). Without these caps, large datasets like WMT translation (millions of examples) would dominate training. The paper does not ablate different cap values, so the sensitivity of results to this hyperparameter is unknown. However, the fact that significant gains come from T0-SF (capped at 20K) and Muffin (capped at 30K) suggests the caps are generous enough that the full diversity of those mixtures is represented.

No-finetuning T5 baselines use LM-adapted checkpoints (Section 5): The authors use LM-adapted T5 models (Lester et al., 2021) as the no-finetuning baseline rather than raw T5 checkpoints. This is a stronger baseline because LM adaptation improves T5's few-shot prompting capability. The fact that Flan-T5 models still show massive gains (+26.6 points for Flan-T5-XXL) against this stronger baseline strengthens the claim that instruction finetuning provides benefits beyond simple language model adaptation.

Critical Assessment

Does multi-task instruction finetuning improve performance at scale? The evidence in Table 3 and Figure 4 provides strong support for this claim, with a +9.4-point normalized average gain for Flan-PaLM 540B over PaLM 540B. However, the nature of this improvement deserves scrutiny. The gains are uneven across benchmarks: +14.5 points on TyDiQA and +15.4 on MGSM, but only +1.9 on MMLU-direct for the 540B model. This suggests instruction finetuning primarily helps on tasks where the pretrained model was underperforming relative to its potential (due to format mismatch, lack of instruction-following behavior, or multilingual limitations), rather than uniformly boosting all capabilities. The small MMLU-direct gain (+1.9 points, from 71.3% to 73.2%) is telling—MMLU-direct already tests knowledge through few-shot exemplars, a paradigm PaLM handles well, so instruction finetuning adds little. In contrast, TyDiQA requires the model to understand a task instruction and produce a language-appropriate answer span without exemplar-guided formatting; PaLM struggles with this (52.9%), and instruction finetuning helps substantially (67.4%).

A limitation of the claim is that the normalized average metric—while useful for aggregation—can overstate gains when low-performing benchmarks see large absolute improvements and high-performing benchmarks see small ones, because the normalization stretches the scale at the bottom. TyDiQA going from 52.9% to 67.4% produces a large normalized gain because the baseline gap to perfect performance was large. The metric is well-defined and borrowed from established conventions, but readers should interpret the headline +9.4% as a summary statistic that weights all six evaluation configurations equally, not as a uniform 9.4% improvement across all tasks.

Do the scaling curves genuinely demonstrate that "more is better," or do they show saturation? The task-scaling curve (Figure 4-right) clearly shows diminishing returns beyond 282 tasks, with the 282→1,836 jump providing only +1.0 points for 540B. This is a finding of saturation, not unbounded improvement, and the paper correctly interprets it as such. However, the experiment cannot distinguish between the two explanations offered: that the additional tasks lack diversity (Explanation 1) or that instruction-following as a skill is saturated (Explanation 2). The experiment that would distinguish them—constructing a maximally diverse set of 1,800 tasks and comparing to the existing 1,800-task mixture—was not run. Until such an experiment is conducted, the claim "scaling the number of tasks yields diminishing returns" is accurate for the specific mixture tested but may not generalize; a better-curated 1,800-task mixture could show continued improvement.

The model-size scaling curve (Figure 4-left) shows that the absolute gap between finetuned and non-finetuned models is roughly constant (or slightly shrinking) with model size. This contradicts the hypothesis that instruction finetuning would be more beneficial for larger models (which have more latent knowledge to unlock). Instead, the benefits are approximately additive: finetuning provides a roughly fixed boost regardless of base model capability. For practitioners, this means the case for instruction finetuning is actually strongest for smaller models where the relative gain is largest (Flan-T5-XL goes from -4.1% to 19.1%, a transformation from below random guessing to competitive with GPT-3 175B), not for the largest models where it provides a more modest incremental improvement.

Does including CoT data prevent degradation and enable zero-shot reasoning? The evidence for CoT degradation (Figure 5-left) is clear and striking: non-CoT-only finetuning drops 540B CoT performance by approximately 12 points. This is a robust, well-controlled result. The solution—including 9 CoT datasets—is shown to work in the sense that the combined mixture outperforms the non-CoT-only mixture. However, the experiment does not establish the minimum amount of CoT data needed. Would 1 CoT dataset work? Would 50 CoT examples? The paper doesn't ablate the number of CoT datasets or examples, leaving the "dose-response" relationship unknown. This matters practically because collecting human-written CoT annotations for 9 datasets is expensive; knowing the minimum effective dose would inform resource allocation.

The zero-shot CoT result (Figure 6) is a genuine strength of the paper. The controlled comparison—PaLM vs. Flan-PaLM, same model architecture and scale, with and without "let's think step-by-step"—isolates the effect of instruction finetuning cleanly. The qualitative examples in Figure 7 make the quantitative numbers vivid. However, the evaluation is limited to BBH (23 tasks); zero-shot CoT performance on MMLU or other benchmarks is not reported. Since BBH tasks were selected for being challenging even with few-shot CoT, the zero-shot CoT results here represent a particularly demanding test—but also one that may not generalize to other task types.

Does instruction finetuning generalize across architectures and combine with other methods? The cross-model results in Table 5 provide strong support. The gains span encoder-decoder (T5) and decoder-only (PaLM) architectures, three pretraining objectives, and five orders of magnitude in parameter count. The near-identical improvement for instruction finetuning on top of UL2 (+8.9) and standard PaLM (+9.3) supports the additive combination claim. However, the paper does not test whether instruction finetuning combines with other prominent adaptation methods like reinforcement learning from human feedback (RLHF; Ouyang et al., 2022) or parameter-efficient finetuning (e.g., prompt tuning, LoRA). The claim that instruction finetuning is "complementary" is demonstrated only for continued pretraining methods, not for the broader space of post-hoc model improvements.

A notable gap: the paper does not test whether instruction finetuning on top of a model that already underwent instruction finetuning (i.e., iterated instruction finetuning) provides further gains. The Flan-U-PaLM result suggests additivity with continued pretraining, but the question of whether multiple rounds of instruction finetuning with different task mixtures would help is unexplored.

Are the human evaluation results reliable? The human evaluation (Section 6) uses 190 examples with one rater per example, with PaLM and Flan-PaLM outputs presented in randomized order. The 79% overall preference for Flan-PaLM is a large effect. However, several methodological concerns exist. First, single-rater per example means there is no inter-rater reliability measurement, so we cannot assess whether different raters would make the same choices. Second, the example set (190 prompts) is constructed by the authors and may not be representative of real user query distributions—it deliberately focuses on challenging zero-shot scenarios where PaLM is known to struggle. Third, the response selection procedure (generate 5 with temperature 0.7, filter by log probability, select best) is applied independently to both models, and differences in the filtering's effectiveness across models could confound the comparison. Fourth, the evaluation was not double-blind in the sense of using a neutral, task-specific rubric—raters made holistic preference judgments, which could be influenced by surface-level features like response length or formatting rather than correctness or usefulness. The Appendix I instructions acknowledge this tension by telling raters "Long answers are not always the best," but do not enforce it mechanically.

Do the Responsible AI results support the claim of "improved" safety? The toxicity results (Table 6, Figures 12–14) consistently show that Flan models are less likely to generate toxic continuations than PaLM. However, the evaluations have important limitations. The toxicity classifier (Perspective API) has known biases and does not capture all forms of harmful content. The group-level bias analysis (Figure 14) reveals that while overall toxicity decreases, the pattern of differential toxicity across identity groups persists. The translation misgendering results (Table 10) are mixed, with no clear improvement from instruction finetuning, and the "she" pronoun disadvantage persists across all models. The paper appropriately acknowledges these limitations (Appendix C.6), but the headline claim that "instruction finetuning also improves performance across several responsible AI evaluation benchmarks" (Section 1) should be qualified: it improves some metrics (toxicity probability, toxicity classification) while leaving others unchanged (group-level bias patterns, translation misgendering). The improvement is real but selective.

What experiments are missing that would strengthen the paper's claims? Several important ablations and extensions are absent: (1) Minimum effective CoT data: How few CoT examples are needed to prevent degradation? (2) Mixture proportion sensitivity: How do results change if CoT data is 0.5%, 1%, 5%, or 10% of the mixture? (3) Template diversity ablation: Are 10 templates per CoT dataset necessary, or would 2–3 suffice? (4) Monolingual vs. multilingual finetuning benefit: Do the TyDiQA and MGSM gains come from multilingual finetuning data, or would the same English-only instruction finetuning improve multilingual performance through better instruction-following? The paper notes (Figure 18) that 60 languages appear in the finetuning data, but doesn't ablate their contribution. (5) Training duration sensitivity: Since the same step count is used across mixture sizes, models trained on fewer tasks see fewer unique examples but the same number of gradient updates—does this confound the task count effect with training duration? (6) Comparison to single-task finetuning: The paper shows Flan-PaLM outperforms PaLM with few-shot prompting, but doesn't compare to PaLM finetuned on individual downstream tasks, which is the standard approach for practitioners who have labeled training data. The TyDiQA result (67.8% vs. ByT5's 81.9%) suggests single-task finetuning would win on many benchmarks, and a direct comparison would better characterize the tradeoff between generality and peak performance. (7) Statistical significance: None of the benchmark results include confidence intervals or significance tests, making it impossible to assess whether small differences (e.g., 282 vs. 1,836 tasks for 540B: 57.5% vs. 58.5%) are reliable.

Overall assessment of experimental support. The paper's central narrative—that instruction finetuning is a general, compute-efficient method for improving pretrained language models, that scaling model size and task count both help but with diminishing returns for tasks, and that including CoT data is essential for preserving reasoning ability—is well-supported by the experiments reported. The scale of the study (multiple model families, sizes spanning three orders of magnitude, 1,836 tasks) is unprecedented for instruction finetuning research and provides convincing evidence of generality. The CoT degradation finding is a genuine discovery that was invisible to prior work.

The weaknesses are in the depth of ablation (many "how much is needed?" questions unanswered), the narrowness of the evaluation relative to the breadth of the claims (four benchmarks plus one human evaluation cannot capture all aspects of "improved performance and usability"), and the reliance on a single aggregate metric (normalized average) that can obscure heterogeneous effects. The paper's honesty about limitations—acknowledging that instruction finetuning doesn't match specialized models on some benchmarks, that harder problems show smaller gains, that scaling tasks has diminishing returns—mitigates these concerns somewhat. The experimental analysis succeeds in establishing the broad empirical patterns it claims, while leaving open many questions about the precise mechanisms, optimal configurations, and boundary conditions of instruction finetuning.

6. Limitations and Trade-offs

The Difficulty Estimation Cost Is Not Accounted For, Making the Headline Efficiency Gains an Upper Bound

The compute-optimal framework described in Section 3.2 requires estimating each prompt's difficulty before deciding how to allocate the inference budget. The paper's method for doing this—generating 2,048 samples per question and averaging either ground-truth correctness or PRM final-answer scores—is extraordinarily expensive. At 2,048 samples per question, the difficulty estimation step alone consumes more compute than the largest test-time budgets studied (256–512 generations). The authors acknowledge this explicitly:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity" (Section 3.2)

The consequence is that the reported 4× efficiency gains over best-of-N are computed after difficulty is known, without amortizing the cost of learning it. In a realistic deployment, the total cost would be difficulty estimation plus strategy execution, and the former could dominate the latter. For the 540B model, generating 2,048 samples per question costs approximately 8× the largest test-time budget studied in the paper (256 generations), meaning the "4× more efficient" strategy would actually be more expensive than a uniform best-of-256 baseline when difficulty estimation is included. The paper provides no alternative cheap difficulty estimation method, and the insight that "predicted bins work nearly as well as oracle bins" (Figures 4, 8) still requires the same 2,048 forward passes—the gain is only in not needing ground-truth labels, not in reducing the number of forward passes needed to estimate difficulty.

The paper partially acknowledges this in Section 3.2, calling it an "exploration-exploitation tradeoff" and flagging it as "a key avenue for future work." But the failure to account for difficulty estimation cost means the headline efficiency numbers (4× over best-of-N in Figures 4 and 8) are best understood as an upper bound on achievable efficiency rather than a realized deployment gain. No mitigation is attempted in the current work—the paper merely suggests that future work could train models to predict difficulty directly from question text or develop adaptive schemes that assess difficulty during the solution process.

---

Hard Problems Remain Essentially Unsolved: Test-Time Compute Cannot Substitute for Missing Capability

Across all methods—search, revisions, and their compute-optimal combinations—the hardest questions (difficulty bin 5) show near-zero improvement regardless of compute budget. In Figure 3 (right), bin 5 accuracy hovers at 1–3% for all methods and all budgets from 4 to 256 generations. In Figure 7 (right), bin 5 shows roughly 2–3% accuracy irrespective of the sequential-to-parallel ratio at a fixed budget of 128 generations. In the FLOPs-matched comparison (Figure 9), the bin 5 scaling line is essentially flat near 0–5%, remaining below the ~14× larger model's greedy performance across all values of the inference-to-pretraining ratio $R$.

This is a fundamental capability bound, not an inefficiency that better allocation could solve. The paper explains the mechanism clearly: test-time compute can only select or refine solutions that the base model is already capable of generating at some non-trivial rate. If the base model's pass@1 is near zero, no amount of search or revision will help—there are no correct solutions in the proposal distribution to find or refine. The paper is candid about this in the Section 7 takeaway box, noting that test-time compute and pretraining compute are "not 1-to-1 exchangeable."

The practical consequence is that this approach offers no path forward for genuinely novel or out-of-distribution reasoning that exceeds the base model's training distribution or architectural capacity. For such problems, pretraining remains the only viable path. The FLOPs-matched comparison quantifies this sharply: on hard problems at $R \gg 1$, the test-time compute approach shows a −52.9% relative disadvantage compared to the ~14× larger model for PRM search (Figure 1 bottom-right bar chart, Figure 9 right). The paper does not attempt to mitigate this limitation—it is inherent to the proposer-verifier framework and is correctly identified as a boundary condition for the method's applicability.

---

Single Benchmark (MATH) and Single Model Family (PaLM 2-S*) Mean the Difficulty-Dependent Patterns May Not Generalize

All experiments use the MATH benchmark (500 test questions) with PaLM 2-S* as the base model. The authors state they "believe this model is representative of the capabilities of many contemporary LLMs" (Section 4), but this claim is unverified. Several aspects of the findings could be model-specific or benchmark-specific:

• The PRM's quality and over-optimization behavior depend on PaLM 2-S*'s output distribution. A model with different calibration properties or different error patterns might exhibit different difficulty-dependent scaling curves—the beam search degradation on easy problems (Figure 3, right, bins 1–2) might not occur with a better-calibrated verifier, or might occur at different budget thresholds.

• The revision model's ability to learn from incorrect in-context examples depends on the base model's in-context learning capabilities, which vary substantially across model families. The 38% correct-to-incorrect reversion rate (Section 6.1) might be higher or lower for other architectures.

• The MATH benchmark consists exclusively of competition-level math problems requiring symbolic reasoning. It is unclear whether the difficulty-dependent patterns—beam search hurting easy problems but helping medium ones (Figure 3, right), sequential revisions dominating on easy problems but needing parallel diversity on hard ones (Figure 7, right)—generalize to other reasoning domains such as code generation, logical reasoning, or scientific QA, or to tasks requiring factual knowledge rather than inference.

• The test set of 500 questions, split into five difficulty quintiles of approximately 100 each, then further split by two-fold cross-validation, means the compute-optimal policy is selected based on roughly 50 questions per fold per bin. This is a small sample, and the paper does not report confidence intervals on the compute-optimal scaling curves (Figures 4, 8), making it difficult to assess whether the observed gains are statistically reliable or would replicate on a different 500-question split.

The paper acknowledges the single-benchmark limitation implicitly by not claiming generality beyond MATH, but does not address it directly. No experiments on other benchmarks, other model families, or other reasoning domains are conducted. The replication of difficulty-dependent patterns across both search methods (Section 5) and revision methods (Section 6) provides some internal consistency, but this is within the same benchmark and model—it does not demonstrate external validity.

---

Revisions and Search Are Studied Independently, Not Combined, Representing a Lower Bound on What a Fully Integrated System Could Achieve

The paper studies two complementary axes—PRM-guided search (Section 5) and iterative revisions (Section 6)—as independent mechanisms, but never combines them. Section 8 explicitly acknowledges this gap:

"we did not experiment with PRM tree-search techniques in combination with revisions"

This is a significant omission because the two mechanisms have complementary, difficulty-dependent strengths. The paper's own analysis shows that revisions improve the proposal distribution (generating better candidates, particularly on easy problems where local refinement suffices), while PRM search improves candidate selection (finding the best among generated candidates, particularly on medium problems where exploration across qualitatively different solution strategies is needed). Applying beam search to revision model outputs—or using the PRM to guide which revisions to pursue, rather than blindly generating a long revision chain—could yield gains beyond either method alone, particularly on medium-difficulty problems (bins 3–4) where both mechanisms show partial effectiveness but neither saturates performance.

The practical consequence is that the current results represent a lower bound on what combining both mechanisms could achieve. A practitioner reading this paper would want to know whether the ~4× efficiency gains over best-of-N could become ~8× or more if search and revisions were deployed together. The paper provides no evidence either way.

No mitigation is attempted. The paper acknowledges this as future work but does not speculate on the magnitude of potential combined gains, nor does it identify what technical obstacles (distribution shift between base model and revision model outputs affecting PRM quality, increased latency from serial revision dependencies within search trees, etc.) might limit the combination.

---

The ~14× Larger Model Baseline Is Weakened by Using Greedy Decoding Without Any Test-Time Compute, Potentially Overstating the Case for Test-Time Scaling

The FLOPs-matched comparison in Section 7 scales model parameters while holding training data fixed (following the LLaMA paradigm rather than Chinchilla-optimal training), and evaluates the larger model using only greedy decoding—no majority voting, no best-of-N, no search. The authors acknowledge the first point:

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work."

However, they do not acknowledge the greed-decoding limitation. The consequence is that the comparison potentially overstates the advantage of test-time compute over pretraining. A Chinchilla-optimal model trained with ~14× more total FLOPs (scaling both parameters and data) would likely outperform a parameter-only-scaled model, narrowing the reported advantages. More importantly, giving the larger model even a modest test-time compute budget—say, best-of-8 or best-of-32 majority voting—would create a much stronger baseline than greedy decoding alone. The paper's central tradeoff question ("is test-time compute or pretraining compute more effective?") cannot be fully answered without exploring this dimension: if the larger model also benefits from test-time compute, the crossover point where pretraining becomes preferable might shift substantially.

The evidence in the paper that this matters comes indirectly from the scaling curves themselves. In Figure 3 (left), best-of-N weighted shows substantial improvement as the generation budget increases—from roughly 16% at 2 generations to roughly 38% at 256 generations for the base PaLM 2-S* model. If the ~14× larger model shows similar scaling behavior with additional test-time compute, then the FLOPs-matched comparison in Section 7 (which compares test-time-compute-augmented smaller model against greedy larger model) is comparing a best-case scenario for test-time compute against a worst-case scenario for pretraining. The paper does not ablate giving the larger model any test-time compute budget, so the magnitude of this asymmetry is unknown.

No mitigation is attempted. The paper transparently reports the pretraining baseline configuration but does not discuss the implications of the greedy decoding choice for the fairness of the FLOPs-matched comparison.

---

The Revision Model's 38% Correct-to-Incorrect Reversion Rate Limits Sequential Chain Reliability

The paper reports (Section 6.1) that approximately 38% of correct answers produced during a revision chain get "revised" back to incorrect answers in the subsequent step. This is a direct consequence of the training data construction: the model only sees incorrect-to-correct trajectories during supervised finetuning, so it has no training signal for what to do when the current answer is already correct. When the model encounters a correct answer in its own context (produced during an earlier revision), it applies its learned behavior—"the previous answer is wrong, produce a corrected version"—and converts a correct answer into an incorrect one.

The practical consequence is that longer revision chains are not monotonically beneficial. Figure 6 (left) shows that pass@1 at each step gradually improves throughout the chain (from approximately 18.2% at step 1 to roughly 24–25% by steps 15–20), but this is an average across many chains. For any individual chain, the quality oscillates—a good revision can be followed by a bad one, and without external verification, the model cannot distinguish which step in the chain produced the best answer. The paper mitigates this with within-chain selection (majority voting or verifier-based selection across all steps of the chain, rather than taking the final revision output), which successfully recovers the best answer in many cases. However, this mitigation adds overhead (the verifier must score multiple outputs per chain) and is imperfect—if the correct answer appears at step 3 but all subsequent revisions are incorrect, the selection mechanism must correctly identify step 3 as the best output, which depends on verifier quality.

This is a fundamental design tension: the model was trained to improve incorrect answers, but in deployment it must handle the case where its own output is already correct. The paper does not explore potential solutions such as training the model with "no revision needed" examples or incorporating a confidence threshold that suppresses revision when the model is already confident. The ReST$^{EM}$ experiment (Appendix K, Figure 16) further highlights the fragility of revision training: attempting to optimize the revision model with RL-style training caused performance to degrade substantially with sequential revisions, suggesting the approach is sensitive to training methodology in ways that are not fully understood.

The paper acknowledges the reversion problem and its mitigation (within-chain selection), but does not quantify the residual error—what fraction of chains still fail because the correct answer was generated but the selection mechanism chose an incorrect answer elsewhere in the chain? This limits a practitioner's ability to assess whether the revision approach is reliable enough for deployment without external answer verification.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper transforms instruction finetuning from a promising-but-brittle technique explored at modest scale into a general, compute-efficient, and architecturally universal method that the authors credibly recommend "for virtually all pretrained language models." Prior to this work, the field had fragmented evidence: Wei et al. (2021) showed instruction finetuning helped a 137B model on 62 tasks, Sanh et al. (2021) showed it helped T5 models on 193 tasks, and Wang et al. (2022c) scaled tasks to 1,600+ but only with a 3B model. No one had connected these dots to ask whether instruction finetuning's benefits are robust to simultaneous scaling of both model size and task count, and whether the practice plays nicely with chain-of-thought reasoning. The paper answers both questions affirmatively, establishing instruction finetuning as a standard, expected stage in the LLM training pipeline—analogous to how pretraining plus finetuning became the default after the BERT era, rather than an optional post-processing trick.

The magnitude of this shift is best captured by Table 2: instruction finetuning requires 0.2% of pretraining compute for PaLM 540B (5.6×10²¹ vs. 2.5×10²⁴ FLOPs), yet delivers a +9.4% normalized average improvement across four demanding held-out benchmarks. This is not an incremental refinement—it is an enormous return on a tiny compute investment that fundamentally changes the economics of model development. A team that has already invested millions of dollars in pretraining a large model can capture an additional ~9 percentage points of capability for less than 1% additional compute. In a field where capability improvements typically require scaling pretraining by factors of 2–10× (with corresponding cost multipliers), this represents a step-change in efficiency.

The paper also resolves a genuine tension in the literature that was invisible to prior work. Instruction finetuning papers without CoT data (Wei et al., 2021; Sanh et al., 2021) reported improvements on held-out NLP tasks, while the CoT community (Kojima et al., 2022) showed that zero-shot CoT reasoning worked on instruction-finetuned models but not on raw pretrained models. The implicit question—does instruction finetuning help or hurt reasoning?—had contradictory answers depending on which paper you read. This paper's Section 4.2 ablation provides the unifying diagnosis: instruction finetuning without CoT data actively degrades reasoning ability (Figure 5-left, green line falling below the no-finetuning baseline), but instruction finetuning with even a small amount of CoT data (9 datasets, 0.5% of the mixture) preserves and enhances reasoning. The contradiction was an artifact of different finetuning mixtures. This diagnostic finding converts a confusing set of results into a coherent picture with a clear design rule: both CoT and non-CoT data must appear in the finetuning mixture for a single model to serve both paradigms.

A subtler shift concerns the mental model of what instruction finetuning does. The paper's scaling curves (Figure 4, right panel) show that most of the gain comes from the first 282 tasks, with adding 1,554 more producing only ~1 additional point for the 540B model. Combined with the token count asymmetry (1.4B finetuning tokens vs. 780B pretraining tokens), this strongly suggests that instruction finetuning is primarily teaching a meta-skill—how to interpret and respond to instructions—rather than injecting new factual knowledge or reasoning capability. The model already "knows" the answers; instruction finetuning teaches it the behavioral pattern of producing them in response to natural language prompts. This reframes instruction finetuning from a knowledge-augmentation technique to a behavioral shaping technique, which has implications for how mixture design should be approached: diversity of output format and instruction phrasing matters more than sheer volume of examples.

The generality demonstrated across architectures and pretraining objectives (Section 5) further shifts the landscape by establishing that instruction finetuning is not coupled to any specific model design. The near-identical gains for Flan-U-PaLM (+8.9), Flan-PaLM (+9.3), and Flan-cont-PaLM (+8.6) on top of their respective baselines show that instruction finetuning operates on an independent axis of model capability—it can be layered onto any sufficiently capable pretrained model regardless of its architectural details. This modularity means that instruction finetuning can become a default final stage in the LLM development pipeline, applied after architecture search, pretraining objective selection, continued pretraining, and any other optimizations, without requiring those earlier stages to be redesigned.

Finally, the paper establishes a new usability floor for pretrained models. The human evaluation (Section 6, Figure 8) demonstrates that a raw pretrained model like PaLM 540B—despite its strong benchmark performance—produces outputs that human raters strongly disprefer on zero-shot open-ended tasks (preferred only ~21% of the time vs. Flan-PaLM). The qualitative failure modes (Figure 9)—continuing to generate instead of answering, repeating the prompt, not knowing when to stop—are not subtle capability gaps but fundamental behavioral failures that make the model unusable for non-experts without prompt engineering. Instruction finetuning fixes these failures almost entirely. This finding implies that releasing a pretrained model without instruction finetuning is, for most practical purposes, releasing an incomplete product—the model has the knowledge and capability but lacks the behavioral interface to make them accessible. The paper makes this point implicitly through the strength of the human evaluation results rather than through explicit argument, but it is one of the most practically consequential implications for the field's model release practices.

Follow-Up Research This Work Enables

Quantifying the minimum effective dose of CoT data. The paper shows that 9 CoT datasets (74,730 examples, approximately 0.5–3% of the full mixture) are sufficient to prevent CoT degradation when finetuning on 1,827 non-CoT tasks. But how few CoT examples would still work? A direct ablation varying the number of CoT datasets from 1 through 9, and within each dataset varying the number of examples from 100 to the full training set, would establish the "dose-response" curve for CoT preservation. The practical value is clear: collecting human-written CoT annotations for 9 datasets is expensive, and knowing whether 1 dataset with 2,000 examples suffices would inform resource allocation for practitioners building instruction finetuning mixtures. The experiment would train Flan-PaLM 62B (reducing computational cost vs. 540B) on the full 1,827 non-CoT tasks plus a systematically varied CoT subset, measuring normalized average on held-out CoT benchmarks (MMLU-CoT, BBH-CoT, MGSM-CoT) to identify the point where performance stops improving. A negative result—finding that the benefit is proportional to CoT dataset count with no threshold—would suggest that diversity of CoT domains matters more than simple exposure to the CoT format.

Does the CoT degradation pattern generalize to other conflicting output paradigms? The paper identifies a specific conflict between direct-answer output format and chain-of-thought output format. Does analogous degradation occur for other paradigm collisions? Candidate conflicts include: single-turn vs. multi-turn dialogue (does finetuning predominantly on single-turn QA degrade the model's ability to maintain conversational context?), extractive vs. abstractive answers (does training mostly on span-extraction tasks suppress the model's ability to generate free-form summaries?), and classification vs. generation (does training primarily on multiple-choice tasks reduce generative fluency?). The experimental design would parallel Section 4.2: construct finetuning mixtures where one paradigm dominates (e.g., 95% single-turn tasks, 0% multi-turn), compare to a combined mixture (e.g., 90% single-turn, 10% multi-turn), and evaluate on held-out tasks from the minority paradigm. A positive finding across multiple paradigm pairs would elevate the CoT degradation observation from a specific case to a general principle of multi-task instruction tuning: any qualitatively distinct output behavior needs explicit representation in the training mixture to survive. A negative finding—that only the CoT vs. non-CoT conflict produces degradation—would suggest something special about chain-of-thought (perhaps that it requires a fundamentally different generation strategy rather than just a different output format) that merits deeper investigation.

The interaction between instruction finetuning and RLHF. The paper demonstrates that instruction finetuning improves benchmark performance and zero-shot usability, but does not compare to or combine with reinforcement learning from human feedback (RLHF; Ouyang et al., 2022), which was contemporaneously shown to improve human preference alignment. A natural experiment would train three variants of the same base model: (a) instruction-finetuned only (Flan), (b) RLHF only (using human preference data, as in InstructGPT), and (c) Flan followed by RLHF. Evaluation would span both benchmark performance (MMLU, BBH, TyDiQA, MGSM) and human preference ratings on open-ended generation, testing whether the two techniques are complementary (Flan improves capability, RLHF improves alignment) or redundant (both improve instruction-following, so the combination shows diminishing returns). The paper's finding that Flan-U-PaLM combines additively with instruction finetuning (Section 5) provides suggestive evidence that post-hoc techniques can stack, but RLHF involves a fundamentally different training signal (human preferences vs. task supervision) that might interact differently. A negative result—RLHF erasing the benchmark gains from Flan—would have significant practical implications for the ordering of these techniques in deployment pipelines.

Iterated instruction finetuning: does a second round with new tasks help? The paper shows that instruction finetuning on top of a pretrained model provides a large one-time gain, and that continued pretraining followed by instruction finetuning provides additive benefits (Flan-cont-PaLM, Flan-U-PaLM). But what about multiple rounds of instruction finetuning with different task mixtures? A concrete experiment: take Flan-PaLM 62B (already instruction-finetuned on 1,836 tasks), construct a second mixture of entirely new tasks (from domains not represented in the first mixture, e.g., legal reasoning, medical diagnosis, code explanation), and apply a second round of instruction finetuning. Does the model continue to improve, or does the first round saturate the "instruction-following" meta-skill such that additional diverse tasks provide no further benefit? The paper's finding that scaling from 282 to 1,836 tasks provides diminishing returns (Figure 4, right) suggests that a second round might help only if the new tasks are qualitatively different from those in the first mixture—testing this would distinguish between the "diminishing returns due to task redundancy" and "diminishing returns due to meta-skill saturation" explanations.

Scaling the number of CoT datasets and reasoning diversity. The paper uses exactly 9 CoT datasets, all involving human-written reasoning chains for relatively structured tasks (math, multi-hop QA, NLI explanations). What happens when you scale to 50 or 100 CoT datasets spanning more diverse reasoning types—mathematical proofs, code execution traces, scientific argumentation, legal reasoning, ethical deliberation? The paper's finding that CoT generalization to held-out reasoning tasks works with only 9 datasets (Section 4.1) is promising, but the shape of the CoT scaling curve is completely unknown. A scaling experiment analogous to Figure 4 but focused on CoT data: vary the number of CoT datasets (9, 25, 50, 100) while holding non-CoT data constant at 1,827 tasks, and measure held-out CoT benchmark performance (MMLU-CoT, BBH-CoT, MGSM-CoT, plus additional reasoning benchmarks like LogiQA, ProofWriter, or MATH that were not in the finetuning mixture). The experiment would reveal whether CoT generalization saturates as quickly as non-CoT instruction-following (after ~282 tasks, per Figure 4) or continues to improve with broader reasoning diversity. A positive result—continued gains with more CoT datasets—would motivate a community effort to build large-scale, diverse CoT annotation resources, analogous to the NIV2 project for non-CoT tasks.

Cross-lingual transfer of instruction-following from English to low-resource languages. The paper's finetuning mixture includes 60 languages (Figure 18), and Flan-PaLM shows strong improvements on TyDiQA (+14.5 points, from 52.9% to 67.4%) and MGSM (+15.4 points for 540B) compared to PaLM. But how much of this multilingual gain comes from the multilingual finetuning data, versus from improved English instruction-following that transfers across languages? A clean ablation: finetune PaLM 540B on two mixtures—(a) the full 1,836-task mixture including multilingual tasks, and (b) an English-only version of the same mixture with all non-English tasks removed—and evaluate on TyDiQA, MGSM, and additional multilingual benchmarks (XQuAD, MLQA, XNLI). If the English-only mixture achieves comparable multilingual gains, it would demonstrate that instruction-following is a largely language-agnostic meta-skill that transfers across languages even when training data is monolingual—a significant finding for practitioners working with low-resource languages where constructing instruction-finetuning data is expensive. If the gains require multilingual finetuning data, it would establish a lower bound on how much target-language data is needed, motivating investment in multilingual instruction dataset creation.

Adversarial evaluation of instruction-following robustness. The paper's evaluation uses clean, in-distribution prompts from established benchmarks. But real users provide messy, ambiguous, underspecified, or contradictory instructions. How robust is instruction-finetuned behavior to these perturbations? A systematic stress-test would construct variants of existing benchmarks where instructions are perturbed along specific axes—removing key words ("Answer the following question" → "The following question"), adding contradictory constraints ("Answer briefly and in exhaustive detail"), using non-standard terminology, or embedding the instruction in irrelevant context—and measure whether Flan models maintain performance better than pretrained baselines. The paper's framing of instruction finetuning as teaching a meta-skill predicts that Flan models should be more robust than pretrained models (they've learned to extract task intent from varied phrasings), but the CoT degradation finding suggests brittleness to format shifts. Adversarial evaluation would reveal whether instruction-following is a shallow pattern-matching behavior or a deeper capability to infer intent, with direct implications for deployment safety.

Practical Applications and Downstream Use Cases

Default post-processing step in the LLM training pipeline. The paper's central practical recommendation—"we recommend instruction finetuning for virtually all pretrained language models" (Section 7)—is well-supported by the evidence. For any organization that pretrains large language models and releases them for general use (whether via API or open-source), instruction finetuning should be a standard, non-optional stage in the development pipeline. The compute argument is decisive: 0.2% of pretraining compute for PaLM 540B yields +9.4% normalized average across diverse benchmarks and transforms the model from one that human raters disprefer on zero-shot open-ended tasks (preferred only ~21% of the time) to one they strongly prefer (~79% of the time). The generality argument—demonstrated across encoder-decoder and decoder-only architectures, three pretraining objectives, and five orders of magnitude in parameter count—removes any concern that the benefits are architecture-specific. For a team releasing a new pretrained model, the default should be to include an instruction-finetuned variant alongside the raw checkpoint, with the instruction-finetuned version as the recommended entry point for downstream users who want zero-shot and few-shot capabilities without prompt engineering.

Enabling smaller models to serve as drop-in replacements for larger models in budget-constrained deployments. The cross-model results in Table 5 reveal that instruction-finetuned smaller models can match or exceed larger pretrained models without finetuning. Flan-T5-XL (3B parameters) achieves 52.4% on MMLU-direct, surpassing GPT-3 175B's 43.9%—a model nearly 60× larger. Flan-T5-XXL (11B) achieves 45.3% on BBH-direct, exceeding PaLM 62B's 37.5%. These results are not merely academic comparisons; they have direct implications for deployment cost. A 3B parameter model costs roughly 20× less to serve (in terms of memory, latency, and FLOPs per token) than a 62B model, and 60× less than a 175B model. For applications where inference cost dominates—high-volume customer support, real-time interactive systems, on-device deployment—using an instruction-finetuned smaller model instead of a pretrained larger model can dramatically reduce serving costs while maintaining or improving task performance. The key caveat is that this substitution works best for tasks within the smaller model's capability range; the paper's Table 5 shows that Flan-T5-XXL (11B) still cannot match PaLM 540B on MMLU (55.1% vs. 71.3% direct), so for the most demanding reasoning tasks, model scale remains necessary. But for the large fraction of practical NLP tasks where the smaller model's performance is sufficient, instruction finetuning enables cost savings of 20–60× without sacrificing quality.

Zero-shot deployment without prompt engineering or few-shot exemplars. The human evaluation results (Section 6, Figure 8) and the zero-shot CoT results (Section 4.3, Figure 6) together demonstrate that instruction-finetuned models can be used effectively in zero-shot settings—without carefully constructed prompts, without few-shot exemplars, and without domain expertise from the user. This has direct implications for product design. A product built on a pretrained-only model requires either (a) hard-coded prompt templates with few-shot exemplars selected by engineers, which limits the range of tasks the system can handle and requires ongoing maintenance as new task types emerge, or (b) exposing the raw model to end users and expecting them to provide exemplars, which is impractical for non-expert users. An instruction-finetuned model can be deployed with a simple interface—the user types a question or request in natural language, and the model responds appropriately using only the instruction text, without exemplars. The significance of "let's think step-by-step" zero-shot CoT reasoning (activated by a simple trigger phrase with no exemplars) further reduces the expertise required: users don't need to know which tasks require reasoning chains and which don't, or how to format reasoning exemplars. For product teams building user-facing LLM applications, this dramatically simplifies the deployment architecture and expands the addressable user base from prompt-engineering-savvy power users to general consumers.

Improving multilingual LLM performance without per-language finetuning. The TyDiQA and MGSM results show that instruction finetuning substantially improves multilingual performance even when the finetuning mixture's multilingual data is a small fraction of the total. Flan-PaLM 540B achieves 67.8% on TyDiQA (up from 52.9% for PaLM), with gains of +18.7 points on Arabic and +14.5 points on Swahili (Table 20). On MGSM, Flan-PaLM 540B achieves 72.0% with CoT + SC, including 69.6% on Bengali—a language where pretrained PaLM with CoT + SC achieved only 41.6% (implied from Table 21). For organizations deploying LLMs in multilingual contexts, these results suggest that constructing even a modestly-sized multilingual instruction finetuning mixture (the finetuning data includes only 60 languages; Figure 18) can unlock substantial zero-shot multilingual capabilities without the cost of per-language supervised finetuning. This is particularly valuable for low-resource languages where labeled task data is scarce or nonexistent. The practical recipe: include translation tasks, multilingual QA, and cross-lingual tasks in the instruction finetuning mixture, and the resulting model will transfer instruction-following behavior across languages, enabling users to interact with the model in their native language without the model having been explicitly finetuned on task-specific data in that language.

When to Prefer This Method

The paper explicitly positions instruction finetuning as a general method that should be applied to virtually all pretrained language models, rather than as one option among competing approaches. It does not frame instruction finetuning as a choice against named alternatives—instead, it demonstrates that instruction finetuning stacks productively with other model improvement techniques (UL2 continued pretraining, extended pretraining) and recommends it as a default stage in the development pipeline. The paper's own words in Section 7 capture this: "For these reasons, we recommend instruction finetuning for virtually all pretrained language models." The comparison is not "Flan vs. method X" but rather "pretrained model with Flan vs. pretrained model without Flan," and the answer is uniformly in Flan's favor across all architectures, scales, pretraining objectives, and evaluation paradigms tested. Since the paper does not articulate a tradeoff against a specific competing method (it is additive to, not substitutive for, other techniques), a formal "prefer A when / prefer B when" decision matrix would be artificial. The relevant decision is simply whether to include instruction finetuning—and the paper's evidence says yes, at a cost of 0.2–1.6% of pretraining compute, for any model intended for zero-shot or few-shot use.