Benchmarking large language models' complex reasoning ability with chain-of-thought prompting

Chain-of-Thought Hub: Measuring LLMs' Reasoning Performance

"A fantasy graph illustrating a chain of stars in a dark night with blue sky, digital art, super resolution". Midjourney V5

By Yao Fu, Litu Ou, Mingyu Chen, Yuhao Wan, Hao Peng, Tushar Khot, Wenhu Chen

From University of Edinburgh, University of Washington, Allen Institute for AI, University of Waterloo

[paper] [blog] [twitter]

Recently, there are a lot of progress in LLMs. Many claim that a small model less than 10B can achieve comparable performance to GPT-3.5. Really?

In a casual conversation, the distinction between GPT-3.5 and GPT-4 can be subtle. The difference comes out when *the complexity of the task reaches a sufficient threshold* — GPT-4 is more reliable, creative, and able to handle much more nuanced instructions than GPT-3.5. -- GPT-4 release blog

The key differentiator is whether a model can do complex tasks, like the old saying: "chit-chat is cheap, show me the reasoning." This is why we compile a list of complex reasoning tasks including math (GSM8K), science (MATH, TheoremQA), symbolic (BBH), knowledge (MMLU, C-Eval), coding (HumanEval), factual (SummEdits) to measure the models' performance on challenging tasks.

More importantly, we envisage large language models to become the next-generation computational platform and foster an ecosystem of LLM-based new applications. When this comes, chain-of-thought prompt engineering will be the next-generation system calls and shell scripts.

The resutls and scripts from Chain-of-thought Hub is being used and referred by leading industrial and academic organizations in the space of large language models.

[Call for contribution]: would love to invite community members to:

• Send a PR to fill in a missing number in the table
• Raise an issue to suggest a new task that can clearly differentiate models' performance
• Raise an issue to suggest a new model that can be added to the table

[UPDATE 20230609]: Add evaluation scripts on MMLU for LLaMA and Falcon

[UPDATE 20230601]: Add SummEdits

[UPDATE 20230527]: Add TheoremQA, add Vicuna, Alpaca, InstructCodeT5.

Leaderboard

Base means the pretrained checkpoint. SIFT means the checkpoint after supervised instruction finetuning. RLHF means the checkpoint after Reinforcement Learning from Human Feedback. Numbers marked with an asterisk * are from our own run, otherwise from multiple sources which we explain below. All methods are measured in accuracy, the higher the better.

What's different than other important evaluation?

• HeLM uses answer-only prompting, we use chain-of-thought promoting
• HeLM evaluates everything. We only focus on complex reasoning, the key differentiator of LLMs' capability.
• Open LLM Leaderboard evaluates open-sourced language models. We consider most leading models.
  • Currently, the performance of LLaMA 65B on Open LLM Leaderboard is just 48.8, which is significantly lower than the 63.4 reported in the paper. This casts doubts on the comparison between LLaMA and Falcon.
  • In our reproduction, we got 61.4 using the MMLU official prompt + greedy decoding + fp16. Our results favors the original LLaMA number and cast doublts on the results of Open LLM Leaderboard.
  • Our evaluation script is rather straightforward, most parameters are default, no fancy prompt engineering. We encourage the community to try out our scripts and reproduce our results.
  • According to Nathan Lambert, HuggingFace is currently redoing the backend of Open LLM Leaderboard, and the results may change (Jun 10 2023).
• Chatbot Arena evaluates chatbot models, which is more user-oriented at deployment. Our evaluation is more developer-oriented, and we consider on not only chatbots but also base models.

How the models are ranked

• If we know model scale, we rank it by scale.
• If we do not know model scale, we rank it by GSM8K, the classical benchmark measuring chain-of-thought math reasoning performance.
  • This is definitely not the only metric, but a good interpretation is "how good the model can do math while maintaining other generic abilities" -- which is also very hard.
  • GPT-4 is already pretrained on GSM8k training split, others may not. So for GPT-4, its perf. on GSM8k is in-distribution generalization, while for others are ood. generalization. Yet even for in-dist. FlanT5 is also trained on GSM8k, still shows perf. difference.
• Generally it is very hard to rigiously compare model perf. due to multiple factors (whether trained on the corresponding training split, whether trained on code, whether optimize prompt .etc). View our results as approximate reference.

Source of numbers

• GPT-4 from its website and Bubeck et al Mar 2023. Note that the version that Bubeck uses is GPT-4 Early which is supposedly to be more powerful than GPT-4 Launch (OpenAI paid a lot of alignment tax to make GPT-4 safer).
• *-davinci-00* and *PaLM are from the Flan-PaLM paper appendix.
  • code-davinci-002 is the base model of GPT-3.5 family but unfortunately it can no longer be accessed.
• LLaMA from LLaMA paper. Note that the prompt of LLaMA used in these tasks are not released so reproduction may have varied numbers, see this twitter thread for more discussions.
  • We are doing our own implementation of LLaMA on MMLU and BBH. Stay tuned.
  • We have reproduced LLaMA on MMLU using the official MMLU prompts and default HuggingFace Transformers generate() function, and our results matches the official numbers very well. See here for more details.
• Falcon on MMLU is from our own script here.
• PaLM-2 from their tech report.
• Claude is from our own test script, see below about how to run it.
• The HumanEval results for LLaMA models, PaLM and StartCoder are from HuggingFace report. Code-davinci-002's performance on HumanEval is from CodeT5+ paper
• C-Eval is from their website
• TheoremQA is from their github
• SummEdits is from their github and paper

Current results

• GPT-4 clearly outperforms all other models on GSM8K and MMLU.
• **The 65B LLaMA is very close to text/code-davinci-002, which means that based on it, if SFT and RLHF are done correctly, it is very likely that we could reproduce ChatGPT based on the 65B LLaMA**
• Claude is the only model family that is comparable to GPT family.
• On GSM8K, gpt-3.5-turbo improves over text-davinci-003. This confirms OpenAI's Jan 30 2023 release notes "improved mathematical capabilities."
• On MMLU, gpt-3.5-turbo is slightly better than text-davinci-003. But this level of margin is NOT SIGNIFICANT
• Also remember that gpt-3.5-turbo is 10 times cheaper than text-davinci-003
• Also be careful that GPT-4/ 3.5's performance on GSM8K is not true few-shot -- in GPT-4 report they said that they mixed a portion of GSM8K training set to train the model
• LLaMA performance on MMLU is from their paper and probably not CoT but AO. Generally on MMLU, AO is better than CoT but just slightly better. So the LLaMA numbers on MMLU might be slightly overestimated.

Visualization

• There is a clear gap between open-source and close.
• Most top models are after RLHF.
• LLaMA 65B is very close to code-davinc-002.
• Existing results strongly suggest that if RLHF is done right on LLaMA, it may be close to ChatGPT-3.5.

More about the tasks

• GSM8K: 8k elementary school math. -- Performance improvements on this dataset directly translate to daily math abilities when interacting with LLMs
• MMLU: 15k problems under 57 subjects, high school and college knowledge
• MATH (Hard!): 12k problems within 7 categories, very hard math and natural science. All current models struggle.
• BBH: 6.5k problems within 23 subsets, symbolic and text reasoning
• HumanEval: a classical handwritten dataset of 164 Python problems for evaluating coding capability.
• C-Eval: a collection of 13k multi-choice questions spanning 52 disciplines of knowledge test in Chinese.
• TheoremQA (Hard!): 800 QA pairs covering 350+ theorems spanning across Math, EE&CS, Physics and Finance.
• SummEdits: 6.3k factual consistency reasoning problems within 10 domains.

Run

MMLU

cd MMLU
mkdir outputs
API_KEY=<your_api_key>
# GPT-3.5-Turbo
python run_mmlu_gpt_3.5_turbo.py --api_key=${API_KEY}
# Claude-v1.3
python run_mmlu_claude.py --api_key=${API_KEY} --engine=claude-v1.3

# LLaMA
LLAMA_CKPT_DIR=<path to model checkpoints>
PARAM_SIZE=65 # 7, 13, 33, 65
MODEL_TYPE=llama # ["llama", "falcon"] 
python run_mmlu_open_source.py --ckpt_dir ${LLAMA_CKPT_DIR} --param_size ${PARAM_SIZE} --model_type ${MODEL_TYPE}

GSM8k

cd gsm8k 
mkdir outputs

# run gpt-3.5
# codex_gsm8k_complex.ipynb         -- code-davinci-002 + complex prompt
# gpt3.5turbo_gsm8k_complex.ipynb   -- gpt-3.5-turbo + complex prompt

# run claude
python run_gsm8k_claude.py\
  --anthropic_key=${API_KEY}\
  --prompt_file=lib_prompt/prompt_original.txt\
  --engine=claude-v1.3\
  --output_file=outputs/gsm8k_claude_v1.3_original_test.txt

# run FlanT5
# flan_t5_11b_gsm8k.ipynb

BBH

cd BBH
mkdir outputs
# then run jupyter notebook to see an example penguins dataset
cd penguins
# gpt3.5trubo_penguins_original.ipynb

# Or run the script for all datasets
API_KEY=<your_api_key>
TASK=<all | multiple_choice | free_form>
python run_bbh_gpt_3.5_turbo.py --api_key=${API_KEY} --task=${TASK} # task=all by default
python run_bbh_claude_v1.3.py --api_key=${API_KEY} --model_index=claude-v1.3 --task=${TASK} # task=all by default

FAQ

• The sensibility of model performance is very high.
  • Unfortunately, it is a nature of LLMs. We are currently taking efforts to standardize the prompts (see initial progress here) and will update more on it.
• What are the prompts used in the complexity-based prompting paper?
  • See research/complexity_based_prompting/
• I want to try some open-sourced model
  • See gsm8k/flan_t5_11b_gsm8k.ipynb for a place to start
• There are some prompts that have wrong answer
  • Yes, but we keep it as they are used in the original papers
  • Generally the model can be robust under prompt perturbation: even if sometimes there are errors in the prompt, as long as the format of the prompt is about the corresponding task, the model tend to only look at the format, ignore the prompt error, and make its own prediction.
  • See https://arxiv.org/abs/2202.12837 and https://arxiv.org/abs/2212.10001 about more analysis how the model can ignore errors in the prompt

I want to know more about building LLMs for reasoning tasks

A detailed roadmap is discussed in our previous blog post.

Generally, the recipe for building models of strong reasoning is the same as generic LLMs: pretraining, finetuning, reinforcement learning. Here we list some very important papers that should be considered:

Pretraining/ Continue Training

• Lewkowycz et. al. 2022. Minerva: Solving Quantitative Reasoning Problems with Language Models
• Taylor et. al. 2022. Galactica: A Large Language Model for Science

Finetuning

• Chung et. al. 2022. Scaling Instruction-Finetuned Language Models
• Li et. al. 2022. Competition-Level Code Generation with AlphaCode
• Fu et. al. 2023. Specializing Smaller Language Models towards Multi-Step Reasoning

Reinforcement Learning

• Uesato et. al. 2022. Solving math word problems with process- and outcome-based feedback
• Le et. al. 2022. CodeRL: Mastering Code Generation through Pretrained Models and Deep Reinforcement Learning
• Lightman et. al. 2023. Let’s Verify Step by Step

Under Development

• CotHub Standard Prompt Library
• TODOs
• Literature
• Detailed Results