LLM -Evolve: Evaluation for LLM ’s Evolving Capability on Benchmarks (2024)

Abstract: The advancement of large language models (LLMs) has extended their use to dynamic and interactive real-world applications, where models engage continuously with their environment and potentially enhance their performance over time. Most existing LLM benchmarks evaluate LLMs on i.i.d. tasks, overlooking their ability to learn iteratively from past experiences. Our paper bridges this evaluation gap by proposing a novel framework, LLM-Evolve, which extends established benchmarks to sequential problem-solving settings. LLM-Evolve evaluates LLMs over multiple rounds, providing feedback after each round to build a demonstration memory that the models can query in future tasks. We applied LLM-Evolve to the MMLU, GSM8K, and AgentBench benchmarks, testing 8 state-of-the-art open-source and closed-source models. Results show that LLMs can achieve performance improvements of up to 17% by learning from past interactions, with the quality of retrieval algorithms and feedback significantly influencing this capability. These insights advocate for more understanding and benchmarks for LLMs’ performance in evolving interactive scenarios.

## introduction the rapid development of llms has expanded their application to dynamic and interactive real-world scenarios, as known as llm-based agents. in these contexts, llms interact continuously with their environment, and their performance can evolve based on these interactions. despite these advancements, standard benchmarks for evaluating llms, such as the mmlu benchmark @xcite , treat each problem as an i.i.d. sample. this conventional approach fails to assess the ability of llms to learn from past experiences and enhance their performance over time. our study addresses this gap by exploring whether existing benchmarks can be adapted to evaluate llms' capabilities in iterative problemsolving scenarios. while developing entirely new benchmarks could provide insights into llm selfevolution, the process is often resource-intensive and costly. alternatively, combining or sampling from existing benchmarks, as seen in recent works @xcite @xcite , provides a more feasible solution but still requires extensive computational resources to rerun evaluations for all llms involved. instead, we chose a different approach: modifying the settings of established benchmarks, such as mmlu, without changing their test sets and metrics. this method offers flexibility, convenience, and direct comparability with existing benchmark results, enabling a deeper understanding of how llms improve by leveraging previous interactions. in this paper, we introduce llm-evolve, a novel evaluation framework that transforms popular llm benchmarks into a sequential problem-solving setting. under llm-evolve, llms are assessed across multiple rounds, where the environment will provide feedback on each round's outcomes to inform subsequent llm evaluations. specifically, the framework saves a given llm's inputs, outputs, and feedback to a demonstration memory, which the model can then query in future rounds to retrieve relevant experiences for few-shot learning on new tasks. this iterative process allows us to measure how effectively an llm can use its past experiences to evolve its capabilities over time. we apply the llm-evolve framework to three prominent benchmarks: mmlu for general language tasks, gsm8k for math problem solving @xcite , and agentbench @xcite which evaluates multi-round interaction capabilities of llms. our experiments include closed-source models including the gpt family and open-source models including the llama family, mistral, and qwen2, with a fixed generation temperature of 0 to eliminate the impact of random llm few-shot demo input output ... demo memory feedback llm llm-evolve round 1 true top-k retrieval true false x llm-evolve round 0 (standard setting) ... i , y llm i ) of an llm with positive feedback f @xmath0, which can be retrieved with a dense retriever r ϕ (•) as the few-shot demonstration in the next round of llm-evolve evaluation. further analysis reveals that the quality of the retrieval algorithm and feedback signals significantly influences an llm's evolving capabilities, and that more capable llms tend to benefit less from multi-round interactions. these interesting findings underscore the potential for adapting existing benchmarks to provide a more systematic evaluation of llms in dynamic and interactive environments. llm benchmarks derived from existing benchmarks researchers have extended existing llm benchmarks to study different properties of llms. for example, winogrande @xcite was introduced to reduce bias in winograd @xcite . @xcite , is a subset of 3,000 manually re-annotated questions of mmlu, used to study the discrepancies with the model performance metrics that were originally reported. mmlu-pro @xcite makes the orig-inal mmlu more robust, especially on reasoningfocused questions. our work extends the settings of existing llm benchmarks to study the interactive evolving capabilities of llms. it further reveals the correlations between benchmark problems, which could help create more diverse and robust llm benchmarks in the future. self-evolving llms. due to the rising size and capabilities of llms, recent efforts have improved the model accuracy on downstream tasks by using inference-based techniques such as refining the generated output through feedback @xcite , and learning through mistakes in icl by understanding core principles @xcite . we differ from these approaches by focusing on understanding llm's evolving capabilities in standard benchmarks. ## llm-evolve framework preliminaries for llm benchmarks. we use p θ to denote a pre-trained llm with parameter θ, x as the problem input, and y as the output. in a standard llm benchmark setting, fixed few-shot input-output (io) pairs are provided to facilitate llm inference, which can be represented as ## experiments benchmarks. we apply the llm-evolve framework to three prominent benchmarks: (1) mmlu for general language tasks, including 14k multichoice problems across 57 subject domains, commonly regarded as the gold standard in evaluating llms; (2) gsm8k, containing 8.5k high-quality linguistically diverse grade school math word problems, requiring an llm to accurately generate the exact numerical answer; (3) agentbench, which evaluates llms' multi-turn interaction capabilities when solving real-world problems, such as solving real-world problems on an operating system. we extend these benchmarks with llm-evolve with 4 rounds of experiments: all the llms start with the standard benchmark evaluation setting, then, 3 additional rounds of llm-evolve experiments are applied. we report the accuracy in all three benchmarks. due to limited resources, we focus on the os-std dataset in agentbench, where an llm needs on average 8 turns to solve each problem. models. we consider state-of-the-art opensource llm of different scales including llama model family @xcite , llama2-7b, llama2-70b, llama3-8b, and llama3-70b, mistral-7b-v0.2 (jiang et al., 2023), and qwen2-72b @xcite . we also experimented with closed-source lms, including gpt-4 @xcite and gpt-3.5-turbo provided by azure openai service. for all the models, we set the generation temperature to 0 to avoid any undesirable behaviors due to randomness. we run 7b/8b models on 1 nvidia a100 gpu, and 70b models on 8 nvidia a100 gpus; getting each round of llm-evolve for 1 llm approximately takes 1 hour. we use contriever @xcite as the retriever in llm-evolve due to its popularity. ## conclusion we presented llm-evolve, a framework that transforms standard llm benchmarks into a sequential problem-solving format, enabling the evaluation of llms' abilities to learn and improve through iterative interactions, and paving the way for future research to develop more sophisticated evaluation methods and enhance the evolving learning capabilities of llms in real-world applications.