GSM8K › Chain-of-Thought Evaluation

The breakthrough insight that transformed performance on GSM8K was the application of chain-of-thought (CoT) prompting. As we explored in prior chapters covering in-context learning emergence, reasoning capabilities in large language models often require explicit elicitation through prompting strategies that encourage step-by-step decomposition. Without such elicitation, even capable models may default to pattern matching or shortcut heuristics that fail on novel problem instances.

The mechanism behind chain-of-thought prompting parallels human cognitive strategies for complex problem solving. Just as students are taught to show their work to catch errors and maintain logical flow, language models benefit from externalizing intermediate computational steps. This externalization serves multiple functions: it breaks complex problems into manageable subproblems, it creates verification points where the model can check its own reasoning, and it increases the effective context available for solving each subcomponent by making intermediate results explicit rather than relying on implicit internal representations.

Standard few-shot prompting gives examples with direct question-answer pairs, presenting a mapping from problem statements to final solutions without intermediate reasoning:

When models answer this way, they must perform all reasoning internally without externalizing intermediate steps. For complex multi-step problems, this often leads to errors because the model cannot show its work and verify each sub-calculation. The internal computation must simultaneously track the initial quantity, the conversion from cans to individual balls, and the final aggregation, creating ample opportunity for information loss or arithmetic drift. The model's attention mechanism must hold multiple numerical quantities in implicit working memory across many layers, a fragile arrangement that becomes increasingly unreliable as problem complexity grows.

Chain-of-thought prompting instead gives reasoning traces that make the computational path explicit:

This approach yields large improvements across model scales. Large models (100B+ parameters) see accuracy increases from roughly 20% to over 60% when provided with chain-of-thought exemplars, while smaller models gain less benefit, suggesting that the capacity to generate useful reasoning chains emerges with scale. This scaling pattern indicates that chain-of-thought reasoning is a capability that develops as models acquire sufficient capacity to maintain and manipulate explicit intermediate states, rather than merely a prompting trick. Smaller models may lack the representational capacity to generate coherent reasoning chains while simultaneously solving the underlying mathematical operations.

A further refinement to chain-of-thought evaluation involves sampling multiple reasoning paths rather than relying on a single greedy decode. Self-consistency uses the observation that while individual reasoning chains may contain errors, the correct answer often emerges as the consensus across multiple independent attempts. This approach mirrors the human strategy of solving a problem multiple times to check for consistency.

The method operates through three specific stages:

1. Sampling $k$ different chain-of-thought reasoning paths from the model using non-zero temperature, encouraging diversity in solution approaches
2. Extracting the final answer from each path using the standard parsing methodology
3. Selecting the most frequent answer (majority voting) as the final prediction

Formally, let $a_1, a_2, \ldots, a_k$ be the answers extracted from $k$ independently sampled reasoning chains. The self-consistency prediction is:

$$\hat{a} = \arg\max_{a} \sum_{i=1}^{k} \mathbf{1}[a_i = a]$$

where $\mathbf{1}[a_i = a]$ is the indicator function that equals 1 when the $i$-th sample matches candidate answer $a$.

The independence assumption underlying this approach is that different sampling paths will produce uncorrelated errors. While all paths might occasionally err, they are unlikely to err in exactly the same way simultaneously. If the correct answer is 42 and an arithmetic mistake in one chain produces 40, a different error in another chain might produce 44. These wrong answers split the vote, while the correct answer 42 concentrates votes from all chains that executed without error. Empirical results show that self-consistency can boost GSM8K accuracy by an additional 10-20% beyond standard chain-of-thought prompting, though at increased computational cost proportional to $k$.

While few-shot examples help, researchers discovered that simply appending "Let's think step by step" to prompts lets zero-shot chain-of-thought reasoning. This simple phrase triggers models to generate intermediate reasoning steps even without exemplars, closing much of the gap between zero-shot and few-shot performance. The effectiveness of this minimal prompt suggests that models have learned the pattern of step-by-step reasoning from their training data and require only a lightweight retrieval cue to activate this behavior.

The effectiveness of this phrase reveals something important about the training of modern language models. During pre-training and instruction tuning, models encounter large quantities of explanatory text, step-by-step tutorials, and worked mathematical examples. The phrase "Let's think step by step" is a retrieval cue that activates this learned pattern of structured reasoning. It effectively puts the model into an explanation mode where it verbalizes its reasoning process rather than jumping directly to conclusions. This zero-shot capability is particularly useful in production environments where crafting few-shot examples for every problem type is impractical.

A significant extension beyond natural language chain-of-thought is the Program of Thought (PoT) approach, introduced by Chen et al. (2022). Instead of asking models to perform arithmetic in natural language, PoT prompts models to write Python code that computes the answer, then executes the code to obtain the result.

A PoT response to the Janet duck egg problem would look like: