Add files using upload-large-folder tool

.gitignore

@@ -0,0 +1,17 @@
+raw_data/
+scaling_out/
+scaling_out_old/
+sanity_check/
+demo/indices/
+# .vscode/
+*.log
+*pycache*
+outputs/
+*.pkl
+.history/
+scripts/
+lm_eval.egg-info/
+demo/experiment_results/**/*.json
+*.jsonl
+*.sh
+*.txt

LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Rulin Shao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,41 @@
+## Core
+
+`python ./demo/retrieval_demo.py` The main entrypoint.
+
+`python ./demo/generation_demo.py`
+
+`python ./demo/evaluation_demo.py`
+
+## Script
+
+`python ./demo/generation_experiment.py {diff_k, diff_dp}` to see how different k and different dp sizes affect the generation time and ttft (if not batch mode). See #8, result figures in #9 and #15.
+
+`python ./demo/validate_equivalence.py {sglang, vllm}` to generate answers and evaluate based on the prompts and retrieved passages in `scaling_out/retrieved_results/facebook/contriever-msmarco/fineweb_edu_1m_datastore-256_chunk_size-1of1_shards/top_3/0/nq_open_retrieved_results.jsonl`. See #6 and #10.
+
+`python ./demo/test_serve.py` to test the serve demo. You should open a server by `python ./demo/retrieval_demo.py serve` first. And currently the test_serve:main is sending requests in a pattern to show the breakdowns of different index types. We might change it in the future to test more scenarios. See #7 and #8.
+
+## Install DiskANN
+
+First build the project as [DiskANN/README.md](DiskANN/README.md). Use CMake to build the project, and the result will be in `./DiskANN/build/`.
+
+```bash
+pip install -e .
+```
+
+## Restrict the RAM
+
+```bash
+sudo mkdir -p /sys/fs/cgroup/memory/16gb
+sudo mkdir -p /sys/fs/cgroup/memory/32gb
+```
+
+```bash
+sudo sh -c 'echo 16000000000 > /sys/fs/cgroup/memory/16gb/memory.limit_in_bytes'
+sudo sh -c 'echo 16000000000 > /sys/fs/cgroup/memory/16gb/memory.memsw.limit_in_bytes'
+sudo sh -c 'echo 32000000000 > /sys/fs/cgroup/memory/32gb/memory.limit_in_bytes'
+sudo sh -c 'echo 32000000000 > /sys/fs/cgroup/memory/32gb/memory.memsw.limit_in_bytes'
+```
+
+```bash
+sudo sh -c 'echo $$ > /sys/fs/cgroup/memory/32gb/cgroup.procs && /home/ubuntu/miniconda3/envs/scaling/bin/python demo/retrieval_demo.py --skip-passages --skip-embeddings --domain rpj_wiki --search-only --load-indices ivf_disk'
+```

environment.yml

@@ -0,0 +1,23 @@
+name: scaling
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.11
+  - numpy
+  - faiss-gpu=1.8.0
+  - openjdk=17
+  
+  - pip:
+    - omegaconf
+    - hydra-core
+    - torch
+    - tqdm
+    - transformers
+    - sentence_transformers
+    - pyserini
+    - datasketch
+    - torch
+    - vllm

environment_cpu.yml

@@ -0,0 +1,21 @@
+name: scaling_cpu
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - python=3.11
+  - numpy
+  - pytorch
+  - cpuonly
+  - faiss-cpu=1.8.0
+  
+  - pip:
+    - omegaconf
+    - hydra-core
+    - tqdm
+    - transformers
+    - sentence_transformers
+    - pyserini
+    - datasketch

rag-evaluation-harness/.ruff_cache/.gitignore

@@ -0,0 +1,2 @@
+# Automatically created by ruff.
+*

rag-evaluation-harness/.ruff_cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

rag-evaluation-harness/CODEOWNERS

@@ -0,0 +1 @@
+* @haileyschoelkopf @lintangsutawika

rag-evaluation-harness/README.md

@@ -0,0 +1,561 @@
+# Retrieval Augmented Generation (RAG) Evaluation Harness
+Adapted From [Language Model Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness)
+
+This repository supports RAG evaluation on all downstream tasks supported in lm-evaluation-harnesses as of Jun 10, 2024.
+
+## Installation
+```bash
+git clone https://github.com/RulinShao/rag-evaluation-harness.git
+cd rag-evaluation-harness
+conda create -n lm-eval python=3.11
+pip install -e .
+```
+To use with VLLMs, also install
+```bash
+pip install lm_eval[vllm]
+```
+
+## Basic Usage
+We provide an example script to evaluate HuggingFace model with retrieval augmentation. Please refer to the below full documentation for LM-only evaluation and advanced usage.
+
+#### Step 1: Prepare retrieved documents.
+Users can easily obtain all evaluation inputs without few-shot demonstration, i.e., queries, by running
+```bash
+lm_eval --tasks "triviaqa" --inputs_save_dir "inputs" --save_inputs_only
+```
+This will save the inputs of TriviaQA in `inputs/triviaqa.jsonl` in a format of
+```json
+{"query": "Question: Who was the man behind The Chipmunks??\nAnswer:"}
+{"query": "Question: Which Lloyd Webber musical premiered in the US on 10th December 1993??\nAnswer:"}
+...
+```
+These inputs can be used as queries for retrieval.
+We assume retrieval is done offline before evaluation. Please save your retrieval augmentations in a jsonl file, in a format of
+```json
+{
+    "query": "Question: Who was the man behind The Chipmunks??\nAnswer:",
+    "ctxs": [
+        {"retrieval text": "Doc_0"},
+        {"retrieval text": "Doc_1"},
+        ...
+    ]
+}
+...
+```
+where `ctxs` is a list of retrieved documents from the most relevant to the least relevant that will be used for evaluation.
+
+#### Step 2: Evaluation.
+To run evaluation with the retrieved documents obatined at step 1:
+```bash
+MODEL_NAME_OR_PATH="meta-llama/Meta-Llama-3-8B"
+TASK="triviaqa"
+RETRIEVED_DOCS=/path/to/your/jsonl  # JSONL file obtained in Step 1
+
+lm_eval --model hf \
+    --model_args pretrained=$MODEL_NAME_OR_PATH \
+    --tasks $TASK \
+    --device cuda:0 \
+    --batch_size auto \
+    --retrieval_file $RETRIEVED_DOCS \
+    --concat_k 1
+```
+where `concat_k` specifies the number of documents that will be prepended in context when running evaluation. Set `concat_k=0` will degrade it to LM-only evaluation.
+
+Note: we use a simple prompt format for retrieval-augmented evaluation, where we prepend the retrieved documents before the input and few-shot examples in reverse order, i.e., `<DOC_k>...<DOC_0><FEWSHOT_m>...<FEWSHOT_0><QUESTION>`. Users can personalize their prompt format by modifying [this line](https://github.com/RulinShao/RAG-evaluation-harnesses/blob/main/lm_eval/evaluator.py#L500).
+
+## Q&A
+**Q: What tasks have been supported?**
+
+A: We refer to [this section](https://github.com/RulinShao/RAG-evaluation-harnesses#user-guide) to review a full list of supported tasks. We have benchmarked MMLU, TriviaQA, Natural Questions, MedQA, etc. with retrieval augmentations using this repository. If you run into issue with any other task, please file an issue ticket and we will work on it. 
+
+**Q: Can I add new evaluation tasks?**
+
+A: Yes! Lm-evaluation-harnesses support convenient integration of new tasks. You can add new tasks with HF datasets simply by defining a new configuration yaml file in [this folder](https://github.com/RulinShao/RAG-evaluation-harnesses/tree/main/lm_eval/tasks). We welcome PRs to supplement more tasks for RAG evaluation.
+
+**Q: I got OOM, what should I do?**
+
+A: If you are evaluating a large model, we recommend to use VLLM and turn on model parallelism. We refer to [this section](https://github.com/RulinShao/RAG-evaluation-harnesses/tree/main#tensor--data-parallel-and-optimized-inference-with-vllm) for more details.
+
+
+# Language Model Evaluation Harness
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10256836.svg)](https://doi.org/10.5281/zenodo.10256836)
+
+## Announcement
+**A new v0.4.0 release of lm-evaluation-harness is available** !
+
+New updates and features include:
+
+- Internal refactoring
+- Config-based task creation and configuration
+- Easier import and sharing of externally-defined task config YAMLs
+- Support for Jinja2 prompt design, easy modification of prompts + prompt imports from Promptsource
+- More advanced configuration options, including output post-processing, answer extraction, and multiple LM generations per document, configurable fewshot settings, and more
+- Speedups and new modeling libraries supported, including: faster data-parallel HF model usage, vLLM support, MPS support with HuggingFace, and more
+- Logging and usability changes
+- New tasks including CoT BIG-Bench-Hard, Belebele, user-defined task groupings, and more
+
+Please see our updated documentation pages in `docs/` for more details.
+
+Development will be continuing on the `main` branch, and we encourage you to give us feedback on what features are desired and how to improve the library further, or ask questions, either in issues or PRs on GitHub, or in the [EleutherAI discord](https://discord.gg/eleutherai)!
+
+## Overview
+
+This project provides a unified framework to test generative language models on a large number of different evaluation tasks.
+
+**Features:**
+- Over 60 standard academic benchmarks for LLMs, with hundreds of subtasks and variants implemented.
+- Support for models loaded via [transformers](https://github.com/huggingface/transformers/) (including quantization via [AutoGPTQ](https://github.com/PanQiWei/AutoGPTQ)), [GPT-NeoX](https://github.com/EleutherAI/gpt-neox), and [Megatron-DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed/), with a flexible tokenization-agnostic interface.
+- Support for fast and memory-efficient inference with [vLLM](https://github.com/vllm-project/vllm).
+- Support for commercial APIs including [OpenAI](https://openai.com), and [TextSynth](https://textsynth.com/).
+- Support for evaluation on adapters (e.g. LoRA) supported in [HuggingFace's PEFT library](https://github.com/huggingface/peft).
+- Support for local models and benchmarks.
+- Evaluation with publicly available prompts ensures reproducibility and comparability between papers.
+- Easy support for custom prompts and evaluation metrics.
+
+The Language Model Evaluation Harness is the backend for 🤗 Hugging Face's popular [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard), has been used in [hundreds of papers](https://scholar.google.com/scholar?oi=bibs&hl=en&authuser=2&cites=15052937328817631261,4097184744846514103,1520777361382155671,17476825572045927382,18443729326628441434,14801318227356878622,7890865700763267262,12854182577605049984,15641002901115500560,5104500764547628290), and is used internally by dozens of organizations including NVIDIA, Cohere, BigScience, BigCode, Nous Research, and Mosaic ML.
+
+## Install
+
+To install the `lm-eval` package from the github repository, run:
+
+```bash
+git clone https://github.com/EleutherAI/lm-evaluation-harness
+cd lm-evaluation-harness
+pip install -e .
+```
+
+We also provide a number of optional dependencies for extended functionality. A detailed table is available at the end of this document.
+
+## Basic Usage
+### User Guide
+
+A user guide detailing the full list of supported arguments is provided [here](./docs/interface.md), and on the terminal by calling `lm_eval -h`. Alternatively, you can use `lm-eval` instead of `lm_eval`.
+
+A list of supported tasks (or groupings of tasks) can be viewed with `lm-eval --tasks list`. Task descriptions and links to corresponding subfolders are provided [here](./lm_eval/tasks/README.md).
+
+### Hugging Face `transformers`
+
+To evaluate a model hosted on the [HuggingFace Hub](https://huggingface.co/models) (e.g. GPT-J-6B) on `hellaswag` you can use the following command (this assumes you are using a CUDA-compatible GPU):
+
+```bash
+lm_eval --model hf \
+    --model_args pretrained=EleutherAI/gpt-j-6B \
+    --tasks hellaswag \
+    --device cuda:0 \
+    --batch_size 8
+```
+
+Additional arguments can be provided to the model constructor using the `--model_args` flag. Most notably, this supports the common practice of using the `revisions` feature on the Hub to store partially trained checkpoints, or to specify the datatype for running a model:
+
+```bash
+lm_eval --model hf \
+    --model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype="float" \
+    --tasks lambada_openai,hellaswag \
+    --device cuda:0 \
+    --batch_size 8
+```
+
+Models that are loaded via both `transformers.AutoModelForCausalLM` (autoregressive, decoder-only GPT style models) and `transformers.AutoModelForSeq2SeqLM` (such as encoder-decoder models like T5) in Huggingface are supported.
+
+Batch size selection can be automated by setting the  ```--batch_size``` flag to ```auto```. This will perform automatic detection of the largest batch size that will fit on your device. On tasks where there is a large difference between the longest and shortest example, it can be helpful to periodically recompute the largest batch size, to gain a further speedup. To do this, append ```:N``` to above flag to automatically recompute the largest batch size ```N``` times. For example, to recompute the batch size 4 times, the command would be:
+
+```bash
+lm_eval --model hf \
+    --model_args pretrained=EleutherAI/pythia-160m,revision=step100000,dtype="float" \
+    --tasks lambada_openai,hellaswag \
+    --device cuda:0 \
+    --batch_size auto:4
+```
+
+> [!Note]
+> Just like you can provide a local path to `transformers.AutoModel`, you can also provide a local path to `lm_eval` via `--model_args pretrained=/path/to/model`
+
+#### Multi-GPU Evaluation with Hugging Face `accelerate`
+
+We support two main ways of using Hugging Face's [accelerate 🚀](https://github.com/huggingface/accelerate) library for multi-GPU evaluation.
+
+To perform *data-parallel evaluation* (where each GPU loads a **separate full copy** of the model), we leverage the `accelerate` launcher as follows:
+
+```
+accelerate launch -m lm_eval --model hf \
+    --tasks lambada_openai,arc_easy \
+    --batch_size 16
+```
+(or via `accelerate launch --no-python lm_eval`).
+
+For cases where your model can fit on a single GPU, this allows you to evaluate on K GPUs K times faster than on one.
+
+**WARNING**: This setup does not work with FSDP model sharding, so in `accelerate config` FSDP must be disabled, or the NO_SHARD FSDP option must be used.
+
+The second way of using `accelerate` for multi-GPU evaluation is when your model is *too large to fit on a single GPU.*
+
+In this setting, run the library *outside of the `accelerate` launcher*, but passing `parallelize=True` to `--model_args` as follows:
+
+```
+lm_eval --model hf \
+    --tasks lambada_openai,arc_easy \
+    --model_args parallelize=True \
+    --batch_size 16
+```
+
+This means that your model's weights will be split across all available GPUs.
+
+For more advanced users or even larger models, we allow for the following arguments when `parallelize=True` as well:
+- `device_map_option`: How to split model weights across available GPUs. defaults to "auto".
+- `max_memory_per_gpu`: the max GPU memory to use per GPU in loading the model.
+- `max_cpu_memory`: the max amount of CPU memory to use when offloading the model weights to RAM.
+- `offload_folder`: a folder where model weights will be offloaded to disk if needed.
+
+These two options (`accelerate launch` and `parallelize=True`) are mutually exclusive.
+
+**Note: we do not currently support multi-node evaluations natively, and advise using either an externally hosted server to run inference requests against, or creating a custom integration with your distributed framework [as is done for the GPT-NeoX library](https://github.com/EleutherAI/gpt-neox/blob/main/eval_tasks/eval_adapter.py).**
+
+### NVIDIA `nemo` models
+
+[NVIDIA NeMo Framework](https://github.com/NVIDIA/NeMo) is a generative AI framework built for researchers and pytorch developers working on language models.
+
+To evaluate a `nemo` model, start by installing NeMo following [the documentation](https://github.com/NVIDIA/NeMo?tab=readme-ov-file#installation). We highly recommended to use the NVIDIA PyTorch or NeMo container, especially if having issues installing Apex or any other dependencies (see [latest released containers](https://github.com/NVIDIA/NeMo/releases)). Please also install the lm evaluation harness library following the instructions in [the Install section](https://github.com/EleutherAI/lm-evaluation-harness/tree/main?tab=readme-ov-file#install).
+
+NeMo models can be obtained through [NVIDIA NGC Catalog](https://catalog.ngc.nvidia.com/models) or in [NVIDIA's Hugging Face page](https://huggingface.co/nvidia). In [NVIDIA NeMo Framework](https://github.com/NVIDIA/NeMo/tree/main/scripts/nlp_language_modeling) there are conversion scripts to convert the `hf` checkpoints of popular models like llama, falcon, mixtral or mpt to `nemo`.
+
+Run a `nemo` model on one GPU:
+```bash
+lm_eval --model nemo_lm \
+    --model_args path=<path_to_nemo_model> \
+    --tasks hellaswag \
+    --batch_size 32
+```
+
+It is recommended to unpack the `nemo` model to avoid the unpacking inside the docker container - it may overflow disk space. For that you can run:
+
+```
+mkdir MY_MODEL
+tar -xvf MY_MODEL.nemo -c MY_MODEL
+```
+
+#### Multi-GPU evaluation with NVIDIA `nemo` models
+
+By default, only one GPU is used. But we do support either data replication or tensor/pipeline parallelism during evaluation, on one node.
+
+1) To enable data replication, set the `model_args` of `devices` to the number of data replicas to run. For example, the command to run 8 data replicas over 8 GPUs is:
+```bash
+torchrun --nproc-per-node=8 --no-python lm_eval \
+    --model nemo_lm \
+    --model_args path=<path_to_nemo_model>,devices=8 \
+    --tasks hellaswag \
+    --batch_size 32
+```
+
+2) To enable tensor and/or pipeline parallelism, set the `model_args` of `tensor_model_parallel_size` and/or `pipeline_model_parallel_size`. In addition, you also have to set up `devices` to be equal to the product of `tensor_model_parallel_size` and/or `pipeline_model_parallel_size`. For example, the command to use one node of 4 GPUs with tensor parallelism of 2 and pipeline parallelism of 2 is:
+```bash
+torchrun --nproc-per-node=4 --no-python lm_eval \
+    --model nemo_lm \
+    --model_args path=<path_to_nemo_model>,devices=4,tensor_model_parallel_size=2,pipeline_model_parallel_size=2 \
+    --tasks hellaswag \
+    --batch_size 32
+```
+Note that it is recommended to substitute the `python` command by `torchrun --nproc-per-node=<number of devices> --no-python` to facilitate loading the model into the GPUs. This is especially important for large checkpoints loaded into multiple GPUs.
+
+Not supported yet: multi-node evaluation and combinations of data replication with tensor or pipeline parallelism.
+
+### Tensor + Data Parallel and Optimized Inference with `vLLM`
+
+We also support vLLM for faster inference on [supported model types](https://docs.vllm.ai/en/latest/models/supported_models.html), especially faster when splitting a model across multiple GPUs. For single-GPU or multi-GPU — tensor parallel, data parallel, or a combination of both — inference, for example:
+
+```bash
+lm_eval --model vllm \
+    --model_args pretrained={model_name},tensor_parallel_size={GPUs_per_model},dtype=auto,gpu_memory_utilization=0.8,data_parallel_size={model_replicas} \
+    --tasks lambada_openai \
+    --batch_size auto
+```
+To use vllm, do `pip install lm_eval[vllm]`. For a full list of supported vLLM configurations, please reference our [vLLM integration](https://github.com/EleutherAI/lm-evaluation-harness/blob/e74ec966556253fbe3d8ecba9de675c77c075bce/lm_eval/models/vllm_causallms.py) and the vLLM documentation.
+
+vLLM occasionally differs in output from Huggingface. We treat Huggingface as the reference implementation, and provide a [script](./scripts/model_comparator.py) for checking the validity of vllm results against HF.
+
+> [!Tip]
+> For fastest performance, we recommend using `--batch_size auto` for vLLM whenever possible, to leverage its continuous batching functionality!
+
+> [!Tip]
+> Passing `max_model_len=4096` or some other reasonable default to vLLM through model args may cause speedups or prevent out-of-memory errors when trying to use auto batch size, such as for Mistral-7B-v0.1 which defaults to a maximum length of 32k.
+
+### Model APIs and Inference Servers
+
+Our library also supports the evaluation of models served via several commercial APIs, and we hope to implement support for the most commonly used performant local/self-hosted inference servers.
+
+To call a hosted model, use:
+
+```bash
+export OPENAI_API_KEY=YOUR_KEY_HERE
+lm_eval --model openai-completions \
+    --model_args model=davinci \
+    --tasks lambada_openai,hellaswag
+```
+
+We also support using your own local inference server with servers that mirror the OpenAI Completions and ChatCompletions APIs.
+
+```bash
+lm_eval --model local-chat-completions --tasks gsm8k --model_args model=facebook/opt-125m,base_url=http://{yourip}:8000/v1
+```
+Note that for externally hosted models, configs such as `--device` and `--batch_size` should not be used and do not function. Just like you can use `--model_args` to pass arbitrary arguments to the model constructor for local models, you can use it to pass arbitrary arguments to the model API for hosted models. See the documentation of the hosting service for information on what arguments they support.
+
+| API or Inference Server                                                                                                   | Implemented?                    | `--model <xxx>` name                                                | Models supported:                                                                             | Request Types:                                             |
+|---------------------------------------------------------------------------------------------------------------------------|---------------------------------|---------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|------------------------------------------------------------|
+| OpenAI Completions                                                                                                        | :heavy_check_mark:              | `openai-completions`, `local-completions` | All OpenAI Completions API models                                            | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
+| OpenAI ChatCompletions                                                                                                    | :heavy_check_mark:        | `openai-chat-completions`, `local-chat-completions`                                                               | [All ChatCompletions API models](https://platform.openai.com/docs/guides/gpt)                 | `generate_until` (no logprobs)                             |
+| Anthropic                                                                                                                 | :heavy_check_mark:              | `anthropic`                                                         | [Supported Anthropic Engines](https://docs.anthropic.com/claude/reference/selecting-a-model)  | `generate_until` (no logprobs)                             |
+| Anthropic Chat                                                                                                                | :heavy_check_mark:              | `anthropic-chat`, `anthropic-chat-completions`                                                         | [Supported Anthropic Engines](https://docs.anthropic.com/claude/docs/models-overview)  | `generate_until` (no logprobs)                             |
+| Textsynth                                                                                                                 | :heavy_check_mark:                   | `textsynth`                                                         | [All supported engines](https://textsynth.com/documentation.html#engines)                     | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
+| Cohere                                                                                                                    | [:hourglass: - blocked on Cohere API bug](https://github.com/EleutherAI/lm-evaluation-harness/pull/395) | N/A                                                                 | [All `cohere.generate()` engines](https://docs.cohere.com/docs/models)                        | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
+| [Llama.cpp](https://github.com/ggerganov/llama.cpp) (via [llama-cpp-python](https://github.com/abetlen/llama-cpp-python)) | :heavy_check_mark:              | `gguf`, `ggml`                                                      | [All models supported by llama.cpp](https://github.com/ggerganov/llama.cpp)                   | `generate_until`, `loglikelihood`, (perplexity evaluation not yet implemented) |
+| vLLM                                                                                                                      | :heavy_check_mark:       | `vllm`                                                              | [Most HF Causal Language Models](https://docs.vllm.ai/en/latest/models/supported_models.html) | `generate_until`, `loglikelihood`, `loglikelihood_rolling` |
+| Mamba                       | :heavy_check_mark:       | `mamba_ssm`                                                                      | [Mamba architecture Language Models via the `mamba_ssm` package](https://huggingface.co/state-spaces) | `generate_until`, `loglikelihood`, `loglikelihood_rolling`                             |
+| Huggingface Optimum (Causal LMs)    | ✔️         | `openvino`                                 |     Any decoder-only AutoModelForCausalLM converted with Huggingface Optimum into OpenVINO™ Intermediate Representation (IR) format                           |  `generate_until`, `loglikelihood`, `loglikelihood_rolling`                         | ...                                                      |
+| Neuron via AWS Inf2 (Causal LMs)    | ✔️         | `neuronx`                                 |     Any decoder-only AutoModelForCausalLM supported to run on [huggingface-ami image for inferentia2](https://aws.amazon.com/marketplace/pp/prodview-gr3e6yiscria2)                         |  `generate_until`, `loglikelihood`, `loglikelihood_rolling`                         | ...                                                      |
+| [Neural Magic DeepSparse](https://github.com/neuralmagic/deepsparse)    | ✔️         | `deepsparse`                                 |     Any LM from [SparseZoo](https://sparsezoo.neuralmagic.com/) or on [HF Hub with the "deepsparse" tag](https://huggingface.co/models?other=deepsparse)                       |  `generate_until`, `loglikelihood`                         | ...                                                      |
+| [Neural Magic SparseML](https://github.com/neuralmagic/sparseml)    | ✔️         | `sparseml`                                 |     Any decoder-only AutoModelForCausalLM from [SparseZoo](https://sparsezoo.neuralmagic.com/) or on [HF Hub](https://huggingface.co/neuralmagic). Especially useful for models with quantization like [`zoo:llama2-7b-gsm8k_llama2_pretrain-pruned60_quantized`](https://sparsezoo.neuralmagic.com/models/llama2-7b-gsm8k_llama2_pretrain-pruned60_quantized)                         |  `generate_until`, `loglikelihood`, `loglikelihood_rolling`                         | ...                                                      |
+| Your local inference server!                                                                                              | :heavy_check_mark:                             | `local-completions` or `local-chat-completions` (using `openai-chat-completions` model type)    | Any server address that accepts GET requests using HF models and mirror's OpenAI's Completions or ChatCompletions interface                                  | `generate_until`                                           |                                | ...                |
+
+Models which do not supply logits or logprobs can be used with tasks of type `generate_until` only, while local models, or APIs that supply logprobs/logits of their prompts, can be run on all task types: `generate_until`, `loglikelihood`, `loglikelihood_rolling`, and `multiple_choice`.
+
+For more information on the different task `output_types` and model request types, see [our documentation](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/model_guide.md#interface).
+
+> [!Note]
+> For best performance with closed chat model APIs such as Anthropic Claude 3 and GPT-4, we recommend carefully looking at a few sample outputs using `--limit 10` first to confirm answer extraction and scoring on generative tasks is performing as expected. providing `system="<some system prompt here>"` within `--model_args` for anthropic-chat-completions, to instruct the model what format to respond in, may be useful.
+
+
+### Other Frameworks
+
+A number of other libraries contain scripts for calling the eval harness through their library. These include [GPT-NeoX](https://github.com/EleutherAI/gpt-neox/blob/main/eval_tasks/eval_adapter.py), [Megatron-DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed/blob/main/examples/MoE/readme_evalharness.md), and [mesh-transformer-jax](https://github.com/kingoflolz/mesh-transformer-jax/blob/master/eval_harness.py).
+
+To create your own custom integration you can follow instructions from [this tutorial](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/interface.md#external-library-usage).
+
+### Additional Features
+> [!Note]
+> For tasks unsuitable for direct evaluation — either due risks associated with executing untrusted code or complexities in the evaluation process — the `--predict_only` flag is available to obtain decoded generations for post-hoc evaluation.
+
+If you have a Metal compatible Mac, you can run the eval harness using the MPS back-end by replacing `--device cuda:0` with `--device mps` (requires PyTorch version 2.1 or higher). **Note that the PyTorch MPS backend is still in early stages of development, so correctness issues or unsupported operations may exist. If you observe oddities in model performance on the MPS back-end, we recommend first checking that a forward pass of your model on `--device cpu` and `--device mps` match.**
+
+> [!Note]
+> You can inspect what the LM inputs look like by running the following command:
+> ```bash
+> python write_out.py \
+>     --tasks <task1,task2,...> \
+>     --num_fewshot 5 \
+>     --num_examples 10 \
+>     --output_base_path /path/to/output/folder
+> ```
+> This will write out one text file for each task.
+
+To verify the data integrity of the tasks you're performing in addition to running the tasks themselves, you can use the `--check_integrity` flag:
+
+```bash
+lm_eval --model openai \
+    --model_args engine=davinci \
+    --tasks lambada_openai,hellaswag \
+    --check_integrity
+```
+
+## Advanced Usage Tips
+
+For models loaded with the HuggingFace  `transformers` library, any arguments provided via `--model_args` get passed to the relevant constructor directly. This means that anything you can do with `AutoModel` can be done with our library. For example, you can pass a local path via `pretrained=` or use models finetuned with [PEFT](https://github.com/huggingface/peft) by taking the call you would run to evaluate the base model and add `,peft=PATH` to the `model_args` argument:
+```bash
+lm_eval --model hf \
+    --model_args pretrained=EleutherAI/gpt-j-6b,parallelize=True,load_in_4bit=True,peft=nomic-ai/gpt4all-j-lora \
+    --tasks openbookqa,arc_easy,winogrande,hellaswag,arc_challenge,piqa,boolq \
+    --device cuda:0
+```
+
+Models provided as delta weights can be easily loaded using the Hugging Face transformers library. Within --model_args, set the delta argument to specify the delta weights, and use the pretrained argument to designate the relative base model to which they will be applied:
+```bash
+lm_eval --model hf \
+    --model_args pretrained=Ejafa/llama_7B,delta=lmsys/vicuna-7b-delta-v1.1 \
+    --tasks hellaswag
+```
+
+[GPTQ](https://github.com/PanQiWei/AutoGPTQ) quantized models can be loaded by specifying their file names in `,autogptq=NAME` (or `,autogptq=True` for default names) in the `model_args` argument:
+
+```bash
+lm_eval --model hf \
+    --model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True \
+    --tasks hellaswag
+```
+
+We support wildcards in task names, for example you can run all of the machine-translated lambada tasks via `--task lambada_openai_mt_*`.
+
+## Saving Results
+
+To save evaluation results provide an `--output_path`. We also support logging model responses with the `--log_samples` flag for post-hoc analysis.
+
+Additionally, one can provide a directory with `--use_cache` to cache the results of prior runs. This allows you to avoid repeated execution of the same (model, task) pairs for re-scoring.
+
+To push results and samples to the Hugging Face Hub, first ensure an access token with write access is set in the `HF_TOKEN` environment variable. Then, use the `--hf_hub_log_args` flag to specify the organization, repository name, repository visibility, and whether to push results and samples to the Hub - [example dataset on the  HF Hub](https://huggingface.co/datasets/KonradSzafer/lm-eval-results-demo). For instance:
+
+```bash
+lm_eval --model hf \
+    --model_args pretrained=model-name-or-path,autogptq=model.safetensors,gptq_use_triton=True \
+    --tasks hellaswag \
+    --log_samples \
+    --output_path results \
+    --hf_hub_log_args hub_results_org=EleutherAI,hub_repo_name=lm-eval-results,push_results_to_hub=True,push_samples_to_hub=True,public_repo=False \
+```
+
+This allows you to easily download the results and samples from the Hub, using:
+```python
+from datasets import load_dataset
+
+load_dataset("EleutherAI/lm-eval-results-private", "hellaswag", "latest")
+```
+
+For a full list of supported arguments, check out the [interface](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/docs/interface.md) guide in our documentation!
+
+## Visualizing Results
+
+You can seamlessly visualize and analyze the results of your evaluation harness runs using both Weights & Biases (W&B) and Zeno.
+
+### Zeno
+
+You can use [Zeno](https://zenoml.com) to visualize the results of your eval harness runs.
+
+First, head to [hub.zenoml.com](https://hub.zenoml.com) to create an account and get an API key [on your account page](https://hub.zenoml.com/account).
+Add this key as an environment variable:
+
+```bash
+export ZENO_API_KEY=[your api key]
+```
+
+You'll also need to install the `lm_eval[zeno]` package extra.
+
+To visualize the results, run the eval harness with the `log_samples` and `output_path` flags.
+We expect `output_path` to contain multiple folders that represent individual model names.
+You can thus run your evaluation on any number of tasks and models and upload all of the results as projects on Zeno.
+
+```bash
+lm_eval \
+    --model hf \
+    --model_args pretrained=EleutherAI/gpt-j-6B \
+    --tasks hellaswag \
+    --device cuda:0 \
+    --batch_size 8 \
+    --log_samples \
+    --output_path output/gpt-j-6B
+```
+
+Then, you can upload the resulting data using the `zeno_visualize` script:
+
+```bash
+python scripts/zeno_visualize.py \
+    --data_path output \
+    --project_name "Eleuther Project"
+```
+
+This will use all subfolders in `data_path` as different models and upload all tasks within these model folders to Zeno.
+If you run the eval harness on multiple tasks, the `project_name` will be used as a prefix and one project will be created per task.
+
+You can find an example of this workflow in [examples/visualize-zeno.ipynb](examples/visualize-zeno.ipynb).
+
+### Weights and Biases
+
+With the [Weights and Biases](https://wandb.ai/site) integration, you can now spend more time extracting deeper insights into your evaluation results. The integration is designed to streamline the process of logging and visualizing experiment results using the Weights & Biases (W&B) platform.
+
+The integration provide functionalities
+
+- to automatically log the evaluation results,
+- log the samples as W&B Tables for easy visualization,
+- log the `results.json` file as an artifact for version control,
+- log the `<task_name>_eval_samples.json` file if the samples are logged,
+- generate a comprehensive report for analysis and visualization with all the important metric,
+- log task and cli specific configs,
+- and more out of the box like the command used to run the evaluation, GPU/CPU counts, timestamp, etc.
+
+First you'll need to install the lm_eval[wandb] package extra. Do `pip install lm_eval[wandb]`.
+
+Authenticate your machine with an your unique W&B token. Visit https://wandb.ai/authorize to get one. Do `wandb login` in your command line terminal.
+
+Run eval harness as usual with a `wandb_args` flag. Use this flag to provide arguments for initializing a wandb run ([wandb.init](https://docs.wandb.ai/ref/python/init)) as comma separated string arguments.
+
+```bash
+lm_eval \
+    --model hf \
+    --model_args pretrained=microsoft/phi-2,trust_remote_code=True \
+    --tasks hellaswag,mmlu_abstract_algebra \
+    --device cuda:0 \
+    --batch_size 8 \
+    --output_path output/phi-2 \
+    --limit 10 \
+    --wandb_args project=lm-eval-harness-integration \
+    --log_samples
+```
+
+In the stdout, you will find the link to the W&B run page as well as link to the generated report. You can find an example of this workflow in [examples/visualize-wandb.ipynb](examples/visualize-wandb.ipynb), and an example of how to integrate it beyond the CLI.
+
+## How to Contribute or Learn More?
+
+For more information on the library and how everything fits together, check out all of our [documentation pages](https://github.com/EleutherAI/lm-evaluation-harness/tree/main/docs)! We plan to post a larger roadmap of desired + planned library improvements soon, with more information on how contributors can help.
+
+### Implementing new tasks
+
+To implement a new task in the eval harness, see [this guide](./docs/new_task_guide.md).
+
+In general, we follow this priority list for addressing concerns about prompting and other eval details:
+1. If there is widespread agreement among people who train LLMs, use the agreed upon procedure.
+2. If there is a clear and unambiguous official implementation, use that procedure.
+3. If there is widespread agreement among people who evaluate LLMs, use the agreed upon procedure.
+4. If there are multiple common implementations but not universal or widespread agreement, use our preferred option among the common implementations. As before, prioritize choosing from among the implementations found in LLM training papers.
+
+These are guidelines and not rules, and can be overruled in special circumstances.
+
+We try to prioritize agreement with the procedures used by other groups to decrease the harm when people inevitably compare runs across different papers despite our discouragement of the practice. Historically, we also prioritized the implementation from [Language Models are Few Shot Learners](https://arxiv.org/abs/2005.14165) as our original goal was specifically to compare results with that paper.
+
+### Support
+
+The best way to get support is to open an issue on this repo or join the [EleutherAI Discord server](https://discord.gg/eleutherai). The `#lm-thunderdome` channel is dedicated to developing this project and the `#release-discussion` channel is for receiving support for our releases. If you've used the library and have had a positive (or negative) experience, we'd love to hear from you!
+
+## Optional Extras
+Extras dependencies can be installed via `pip install -e ".[NAME]"`
+
+| Name          | Use                                   |
+|---------------|---------------------------------------|
+| anthropic     | For using Anthropic's models          |
+| deepsparse     | For running NM's DeepSparse models    |
+| dev           | For linting PRs and contributions     |
+| gptq          | For loading models with GPTQ          |
+| hf_transfer   | For speeding up HF Hub file downloads |
+| ifeval        | For running the IFEval task           |
+| neuronx       | For running on AWS inf2 instances     |
+| mamba         | For loading Mamba SSM models          |
+| math          | For running math task answer checking |
+| multilingual  | For multilingual tokenizers           |
+| openai        | For using OpenAI's models             |
+| optimum       | For running Intel OpenVINO models     |
+| promptsource  | For using PromptSource prompts        |
+| sentencepiece | For using the sentencepiece tokenizer |
+| sparseml      | For using NM's SparseML models        |
+| testing       | For running library test suite        |
+| unitxt        | For IBM's unitxt dataset tasks        |
+| vllm          | For loading models with vLLM          |
+| zeno          | For visualizing results with Zeno     |
+|---------------|---------------------------------------|
+| all           | Loads all extras (not recommended)    |
+
+## Cite as
+
+```
+@article{shao2024scaling,
+  title={Scaling Retrieval-Based Language Models with a Trillion-Token Datastore},
+  author={Shao, Rulin and He, Jacqueline and Asai, Akari and Shi, Weijia and Dettmers, Tim and Min, Sewon and Zettlemoyer, Luke and Koh, Pang Wei},
+  journal={arXiv preprint arXiv:2407.12854},
+  year={2024}
+}
+
+@misc{eval-harness,
+  author       = {Gao, Leo and Tow, Jonathan and Abbasi, Baber and Biderman, Stella and Black, Sid and DiPofi, Anthony and Foster, Charles and Golding, Laurence and Hsu, Jeffrey and Le Noac'h, Alain and Li, Haonan and McDonell, Kyle and Muennighoff, Niklas and Ociepa, Chris and Phang, Jason and Reynolds, Laria and Schoelkopf, Hailey and Skowron, Aviya and Sutawika, Lintang and Tang, Eric and Thite, Anish and Wang, Ben and Wang, Kevin and Zou, Andy},
+  title        = {A framework for few-shot language model evaluation},
+  month        = 12,
+  year         = 2023,
+  publisher    = {Zenodo},
+  version      = {v0.4.0},
+  doi          = {10.5281/zenodo.10256836},
+  url          = {https://zenodo.org/records/10256836}
+}
+```

rag-evaluation-harness/lm_eval/evaluator.py

@@ -0,0 +1,921 @@
+import os
+import itertools
+import json
+import jsonlines
+import logging
+import random
+import time
+from collections import defaultdict
+from typing import TYPE_CHECKING, List, Optional, Union
+
+import numpy as np
+import torch
+
+import lm_eval.api.metrics
+import lm_eval.api.registry
+import lm_eval.models
+from lm_eval.caching.cache import delete_cache
+from lm_eval.evaluator_utils import (
+    consolidate_results,
+    get_sample_size,
+    get_task_list,
+    prepare_print_tasks,
+    print_writeout,
+    run_task_tests,
+)
+from lm_eval.loggers import EvaluationTracker
+from lm_eval.loggers.utils import add_env_info, get_git_commit_hash
+from lm_eval.tasks import TaskManager, get_task_dict
+from lm_eval.utils import (
+    eval_logger,
+    handle_non_serializable,
+    hash_string,
+    positional_deprecated,
+    simple_parse_args_string,
+)
+
+
+if TYPE_CHECKING:
+    from lm_eval.api.model import LM
+    from lm_eval.tasks import Task
+
+
+@positional_deprecated
+def simple_evaluate(
+    model,
+    model_args: Optional[Union[str, dict]] = None,
+    tasks: Optional[List[Union[str, dict, object]]] = None,
+    num_fewshot: Optional[int] = None,
+    batch_size: Optional[int] = None,
+    max_batch_size: Optional[int] = None,
+    device: Optional[str] = None,
+    use_cache: Optional[str] = None,
+    cache_requests: bool = False,
+    rewrite_requests_cache: bool = False,
+    delete_requests_cache: bool = False,
+    limit: Optional[Union[int, float]] = None,
+    bootstrap_iters: int = 100000,
+    check_integrity: bool = False,
+    write_out: bool = False,
+    log_samples: bool = True,
+    evaluation_tracker: Optional[EvaluationTracker] = None,
+    system_instruction: Optional[str] = None,
+    apply_chat_template: bool = False,
+    fewshot_as_multiturn: bool = False,
+    gen_kwargs: Optional[str] = None,
+    task_manager: Optional[TaskManager] = None,
+    verbosity: str = "INFO",
+    predict_only: bool = False,
+    random_seed: int = 0,
+    numpy_random_seed: int = 1234,
+    torch_random_seed: int = 1234,
+    fewshot_random_seed: int = 1234,
+    retrieval_args: dict = {},
+):
+    """Instantiate and evaluate a model on a list of tasks.
+
+    :param model: Union[str, LM]
+        Name of model or LM object, see lm_eval.models.get_model
+    :param model_args: Optional[str, dict]
+        String or dict arguments for each model class, see LM.create_from_arg_string and LM.create_from_arg_object.
+        Ignored if `model` argument is a LM object.
+    :param tasks: list[Union[str, dict, Task]]
+        List of task names or Task objects. Task objects will be taken to have name task.EVAL_HARNESS_NAME if defined and type(task).__name__ otherwise.
+    :param num_fewshot: int
+        Number of examples in few-shot context
+    :param batch_size: int or str, optional
+        Batch size for model
+    :param max_batch_size: int, optional
+        Maximal batch size to try with automatic batch size detection
+    :param device: str, optional
+        PyTorch device (e.g. "cpu" or "cuda:0") for running models
+    :param use_cache: str, optional
+        A path to a sqlite db file for caching model responses. `None` if not caching.
+    :param cache_requests: bool, optional
+        Speed up evaluation by caching the building of dataset requests. `None` if not caching.
+    :param rewrite_requests_cache: bool, optional
+        Rewrites all of the request cache if set to `True`. `None` if not desired.
+    :param delete_requests_cache: bool, optional
+        Deletes all of the request cache if set to `True`. `None` if not desired.
+    :param limit: int or float, optional
+        Limit the number of examples per task (only use this for testing), If <1, limit is a percentage of the total number of examples.
+    :param bootstrap_iters:
+        Number of iterations for bootstrap statistics, used when calculating stderrs. set to 0 for no stderr calculations to be performed.
+    :param check_integrity: bool
+        Whether to run the relevant part of the test suite for the tasks
+    :param write_out: bool
+        If True, write out an example document and model input for checking task integrity
+    :param log_samples: bool
+        If True, write out all model outputs and documents for per-sample measurement and post-hoc analysis
+    :param system_instruction: str
+        System instruction to be applied to the prompt
+    :param apply_chat_template: bool
+        If True, apply chat template to the prompt
+    :param fewshot_as_multiturn: bool
+        Whether to provide the fewshot examples as a multiturn conversation or a single user turn.
+    :param gen_kwargs: str
+        String arguments for model generation
+        Ignored for all tasks with loglikelihood output_type
+    :param predict_only: bool
+        If true only model outputs will be generated and returned. Metrics will not be evaluated
+    :param random_seed: int
+        Random seed for python's random module. If set to None, the seed will not be set.
+    :param numpy_random_seed: int
+        Random seed for numpy. If set to None, the seed will not be set.
+    :param torch_random_seed: int
+        Random seed for torch. If set to None, the seed will not be set.
+    :param fewshot_random_seed: int
+        Random seed for fewshot sampler random generator. If set to None, the seed of generator will be set to None.
+
+    :return
+        Dictionary of results
+
+    """
+    # os pid print and then sllep 30s
+    eval_logger.setLevel(getattr(logging, f"{verbosity}"))
+    start_date = time.time()
+
+    if delete_requests_cache:
+        eval_logger.info("Deleting requests cache...")
+        delete_cache()
+
+    seed_message = []
+    if random_seed is not None:
+        # See https://github.com/EleutherAI/lm-evaluation-harness/pull/1412
+        seed_message.append(f"Setting random seed to {random_seed}")
+        random.seed(random_seed)
+
+    if numpy_random_seed is not None:
+        seed_message.append(f"Setting numpy seed to {numpy_random_seed}")
+        np.random.seed(numpy_random_seed)
+
+    if torch_random_seed is not None:
+        seed_message.append(f"Setting torch manual seed to {torch_random_seed}")
+        torch.manual_seed(torch_random_seed)
+
+    if seed_message:
+        eval_logger.info(" | ".join(seed_message))
+
+    if tasks is None:
+        tasks = []
+    if len(tasks) == 0:
+        raise ValueError(
+            "No tasks specified, or no tasks found. Please verify the task names."
+        )
+
+    if gen_kwargs is not None:
+        gen_kwargs = simple_parse_args_string(gen_kwargs)
+        eval_logger.warning(
+            "generation_kwargs specified through cli, these settings will update set parameters in yaml tasks. "
+            "Ensure 'do_sample=True' for non-greedy decoding!"
+        )
+        if gen_kwargs == "":
+            gen_kwargs = None
+
+    if isinstance(model, str):
+        if retrieval_args["save_inputs_only"] and not model_args:
+            model = "hf"
+            model_args = "pretrained=openai-community/gpt2"  # load a very small model that will not be used
+
+        if model_args is None:
+            eval_logger.warning("model_args not specified. Using defaults.")
+            model_args = ""
+
+        if isinstance(model_args, dict):
+            eval_logger.info(
+                f"Initializing {model} model, with arguments: {model_args}"
+            )
+            lm = lm_eval.api.registry.get_model(model).create_from_arg_obj(
+                model_args,
+                {
+                    "batch_size": batch_size,
+                    "max_batch_size": max_batch_size,
+                    "device": device,
+                },
+            )
+
+        else:
+            eval_logger.info(
+                f"Initializing {model} model, with arguments: {simple_parse_args_string(model_args)}"
+            )
+            lm = lm_eval.api.registry.get_model(model).create_from_arg_string(
+                model_args,
+                {
+                    "batch_size": batch_size,
+                    "max_batch_size": max_batch_size,
+                    "device": device,
+                },
+            )
+    else:
+        if not isinstance(model, lm_eval.api.model.LM):
+            raise TypeError
+        eval_logger.info("Using pre-initialized model")
+        lm = model
+
+    if use_cache is not None:
+        eval_logger.info(f"Using cache at {use_cache + '_rank' + str(lm.rank) + '.db'}")
+        lm = lm_eval.api.model.CachingLM(
+            lm,
+            use_cache
+            # each rank receives a different cache db.
+            # necessary to avoid multiple writes to cache at once
+            + "_rank"
+            + str(lm.rank)
+            + ".db",
+        )
+
+    if task_manager is None:
+        task_manager = TaskManager(verbosity)
+
+    task_dict = get_task_dict(tasks, task_manager)
+    for task_name in task_dict.keys():
+        task_obj = task_dict[task_name]
+        if isinstance(task_obj, tuple):
+            _, task_obj = task_obj
+            if task_obj is None:
+                continue
+
+        if task_obj.get_config("output_type") == "generate_until":
+            if gen_kwargs is not None:
+                task_obj.set_config(
+                    key="generation_kwargs", value=gen_kwargs, update=True
+                )
+
+        if predict_only:
+            log_samples = True
+            eval_logger.info(
+                f"Processing {task_name} in output-only mode. Metrics will not be calculated!"
+            )
+            # we have to change the class properties post-hoc. This is pretty hacky.
+            task_obj.override_metric(metric_name="bypass")
+
+        # override tasks' fewshot values to the provided num_fewshot arg value
+        # except if tasks have it set to 0 manually in their configs--then we should never overwrite that
+        if num_fewshot is not None:
+            if (default_num_fewshot := task_obj.get_config("num_fewshot")) == 0:
+                eval_logger.info(
+                    f"num_fewshot has been set to 0 for {task_name} in its config. Manual configuration will be ignored."
+                )
+            else:
+                eval_logger.warning(
+                    f"Overwriting default num_fewshot of {task_name} from {default_num_fewshot} to {num_fewshot}"
+                )
+                task_obj.set_config(key="num_fewshot", value=num_fewshot)
+        else:
+            # if num_fewshot not provided, and the task does not define a default one, default to 0
+            if (default_num_fewshot := task_obj.get_config("num_fewshot")) is None:
+                task_obj.set_config(key="num_fewshot", value=0)
+        # fewshot_random_seed set for tasks, even with a default num_fewshot (e.g. in the YAML file)
+        task_obj.set_fewshot_seed(seed=fewshot_random_seed)
+        eval_logger.info(
+            f"Setting fewshot random generator seed to {fewshot_random_seed}"
+        )
+
+    if check_integrity:
+        run_task_tests(task_list=tasks)
+
+    if evaluation_tracker is not None:
+        evaluation_tracker.general_config_tracker.log_experiment_args(
+            model_source=model,
+            model_args=model_args,
+            system_instruction=system_instruction,
+            chat_template=lm.chat_template if apply_chat_template else None,
+        )
+
+    results = evaluate(
+        lm=lm,
+        task_dict=task_dict,
+        limit=limit,
+        cache_requests=cache_requests,
+        rewrite_requests_cache=rewrite_requests_cache,
+        bootstrap_iters=bootstrap_iters,
+        write_out=write_out,
+        log_samples=log_samples,
+        system_instruction=system_instruction,
+        apply_chat_template=apply_chat_template,
+        fewshot_as_multiturn=fewshot_as_multiturn,
+        verbosity=verbosity,
+        retrieval_args=retrieval_args,
+    )
+
+    if lm.rank == 0 and results is not None:
+        if isinstance(model, str):
+            model_name = model
+        elif hasattr(model, "config") and hasattr(model.config, "_name_or_path"):
+            model_name = model.config._name_or_path
+        else:
+            model_name = type(model).__name__
+
+        # add info about the model and few shot config
+        results["config"] = {
+            "model": model_name,
+            "model_args": model_args,
+        }
+        # add more detailed model info if available
+        if isinstance(lm, lm_eval.models.huggingface.HFLM):
+            results["config"].update(lm.get_model_info())
+        # add info about execution
+        results["config"].update(
+            {
+                "batch_size": batch_size,
+                "batch_sizes": (
+                    list(lm.batch_sizes.values()) if hasattr(lm, "batch_sizes") else []
+                ),
+                "device": device,
+                "use_cache": use_cache,
+                "limit": limit,
+                "bootstrap_iters": bootstrap_iters,
+                "gen_kwargs": gen_kwargs,
+                "random_seed": random_seed,
+                "numpy_seed": numpy_random_seed,
+                "torch_seed": torch_random_seed,
+                "fewshot_seed": fewshot_random_seed,
+            }
+        )
+        results["git_hash"] = get_git_commit_hash()
+        results["date"] = start_date
+        add_env_info(results)  # additional environment info to results
+        return results
+    else:
+        return None
+
+
+@positional_deprecated
+def evaluate(
+    lm: "LM",
+    task_dict,
+    limit: Optional[int] = None,
+    cache_requests: bool = False,
+    rewrite_requests_cache: bool = False,
+    bootstrap_iters: Optional[int] = 100000,
+    write_out: bool = False,
+    log_samples: bool = True,
+    system_instruction: Optional[str] = None,
+    apply_chat_template: bool = False,
+    fewshot_as_multiturn: bool = False,
+    verbosity: str = "INFO",
+    retrieval_args: dict = {},
+):
+    """Instantiate and evaluate a model on a list of tasks.
+
+    :param lm: obj
+        Language Model
+    :param task_dict: dict[str, Task]
+        Dictionary of tasks. Tasks will be taken to have name type(task).config.task .
+    :param limit: int, optional
+        Limit the number of examples per task (only use this for testing)
+    :param bootstrap_iters:
+        Number of iterations for bootstrap statistics, used when calculating stderr. Set to 0 for skipping all stderr calculations.
+    :param write_out: bool
+        If True, write out an example document and model input for checking task integrity
+    :param log_samples: bool
+        If True, write out all model outputs and documents for per-sample measurement and post-hoc analysis
+    :param system_instruction: str
+        System instruction to be applied to the prompt
+    :param apply_chat_template: bool
+        If True, apply chat template to the prompt
+    :param fewshot_as_multiturn: bool
+        Whether to provide the fewshot examples as a multiturn conversation or a single user turn.
+    :return
+        Dictionary of results
+    """
+
+    eval_logger.setLevel(getattr(logging, f"{verbosity}"))
+
+    # tracks all Instances/requests a model must generate output on.
+    requests = defaultdict(list)
+    # stores the amount to pad out reqs per req. type so that
+    # number of fwd passes per distributed rank is equal
+    padding_requests = defaultdict(int)
+
+    # get lists of group hierarchy and each type of request
+    task_hierarchy, eval_tasks = get_task_list(task_dict)
+    if not log_samples:
+        if not all(
+            "bypass" not in getattr(task_output.task, "_metric_fn_list", {}).keys()
+            for task_output in eval_tasks
+        ):
+            raise ValueError("log_samples must be True for 'bypass' metric-only tasks")
+
+    # hash the retrieval results first
+    if retrieval_args["retrieval_file"]:
+        logging.info(
+            f"Hashing the retrieval documents once for {len(eval_tasks)} tasks"
+        )
+        hashed_retrieval_results = hash_retrieval_results(
+            retrieval_args["retrieval_file"], retrieval_args["concat_k"], None
+        )
+
+    for task_output in eval_tasks:
+        task: Task = task_output.task
+        limit = get_sample_size(task, limit)
+        task.build_all_requests(
+            limit=limit,
+            rank=lm.rank,
+            world_size=lm.world_size,
+            cache_requests=cache_requests,
+            rewrite_requests_cache=rewrite_requests_cache,
+            system_instruction=system_instruction,
+            apply_chat_template=apply_chat_template,
+            fewshot_as_multiturn=fewshot_as_multiturn,
+            lm=lm,
+        )
+        eval_logger.debug(
+            f"Task: {task_output.task_name}; number of requests on this rank: {len(task.instances)}"
+        )
+        if write_out:
+            print_writeout(task)
+        # aggregate Instances by LM method requested to get output.
+        for instance in task.instances:
+            reqtype = instance.request_type
+            requests[reqtype].append(instance)
+
+        if lm.world_size > 1:
+            instances_rnk = torch.tensor(len(task._instances), device=lm.device)
+            gathered_item = (
+                lm.accelerator.gather(instances_rnk).cpu().detach().numpy().tolist()
+            )
+            # "multiple_choice" task types dispatch (several) "loglikelihood" request types
+            reqtype = (
+                "loglikelihood"
+                if task.OUTPUT_TYPE == "multiple_choice"
+                else task.OUTPUT_TYPE
+            )
+            # compute number of pseudo-batches to pad with (FSDP/DDP require even batches among ranks)
+            numpad = max(gathered_item) - gathered_item[lm.rank]
+            # todo: may not account for padding in cases like SquadV2 which has multiple req types
+            padding_requests[reqtype] += numpad
+
+        # save inputs for retrieval
+        output_dir = retrieval_args["inputs_save_dir"]
+        os.makedirs(output_dir, exist_ok=True)
+        save_file = os.path.join(output_dir, f"{task_output.task_name}.jsonl")
+        eval_logger.info(
+            f"Saving inputs for retrieval\n\tTask: {task_output.task_name}\n\tPath {save_file}."
+        )
+        if not os.path.exists(save_file) or retrieval_args["overwrite_saved_inputs"]:
+            with open(save_file, "w") as fout:
+                for instance in task.instances:
+                    prompt_end = instance.arguments[0]
+                    fout.write(
+                        json.dumps(
+                            {"query": extract_question_from_fewshot_prompt(prompt_end)}
+                        )
+                        + "\n"
+                    )
+
+        # save answers for analysis
+        if retrieval_args["answer_save_dir"]:
+            answer_save_dir = retrieval_args["answer_save_dir"]
+            os.makedirs(answer_save_dir, exist_ok=True)
+            save_file = os.path.join(answer_save_dir, f"{task_output.task_name}.jsonl")
+            eval_logger.info(
+                f"Saving inputs and answers for retrieval\n\tTask: {task_output.task_name}\n\tPath {save_file}."
+            )
+            if (
+                not os.path.exists(save_file)
+                or retrieval_args["overwrite_saved_inputs"]
+            ):
+                with open(save_file, "w") as fout:
+                    for instance in task.instances:
+                        prompt_end = instance.arguments[0]
+                        if instance.request_type == "loglikelihood":
+                            answer = extract_answer_from_loglikelihood_task(
+                                instance.arguments[0], instance.arguments[1]
+                            )
+                        else:
+                            if "answer" in instance.doc:
+                                answer = instance.doc["answer"]
+                            elif "answers" in instance.doc:
+                                answer = instance.doc["answers"]
+                            else:
+                                raise AttributeError
+                        fout.write(
+                            json.dumps({"query": prompt_end, "answer": answer}) + "\n"
+                        )
+
+        # skip evaluation is save_inputs_only is True
+        if retrieval_args["save_inputs_only"]:
+            continue
+
+        # prepend retrieved documents if any
+        logging.info(f"Retrieval arguments: {retrieval_args}")
+
+        if retrieval_args["retrieval_file"] or retrieval_args["retrieval_dir"]:
+            if retrieval_args["retrieval_dir"]:
+                subtask_retrieval_file = f"{retrieval_args['retrieval_dir']}/{task_output.task_name}_retrieved_results.jsonl"
+                assert os.path.exists(subtask_retrieval_file), (
+                    f"retrieval path does not exist: {subtask_retrieval_file}"
+                )
+                hashed_retrieval_results = hash_retrieval_results(
+                    subtask_retrieval_file, retrieval_args["concat_k"], task
+                )
+            # assert len(task.instances) == len(hashed_retrieval_results), f'length mismatch between task data ({len(task.instances)}) and retrieval data ({len(hashed_retrieval_results)})'
+
+            for i, instance in enumerate(task.instances):
+                prompt_end = instance.arguments[0]
+                query = extract_question_from_fewshot_prompt(prompt_end)
+                if query in hashed_retrieval_results:
+                    prompt_retrieval = hashed_retrieval_results[query]
+                else:
+                    import sys
+
+                    if sys.stdin.isatty():
+                        print(f"Query not found in", task)
+                        continue
+                    else:
+                        raise RuntimeError
+                    # prompt_retrieval = hashed_retrieval_results[task._config.description + query]
+
+                prompt = prompt_retrieval + prompt_end
+                if retrieval_args["additional_system_prompt"]:
+                    prompt = (
+                        prompt_retrieval
+                        + "\n\n"
+                        + retrieval_args["additional_system_prompt"]
+                        + prompt
+                    )
+                if i == 0:
+                    print(f"Sample prompt:\n{prompt}")
+                task.instances[i].arguments = (prompt, *instance.arguments[1:])
+
+        elif retrieval_args["additional_system_prompt"]:
+            for i, instance in enumerate(task.instances):
+                prompt = (
+                    retrieval_args["additional_system_prompt"] + instance.arguments[0]
+                )
+                task.instances[i].arguments = (prompt, *instance.arguments[1:])
+
+        if lm.world_size > 1:
+            instances_rnk = torch.tensor(len(task._instances), device=lm.device)
+            gathered_item = (
+                lm.accelerator.gather(instances_rnk).cpu().detach().numpy().tolist()
+            )
+            # "multiple_choice" task types dispatch (several) "loglikelihood" request types
+            reqtype = (
+                "loglikelihood"
+                if task.OUTPUT_TYPE == "multiple_choice"
+                else task.OUTPUT_TYPE
+            )
+            # compute number of pseudo-batches to pad with (FSDP/DDP require even batches among ranks)
+            numpad = max(gathered_item) - gathered_item[lm.rank]
+            # todo: may not account for padding in cases like SquadV2 which has multiple req types
+            padding_requests[reqtype] += numpad
+
+    # Skip evaluation is save_inputs_only is True
+    if retrieval_args["save_inputs_only"]:
+        logging.info("Skipping evaluation because save_inputs_only is set to True...")
+        return None
+
+    ### Run LM on inputs, get all outputs ###
+    # execute each type of request
+    for reqtype, reqs in requests.items():
+        eval_logger.info(f"Running {reqtype} requests")
+        # create `K` copies of each request `req` based off `K = req.repeats`
+        cloned_reqs = []
+        for req in reqs:
+            cloned_reqs.extend([req] * req.repeats)
+
+        if (lm.world_size > 1) and (padding_requests[reqtype] > 0):
+            for _ in range(padding_requests[reqtype]):
+                cloned_reqs.extend([req] * req.repeats)
+
+        # run requests through model
+        ## real gen here!!!
+        resps = getattr(lm, reqtype)(cloned_reqs)
+
+        # put responses from model into a list of length K for each request.
+        for x, req in zip(resps, cloned_reqs):
+            req.resps.append(x)
+
+        with open("lm_eval_record.jsonl", "w") as f:
+            for req, x in zip(cloned_reqs, resps):
+                f.write(
+                    json.dumps(
+                        {
+                            "prompt": req.arguments[0],
+                            "response": x,
+                        }
+                    )
+                    + "\n"
+                )
+
+        if lm.world_size > 1:
+            lm.accelerator.wait_for_everyone()
+
+    RANK = lm.rank
+    WORLD_SIZE = lm.world_size
+    ### Postprocess outputs ###
+    # TODO: del model here, maybe (idea: allow user to specify device of e.g. reward model separately)
+    for task_output in eval_tasks:
+        task = task_output.task
+        task.apply_filters()
+
+        ### Collect values of metrics on all datapoints ###
+        # # unpack results and sort back in order and return control to Task
+        # TODO: make it possible to use a different metric per filter
+        # Pre-process task.instances to group by doc_id
+        instances_by_doc_id = defaultdict(list)
+        for instance in task.instances:
+            instances_by_doc_id[instance.doc_id].append(instance)
+        # Sort instances within each group
+        for instances in instances_by_doc_id.values():
+            instances.sort(key=lambda x: x.idx)
+        # iterate over different filters used
+        for filter_key in task.instances[0].filtered_resps.keys():
+            doc_iterator = task.doc_iterator(
+                rank=RANK, limit=limit, world_size=WORLD_SIZE
+            )
+            for doc_id, doc in doc_iterator:
+                requests = instances_by_doc_id[doc_id]
+                metrics = task.process_results(
+                    doc, [req.filtered_resps[filter_key] for req in requests]
+                )
+                if log_samples:
+                    target = task.doc_to_target(doc)
+                    example = {
+                        "doc_id": doc_id,
+                        "doc": doc,
+                        "target": target,
+                        "arguments": [req.args for req in requests],
+                        "resps": [req.resps for req in requests],
+                        "filtered_resps": [
+                            req.filtered_resps[filter_key] for req in requests
+                        ],
+                        "doc_hash": hash_string(
+                            json.dumps(
+                                requests[0].doc,
+                                indent=2,
+                                default=handle_non_serializable,
+                                ensure_ascii=False,
+                            )
+                        ),
+                        "prompt_hash": hash_string(requests[0].arguments[0]),
+                        "target_hash": hash_string(str(target)),
+                    }
+                    example.update(metrics)
+                    task_output.logged_samples.append(example)
+                for metric, value in metrics.items():
+                    task_output.sample_metrics[(metric, filter_key)].append(value)
+
+    if WORLD_SIZE > 1:
+        # if multigpu, then gather data across all ranks to rank 0
+        # first gather logged samples across all ranks
+        for task_output in eval_tasks:
+            if log_samples:
+                # for task_name, task_samples in list(samples.items()):
+                full_samples = [None] * WORLD_SIZE if RANK == 0 else None
+                torch.distributed.gather_object(
+                    obj=task_output.logged_samples,
+                    object_gather_list=full_samples,
+                    dst=0,
+                )
+
+                if RANK == 0:
+                    task_output.logged_samples = list(
+                        itertools.chain.from_iterable(full_samples)
+                    )
+
+            # then collect metrics across all ranks
+            for metrics in task_output.sample_metrics:
+                metric_list = [None] * WORLD_SIZE if RANK == 0 else None
+                torch.distributed.gather_object(
+                    obj=task_output.sample_metrics[metrics],
+                    object_gather_list=metric_list,
+                    dst=0,
+                )
+                if RANK == 0:
+                    task_output.sample_metrics[metrics] = list(
+                        itertools.chain.from_iterable(metric_list)
+                    )
+
+    if RANK == 0:
+        ### Aggregate results over all datapoints ###
+        # aggregate results ; run bootstrap CIs
+        for task_output in eval_tasks:
+            task_output.calculate_aggregate_metric(bootstrap_iters=bootstrap_iters)
+        (
+            results,
+            samples,
+            configs,
+            versions,
+            num_fewshot,
+            higher_is_better,
+        ) = consolidate_results(eval_tasks)
+
+        ### Calculate group metrics ###
+        if bool(results):
+            for group, task_list in reversed(task_hierarchy.items()):
+                if len(task_list) == 0:
+                    # task_hierarchy entries are either
+                    # `group_name: [subtask1, subtask2, ...]`
+                    # or `task_name: []`.
+                    # we only want to operate on groups here.
+                    continue
+
+                # collect all higher_is_better values for metrics
+                # in the group's subtasks.
+                # TODO: clean this up ; unify with the below metric_list loop?
+                _higher_is_better = {}
+                for task in task_list:
+                    for m, h in higher_is_better[task].items():
+                        if m not in _higher_is_better.keys():
+                            _higher_is_better[m] = h
+                    if (
+                        m in _higher_is_better
+                        and _higher_is_better[m] is not None
+                        and _higher_is_better[m] != h
+                    ):
+                        eval_logger.warning(
+                            f"Higher_is_better values for metric {m} in group {group} are not consistent. Defaulting to None."
+                        )
+                        _higher_is_better[m] = None
+                higher_is_better[group] = _higher_is_better
+
+                # collect all metric keys used by a subtask in the group.
+                metric_list = list(
+                    {
+                        key
+                        for task in task_list
+                        for key in results[task].keys()
+                        if "_stderr" not in key and key not in ["alias", "samples"]
+                    }
+                )
+                for metric in metric_list:
+                    stderr = "_stderr,".join(metric.split(","))
+
+                    # gather metrics, sizes, and stderrs from subtasks
+                    metrics = [
+                        results[task][metric]
+                        for task in task_list
+                        if metric in results[task]
+                    ]  # TODO: copy?
+                    stderrs = [
+                        results[task][stderr]
+                        for task in task_list
+                        if stderr in results[task]
+                    ]
+                    sizes = [
+                        results[task]["samples"]
+                        for task in task_list
+                        if metric in results[task]
+                    ]
+
+                    # compute group's pooled metric and stderr
+                    results[group][metric] = (
+                        lm_eval.api.metrics.aggregate_subtask_metrics(metrics, sizes)
+                    )
+                    # TODO: calculate grouped metric using aggregation fn
+                    if "N/A" in stderrs:
+                        results[group][stderr] = "N/A"
+                    else:
+                        results[group][stderr] = (
+                            lm_eval.api.metrics.pooled_sample_stderr(stderrs, sizes)
+                        )
+                        # TODO: allow GroupConfigs to choose which variance formula is used, for back-compatibility
+                        # To use the old (likely incorrect) variance formula, comment out the above and uncomment this line:
+                        # results[group][stderr] = lm_eval.api.metrics.combined_sample_stderr(stderrs, sizes, metrics=metrics)
+
+                    results[group]["samples"] = sum(sizes)
+
+        results_agg = defaultdict(dict)
+        groups_agg = defaultdict(dict)
+        all_tasks_list = list(task_hierarchy.keys())
+        while True:
+            add_tasks_list = list(k for k in results_agg.keys())
+            left_tasks_list = sorted(list(set(all_tasks_list) - set(add_tasks_list)))
+            if len(left_tasks_list) == 0:
+                break
+
+            _task_hierarchy = {
+                k: v for k, v in task_hierarchy.items() if k in left_tasks_list
+            }
+            _results_agg, _groups_agg = prepare_print_tasks(_task_hierarchy, results)
+
+            results_agg = {**results_agg, **_results_agg}
+            groups_agg = {**groups_agg, **_groups_agg}
+
+        for group_name, task_list in task_hierarchy.items():
+            if task_list:
+                num_fewshot[group_name] = num_fewshot[
+                    task_list[0]
+                ]  # TODO: validate this
+
+        results_dict = {
+            "results": dict(results_agg.items()),
+            **({"groups": dict(groups_agg.items())} if bool(groups_agg) else {}),
+            "group_subtasks": dict(reversed(task_hierarchy.items())),
+            "configs": dict(sorted(configs.items())),
+            "versions": dict(sorted(versions.items())),
+            "n-shot": dict(sorted(num_fewshot.items())),
+            "n-doc": {
+                k: retrieval_args["concat_k"]
+                for k in dict(sorted(num_fewshot.items())).keys()
+            },
+            "higher_is_better": dict(sorted(higher_is_better.items())),
+            "n-samples": {
+                task_output.task_name: {
+                    "original": len(task_output.task.eval_docs),
+                    "effective": min(
+                        limit if limit else len(task_output.task.eval_docs),
+                        len(task_output.task.eval_docs),
+                    ),
+                }
+                for task_output in eval_tasks
+            },
+        }
+        if log_samples:
+            results_dict["samples"] = dict(samples)
+
+        return results_dict
+
+    else:
+        return None
+
+
+def request_caching_arg_to_dict(cache_requests: str) -> dict:
+    request_caching_args = {
+        "cache_requests": cache_requests in {"true", "refresh"},
+        "rewrite_requests_cache": cache_requests == "refresh",
+        "delete_requests_cache": cache_requests == "delete",
+    }
+
+    return request_caching_args
+
+
+def load_jsonlines(file):
+    with jsonlines.open(file, "r") as jsonl_f:
+        lst = [obj for obj in jsonl_f]
+    return lst
+
+
+def extract_question_from_fewshot_prompt(prompt):
+    """
+    Extract the 0-shot question from fewshot example.
+    We split by '\n\n' because it is the default fewshot delimiter.
+    Please make sure all future tasks use '\n\n' as the fewshot delimiter.
+    """
+    return prompt.split("\n\n")[-1]
+
+
+def hash_retrieval_results(
+    test_jsonl_with_retrieval: str = "",
+    concat_k: int = 1,
+    task=None,
+):
+    hashed_results = {}
+    qa_data = load_jsonlines(test_jsonl_with_retrieval)
+    for data in qa_data:
+        assert "question" or "raw_query" or "query" in data
+        if "raw_query" in data or "query" in data:
+            raw_query = data["raw_query"] if "raw_query" in data else data["query"]
+            # hotfix: remove system prompt in the original query based on '\n\n' to align the extracted query in the few-shot setting.
+            raw_query = extract_question_from_fewshot_prompt(raw_query)
+        else:
+            query = data["question"]
+            raw_query = task._config.description + task.doc_to_text({"question": query})
+
+        k_ctx = ""
+        for i in range(concat_k):
+            try:
+                # todo: unify the key name
+                k_ctx = (
+                    data["ctxs"][i]["retrieval text"] + k_ctx
+                    if "retrieval text" in data["ctxs"][i].keys()
+                    else data["ctxs"][i]["text"] + k_ctx
+                )
+            except:
+                print(f"No enough documents to prepend! Added {i} documents only.")
+
+        try:
+            assert (
+                raw_query not in hashed_results.keys()
+                or k_ctx == hashed_results[raw_query]
+            )
+        except:
+            print(
+                f"\n\nMismatched:\nQuery:{raw_query}\nHashed Doc:{hashed_results[raw_query]}\nNew Doc:{k_ctx}"
+            )
+        # assert raw_query not in hashed_results, f'query already in hashed results: {raw_query}'
+        hashed_results[raw_query] = k_ctx
+    return hashed_results
+
+
+def extract_answer_from_loglikelihood_task(input_text, answer_label):
+    # Split the input into question and answer parts
+    parts = input_text.split("Answer:")
+    question_part = parts[0]
+
+    # Normalize the answer label to remove extra spaces
+    answer_label = answer_label.strip()
+
+    # Split the question part further to isolate answer choices
+    answer_choices = question_part.split("\n")
+    answer_choices = [choice.strip() for choice in answer_choices if choice.strip()]
+
+    # Find the answer choice that matches the answer label
+    for choice in answer_choices:
+        if choice.startswith(answer_label):
+            return choice
+
+    return "Answer not found"

rag-evaluation-harness/lm_eval/tasks/anli/anli_r1.yaml

@@ -0,0 +1,26 @@
+group:
+  - anli
+task: anli_r1
+dataset_path: anli
+dataset_name: null
+output_type: multiple_choice
+training_split: train_r1
+validation_split: dev_r1
+test_split: test_r1
+doc_to_text: "{{premise}}\nQuestion: {{hypothesis}} True, False, or Neither?\nAnswer:"
+# True = entailment
+# False = contradiction
+# Neither = neutral
+doc_to_target: "{{['True', 'Neither', 'False'][label]}}"
+doc_to_choice:
+  - "True"
+  - "Neither"
+  - "False"
+should_decontaminate: true
+doc_to_decontamination_query: premise
+metric_list:
+  - metric: acc
+    aggregation: mean
+    higher_is_better: true
+metadata:
+  version: 1.0

rag-evaluation-harness/lm_eval/tasks/anli/anli_r2.yaml

@@ -0,0 +1,5 @@
+include: anli_r1.yaml
+task: anli_r2
+training_split: train_r2
+validation_split: dev_r2
+test_split: test_r2

rag-evaluation-harness/lm_eval/tasks/csatqa/csatqa_li.yaml

@@ -0,0 +1,3 @@
+"dataset_name": "LI"
+"include": "_default_csatqa_yaml"
+"task": "csatqa_li"

rag-evaluation-harness/lm_eval/tasks/csatqa/utils.py

@@ -0,0 +1,20 @@
+import datasets
+
+
+def process_docs(dataset: datasets.Dataset) -> datasets.Dataset:
+    def _process_doc(doc):
+        instruction = f"""다음을 읽고 정답으로 알맞은 것을 고르시요.
+### Context: {doc["context"]}
+### Question: {doc["question"]}
+### Options:
+(1) {doc["option#1"]}\n(2) {doc["option#2"]}\n(3) {doc["option#3"]}\n(4) {doc["option#4"]}\n(5) {doc["option#5"]}
+### Answer: 주어진 문제의 정답은"""
+
+        out_doc = {
+            "question": instruction,
+            "choices": ["(1)", "(2)", "(3)", "(4)", "(5)"],
+            "gold": int(doc["gold"]) - 1,
+        }
+        return out_doc
+
+    return dataset.map(_process_doc)

rag-evaluation-harness/lm_eval/tasks/french_bench/french_bench_multifquad.yaml

@@ -0,0 +1,34 @@
+include: "_default_template_yaml"
+group:
+  - french_bench
+  - french_bench_gen
+description: "D'après l'information dans le contexte donné, donne la réponse à la question en citant quelques extraits du contexte."
+task: french_bench_multifquad
+dataset_path: manu/multifquad_test
+output_type: generate_until
+validation_split: valid
+test_split: test
+fewshot_split: valid
+doc_to_text: "\nContexte: {{context}}\n\nQuestion: {{question}}\n\nRéponse:"
+doc_to_target: "{{', '.join(answers.text)}}"
+target_delimiter: " "
+should_decontaminate: true
+doc_to_decontamination_query: context
+generation_kwargs:
+  until:
+    - "\n"
+# filter_list:
+#   - name: remove_whitespace
+#     filter:
+#       - function: remove_whitespace
+#       - function: take_first
+metric_list:
+  - metric: !function utils.exact
+    aggregation: mean
+    higher_is_better: true
+  - metric: !function utils.f1
+    aggregation: mean
+    higher_is_better: true
+  - metric: !function utils.rouge1
+    higher_is_better: true
+    aggregation:  !function utils.rouge1_agg

rag-evaluation-harness/lm_eval/tasks/xnli/xnli_ar.yaml

@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: ar
+doc_to_choice: '{{[premise+", صحيح? نعم, "+hypothesis,premise+", صحيح? لذا, "+hypothesis,premise+",
+  صحيح? رقم, "+hypothesis]}}'
+doc_to_text: ''
+include: xnli_common_yaml
+task: xnli_ar

rag-evaluation-harness/lm_eval/tasks/xnli/xnli_bg.yaml

@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: bg
+doc_to_choice: '{{[premise+", правилно? да, "+hypothesis,premise+", правилно? така,
+  "+hypothesis,premise+", правилно? не, "+hypothesis]}}'
+doc_to_text: ''
+include: xnli_common_yaml
+task: xnli_bg

rag-evaluation-harness/lm_eval/tasks/xnli/xnli_es.yaml

@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: es
+doc_to_choice: '{{[premise+", correcto? Sí, "+hypothesis,premise+", correcto? Asi
+  que, "+hypothesis,premise+", correcto? No, "+hypothesis]}}'
+doc_to_text: ''
+include: xnli_common_yaml
+task: xnli_es

rag-evaluation-harness/lm_eval/tasks/xnli/xnli_tr.yaml

@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: tr
+doc_to_choice: '{{[premise+", doğru? Evet, "+hypothesis,premise+", doğru? Böylece,
+  "+hypothesis,premise+", doğru? Hayır, "+hypothesis]}}'
+doc_to_text: ''
+include: xnli_common_yaml
+task: xnli_tr

rag-evaluation-harness/lm_eval/tasks/xnli/xnli_ur.yaml

@@ -0,0 +1,7 @@
+# Generated by utils.py
+dataset_name: ur
+doc_to_choice: '{{[premise+", صحیح? جی ہاں, "+hypothesis,premise+", صحیح? اس لئے,
+  "+hypothesis,premise+", صحیح? نہیں, "+hypothesis]}}'
+doc_to_text: ''
+include: xnli_common_yaml
+task: xnli_ur

rag-evaluation-harness/mypy.ini

@@ -0,0 +1,29 @@
+[mypy]
+python_version = 3.8
+show_traceback = True
+check_untyped_defs = True
+no_implicit_reexport = True
+warn_unreachable = True
+warn_unused_configs = True
+warn_unused_ignores = True
+warn_redundant_casts = True
+
+# We ignore errors everywhere to gradually add type annotations
+
+[mypy-lm_eval.*]
+ignore_errors = True
+
+[mypy-lm_eval.api.*]
+ignore_errors = True
+
+[mypy-lm_eval.prompts.*]
+ignore_errors = True
+
+[mypy-lm_eval.models.*]
+ignore_errors = True
+
+[mypy-scripts.*]
+ignore_errors = True
+
+[mypy-main]
+ignore_errors = True

rag-evaluation-harness/pyproject.toml

@@ -0,0 +1,109 @@
+[build-system]
+requires = ["setuptools>=40.8.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lm_eval"
+version = "0.4.2"
+authors = [
+    {name="EleutherAI", email="[email protected]"}
+]
+description = "A framework for evaluating language models"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.8"
+license = { "text" = "MIT" }
+dependencies = [
+    "accelerate>=0.26.0",
+    "evaluate",
+    "datasets>=2.16.0",
+    "evaluate>=0.4.0",
+    "jsonlines",
+    "numexpr",
+    "peft>=0.2.0",
+    "pybind11>=2.6.2",
+    "pytablewriter",
+    "rouge-score>=0.0.4",
+    "sacrebleu>=1.5.0",
+    "scikit-learn>=0.24.1",
+    "sqlitedict",
+    "torch>=1.8",
+    "tqdm-multiprocess",
+    "transformers>=4.1",
+    "zstandard",
+    "dill",
+    "word2number",
+    "more_itertools",
+]
+
+[tool.setuptools.packages.find]
+include = ["lm_eval*"]
+
+# required to include yaml files in pip installation
+[tool.setuptools.package-data]
+lm_eval = ["**/*.yaml", "tasks/**/*"]
+
+[project.scripts]
+lm-eval = "lm_eval.__main__:cli_evaluate"
+lm_eval = "lm_eval.__main__:cli_evaluate"
+
+[project.urls]
+Homepage = "https://github.com/EleutherAI/lm-evaluation-harness"
+Repository = "https://github.com/EleutherAI/lm-evaluation-harness"
+
+[project.optional-dependencies]
+anthropic = ["anthropic"]
+dev = ["pytest", "pytest-cov", "pytest-xdist", "pre-commit", "mypy"]
+deepsparse = ["deepsparse-nightly[llm]>=1.8.0.20240404"]
+gptq = ["auto-gptq[triton]>=0.6.0"]
+hf_transfer = ["hf_transfer"]
+ifeval = ["langdetect", "immutabledict"]
+neuronx = ["optimum[neuronx]"]
+mamba = ["mamba_ssm", "causal-conv1d==1.0.2"]
+math = ["sympy>=1.12", "antlr4-python3-runtime==4.11"]
+multilingual = ["nagisa>=0.2.7", "jieba>=0.42.1", "pycountry"]
+openai = ["openai==1.3.9", "tiktoken"]
+optimum = ["optimum[openvino]"]
+promptsource = ["promptsource>=0.2.3"]
+sentencepiece = ["sentencepiece>=0.1.98"]
+sparseml = ["sparseml-nightly[llm]>=1.8.0.20240404"]
+testing = ["pytest", "pytest-cov", "pytest-xdist"]
+vllm = ["vllm>=0.4.2"]
+zeno = ["pandas", "zeno-client"]
+wandb = ["wandb>=0.16.3", "pandas", "numpy"]
+unitxt = ["unitxt"]
+all = [
+    "lm_eval[anthropic]",
+    "lm_eval[dev]",
+    "lm_eval[deepsparse]",
+    "lm_eval[gptq]",
+    "lm_eval[hf_transfer]",
+    "lm_eval[ifeval]",
+    "lm_eval[mamba]",
+    "lm_eval[math]",
+    "lm_eval[multilingual]",
+    "lm_eval[openai]",
+    "lm_eval[promptsource]",
+    "lm_eval[sentencepiece]",
+    "lm_eval[sparseml]",
+    "lm_eval[testing]",
+    "lm_eval[vllm]",
+    "lm_eval[zeno]",
+    "lm_eval[wandb]",
+    "lm_eval[unitxt]"
+]
+
+[tool.ruff.lint]
+extend-select = ["I"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["lm_eval"]
+
+[tool.ruff.lint.extend-per-file-ignores]
+"__init__.py" = ["F401","F402","F403"]

rag-evaluation-harness/setup.py

@@ -0,0 +1,5 @@
+import setuptools
+
+
+# This is to make sure that the package supports editable installs
+setuptools.setup()

recall_acc_results/_a/.gitignore

@@ -0,0 +1 @@
+*

recall_acc_results/_a/_b/recall_acc_results_Llama-3.2-1B-Instruct_dpr_nlist8192.json

@@ -0,0 +1,94 @@
+{
+  "nprobe_values": [
+    0,
+    4,
+    8,
+    16,
+    32,
+    48,
+    64,
+    96,
+    128,
+    192,
+    256,
+    384,
+    512,
+    768,
+    1024
+  ],
+  "recalls": [
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0,
+    0.0
+  ],
+  "f1_scores": [
+    0.21769386490478573,
+    0.25655656373673,
+    0.26277393056489584,
+    0.2666075931737789,
+    0.2689541813918884,
+    0.27178377562037465,
+    0.2708846495803003,
+    0.27046785538697377,
+    0.27381786243096806,
+    0.2747022079299461,
+    0.27639020598913533,
+    0.2767040841700495,
+    0.2769265901958796,
+    0.2773986181520763,
+    0.27761378156668565
+  ],
+  "exact_match_scores": [
+    0.1556786703601108,
+    0.18476454293628808,
+    0.19113573407202217,
+    0.1930747922437673,
+    0.19473684210526315,
+    0.1961218836565097,
+    0.19529085872576177,
+    0.19529085872576177,
+    0.19806094182825484,
+    0.19889196675900278,
+    0.20055401662049863,
+    0.2002770083102493,
+    0.20055401662049863,
+    0.2002770083102493,
+    0.20055401662049863
+  ],
+  "parameters": {
+    "nlist": 8192,
+    "domain": "dpr",
+    "task": "nq",
+    "model": "meta-llama/Llama-3.2-1B-Instruct",
+    "engine": "vllm"
+  },
+  "search_times": [
+    0.0,
+    1.8302443027496338,
+    1.9399559497833252,
+    2.2174618244171143,
+    2.652435779571533,
+    3.1330487728118896,
+    3.292360782623291,
+    3.9053852558135986,
+    4.548843622207642,
+    6.490998268127441,
+    7.144783973693848,
+    9.334285020828247,
+    12.308050870895386,
+    16.292457580566406,
+    21.412838220596313
+  ]
+}

recall_acc_results/_a/real/recall_acc_results_Llama-3.1-8B-Instruct_rpj_wiki_nlist8192.json

@@ -0,0 +1,88 @@
+{
+  "nprobe_values": [
+    0,
+    4,
+    8,
+    16,
+    32,
+    48,
+    64,
+    96,
+    128,
+    192,
+    256,
+    2048,
+    4096
+  ],
+  "recalls": [
+    1.0,
+    0.0,
+    0.5670360110803324,
+    0.684118190212373,
+    0.7736842105263158,
+    0.851892890120037,
+    0.881809787626962,
+    0.9027700831024931,
+    0.9239150507848568,
+    0.9374884579870728,
+    0.951708217913204,
+    0.9598337950138505,
+    0.9867959372114496,
+    0.9901200369344413
+  ],
+  "f1_scores": [
+    0.4786705586086418,
+    0.40470335934772955,
+    0.43794170876894184,
+    0.44503321604744245,
+    0.45646277758469844,
+    0.4631313161455936,
+    0.4664465840616437,
+    0.47055412199309693,
+    0.4725633654427836,
+    0.47337743829635387,
+    0.4730561125835718,
+    0.47221922222452073,
+    0.47681121143073507,
+    0.4770792813443116
+  ],
+  "exact_match_scores": [
+    0.36426592797783935,
+    0.3060941828254848,
+    0.3332409972299169,
+    0.3376731301939058,
+    0.34542936288088644,
+    0.3493074792243767,
+    0.35290858725761776,
+    0.35678670360110804,
+    0.35789473684210527,
+    0.3595567867036011,
+    0.360387811634349,
+    0.3592797783933518,
+    0.36398891966759,
+    0.3631578947368421
+  ],
+  "parameters": {
+    "nlist": 8192,
+    "domain": "rpj_wiki",
+    "task": "nq",
+    "model": "meta-llama/Llama-3.1-8B-Instruct",
+    "engine": "sglang"
+  },
+  "search_times": [
+    0.010169744491577148,
+    0.0,
+    0.16394424438476562,
+    0.21286225318908691,
+    0.3131523132324219,
+    0.7416322231292725,
+    1.0397512912750244,
+    1.2900450229644775,
+    1.7838373184204102,
+    2.216383934020996,
+    1.9432766437530518,
+    4.186463356018066,
+    27.881035566329956,
+    46.320849657058716
+  ]
+}

recall_acc_results/_a/real/recall_acc_results_Llama-3.2-1B-Instruct_dpr_nlist8192.json

@@ -0,0 +1,98 @@
+{
+  "nprobe_values": [
+    0,
+    4,
+    8,
+    16,
+    32,
+    48,
+    64,
+    96,
+    128,
+    192,
+    256,
+    384,
+    512,
+    768,
+    1024
+  ],
+  "recalls": [
+    1.0,
+    0.0,
+    0.6291782086795936,
+    0.7152354570637119,
+    0.7860572483841182,
+    0.8456140350877193,
+    0.8770083102493075,
+    0.894921514312096,
+    0.9179132040627885,
+    0.9318559556786704,
+    0.9501385041551247,
+    0.960387811634349,
+    0.9738688827331488,
+    0.979870729455217,
+    0.9875346260387812,
+    0.9914127423822715
+  ],
+  "f1_scores": [
+    0.27881974601047416,
+    0.21561311967926722,
+    0.2567006766234114,
+    0.2630800747764499,
+    0.2685084250046297,
+    0.27092383361616285,
+    0.27419806877566505,
+    0.2730051004635831,
+    0.27191109831575466,
+    0.2750768353845801,
+    0.27610190757308717,
+    0.2780203696805667,
+    0.27792227294812094,
+    0.2781271355310397,
+    0.2786307045194937,
+    0.2791007792277955
+  ],
+  "exact_match_scores": [
+    0.20193905817174515,
+    0.15401662049861495,
+    0.1853185595567867,
+    0.19141274238227146,
+    0.19501385041551247,
+    0.19667590027700832,
+    0.19833795013850417,
+    0.19722991689750694,
+    0.19667590027700832,
+    0.19916897506925207,
+    0.2,
+    0.20166204986149586,
+    0.20166204986149586,
+    0.20166204986149586,
+    0.20138504155124654,
+    0.20193905817174515
+  ],
+  "parameters": {
+    "nlist": 8192,
+    "domain": "dpr",
+    "task": "nq",
+    "model": "meta-llama/Llama-3.2-1B-Instruct",
+    "engine": "sglang"
+  },
+  "search_times": [
+    0.2925705909729004,
+    0.0,
+    1.9018418788909912,
+    1.887054443359375,
+    2.3637545108795166,
+    2.95737361907959,
+    3.161799669265747,
+    3.739989757537842,
+    4.95138692855835,
+    6.247658729553223,
+    6.502671003341675,
+    7.629181861877441,
+    10.550214290618896,
+    13.077433586120605,
+    17.176400184631348,
+    21.692492246627808
+  ]
+}

recall_acc_results/_a/real/recall_acc_results_Llama-3.2-1B-Instruct_rpj_wiki_nlist8192.json

@@ -0,0 +1,39 @@
+{
+  "nprobe_values": [
+    384,
+    512,
+    768,
+    1024
+  ],
+  "recalls": [
+    0.9915974145891044,
+    0.9946445060018467,
+    0.9965835641735918,
+    0.9975069252077562
+  ],
+  "f1_scores": [
+    0.3697835728581248,
+    0.3701804713083109,
+    0.3699405513600644,
+    0.3694831723007625
+  ],
+  "exact_match_scores": [
+    0.2692520775623269,
+    0.2698060941828255,
+    0.2698060941828255,
+    0.2698060941828255
+  ],
+  "parameters": {
+    "nlist": 8192,
+    "domain": "rpj_wiki",
+    "task": "nq",
+    "model": "meta-llama/Llama-3.2-1B-Instruct",
+    "engine": "sglang"
+  },
+  "search_times": [
+    827.3021464347839,
+    2753.4918179512024,
+    934.9543120861053,
+    991.6539351940155
+  ]
+}

recall_acc_results/_a/valid/recall_acc_results_Llama-3.2-1B_dpr_nlist8192.json

@@ -0,0 +1,97 @@
+{
+  "nprobe_values": [
+    0,
+    4,
+    8,
+    16,
+    32,
+    48,
+    64,
+    96,
+    128,
+    192,
+    256,
+    384,
+    512,
+    768,
+    1024
+  ],
+  "recalls": [
+    1.0,
+    0.0,
+    0.6291782086795936,
+    0.7152354570637119,
+    0.7860572483841182,
+    0.8456140350877193,
+    0.8770083102493075,
+    0.894921514312096,
+    0.9179132040627885,
+    0.9318559556786704,
+    0.9501385041551247,
+    0.960387811634349,
+    0.9738688827331488,
+    0.979870729455217,
+    0.9875346260387812,
+    0.9914127423822715
+  ],
+  "f1_scores": [
+    0.2557521385990972,
+    0.1781030368195021,
+    0.2311241753690697,
+    0.23319314466009197,
+    0.23806248676137007,
+    0.24238545934267358,
+    0.24551399451683797,
+    0.2464275695961469,
+    0.24845445240371594,
+    0.2504595681524961,
+    0.2513924187737124,
+    0.25451953400729516,
+    0.2551967753562816,
+    0.25548462312214937,
+    0.25601382270551143,
+    0.256212682348643
+  ],
+  "exact_match_scores": [
+    0.18227146814404432,
+    0.12132963988919668,
+    0.16066481994459833,
+    0.16149584487534627,
+    0.1664819944598338,
+    0.1703601108033241,
+    0.17202216066481996,
+    0.17229916897506925,
+    0.1739612188365651,
+    0.17534626038781165,
+    0.17617728531855956,
+    0.17977839335180054,
+    0.1811634349030471,
+    0.1814404432132964,
+    0.1817174515235457,
+    0.1817174515235457
+  ],
+  "parameters": {
+    "nlist": 8192,
+    "domain": "dpr",
+    "task": "nq",
+    "model": "meta-llama/Llama-3.2-1B",
+    "engine": "sglang"
+  },
+  "search_times": [
+    0.0,
+    1.907364845275879,
+    1.9229207038879395,
+    7.183107614517212,
+    2.8659842014312744,
+    3.249828338623047,
+    3.6830973625183105,
+    4.328709602355957,
+    5.444960832595825,
+    6.922391653060913,
+    8.49331521987915,
+    11.494524240493774,
+    12.845796346664429,
+    18.03567910194397,
+    21.74203062057495
+  ]
+}