Build LongBench dataset from source JSONL files

.gitattributes

@@ -1,60 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,524 @@
+---
+license: apache-2.0
+pretty_name: "LongBench"
+language:
+- code
+- en
+- zh
+task_categories:
+- question-answering
+- summarization
+- text-classification
+- text-generation
+- code-generation
+task_ids:
+- extractive-qa
+- open-domain-qa
+- document-question-answering
+- summarization
+- text-classification
+- language-modeling
+tags:
+- longbench
+- long-context
+- benchmark
+- evaluation
+- multilingual
+- bilingual
+- question-answering
+- summarization
+- code
+- llm
+- large-language-models
+size_categories:
+- 1K<n<10K
+source_datasets:
+- original
+configs:
+- config_name: narrativeqa
+  data_files:
+    - split: test
+      path: data/narrativeqa/test-00000-of-00001.parquet
+- config_name: qasper
+  data_files:
+    - split: test
+      path: data/qasper/test-00000-of-00001.parquet
+- config_name: multifieldqa_en
+  data_files:
+    - split: test
+      path: data/multifieldqa_en/test-00000-of-00001.parquet
+- config_name: multifieldqa_zh
+  data_files:
+    - split: test
+      path: data/multifieldqa_zh/test-00000-of-00001.parquet
+- config_name: hotpotqa
+  data_files:
+    - split: test
+      path: data/hotpotqa/test-00000-of-00001.parquet
+- config_name: 2wikimqa
+  data_files:
+    - split: test
+      path: data/2wikimqa/test-00000-of-00001.parquet
+- config_name: musique
+  data_files:
+    - split: test
+      path: data/musique/test-00000-of-00001.parquet
+- config_name: dureader
+  data_files:
+    - split: test
+      path: data/dureader/test-00000-of-00001.parquet
+- config_name: gov_report
+  data_files:
+    - split: test
+      path: data/gov_report/test-00000-of-00001.parquet
+- config_name: qmsum
+  data_files:
+    - split: test
+      path: data/qmsum/test-00000-of-00001.parquet
+- config_name: multi_news
+  data_files:
+    - split: test
+      path: data/multi_news/test-00000-of-00001.parquet
+- config_name: vcsum
+  data_files:
+    - split: test
+      path: data/vcsum/test-00000-of-00001.parquet
+- config_name: trec
+  data_files:
+    - split: test
+      path: data/trec/test-00000-of-00001.parquet
+- config_name: triviaqa
+  data_files:
+    - split: test
+      path: data/triviaqa/test-00000-of-00001.parquet
+- config_name: samsum
+  data_files:
+    - split: test
+      path: data/samsum/test-00000-of-00001.parquet
+- config_name: lsht
+  data_files:
+    - split: test
+      path: data/lsht/test-00000-of-00001.parquet
+- config_name: passage_count
+  data_files:
+    - split: test
+      path: data/passage_count/test-00000-of-00001.parquet
+- config_name: passage_retrieval_en
+  data_files:
+    - split: test
+      path: data/passage_retrieval_en/test-00000-of-00001.parquet
+- config_name: passage_retrieval_zh
+  data_files:
+    - split: test
+      path: data/passage_retrieval_zh/test-00000-of-00001.parquet
+- config_name: lcc
+  data_files:
+    - split: test
+      path: data/lcc/test-00000-of-00001.parquet
+- config_name: repobench-p
+  data_files:
+    - split: test
+      path: data/repobench-p/test-00000-of-00001.parquet
+- config_name: qasper_e
+  data_files:
+    - split: test
+      path: data/qasper_e/test-00000-of-00001.parquet
+- config_name: multifieldqa_en_e
+  data_files:
+    - split: test
+      path: data/multifieldqa_en_e/test-00000-of-00001.parquet
+- config_name: hotpotqa_e
+  data_files:
+    - split: test
+      path: data/hotpotqa_e/test-00000-of-00001.parquet
+- config_name: 2wikimqa_e
+  data_files:
+    - split: test
+      path: data/2wikimqa_e/test-00000-of-00001.parquet
+- config_name: gov_report_e
+  data_files:
+    - split: test
+      path: data/gov_report_e/test-00000-of-00001.parquet
+- config_name: multi_news_e
+  data_files:
+    - split: test
+      path: data/multi_news_e/test-00000-of-00001.parquet
+- config_name: trec_e
+  data_files:
+    - split: test
+      path: data/trec_e/test-00000-of-00001.parquet
+- config_name: triviaqa_e
+  data_files:
+    - split: test
+      path: data/triviaqa_e/test-00000-of-00001.parquet
+- config_name: samsum_e
+  data_files:
+    - split: test
+      path: data/samsum_e/test-00000-of-00001.parquet
+- config_name: passage_count_e
+  data_files:
+    - split: test
+      path: data/passage_count_e/test-00000-of-00001.parquet
+- config_name: passage_retrieval_en_e
+  data_files:
+    - split: test
+      path: data/passage_retrieval_en_e/test-00000-of-00001.parquet
+- config_name: lcc_e
+  data_files:
+    - split: test
+      path: data/lcc_e/test-00000-of-00001.parquet
+- config_name: repobench-p_e
+  data_files:
+    - split: test
+      path: data/repobench-p_e/test-00000-of-00001.parquet
+---
+
+# LongBench
+
+## Dataset Summary
+
+LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.
+
+This Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.
+
+
+This repository keeps the LongBench records in their original task-level shape while publishing them as typed Parquet configs. The split is always `test`; the configuration name is the LongBench task name. That means the benchmark can be loaded with plain `load_dataset(...)` calls, without the legacy dataset script or a manual `data.zip` step.
+
+The `language` metadata above is intentionally limited to Hub-valid values. Row-level LongBench labels are preserved in the data and include natural languages (`en`, `zh`) plus code labels (`python`, `java`, `csharp`) for the completion tasks.
+
+This repackaging also adds token counts to every row: `input_tokens`, `context_tokens`, and `total_tokens`, computed with `cl100k_base`. LongBench is specifically about long-context behavior, so the added counts make it easier to filter by real prompt size, inspect outliers, and compare tasks without guessing from the original mixed `length` field.
+
+## Original Source and Attribution
+
+- Original project: [https://github.com/THUDM/LongBench](https://github.com/THUDM/LongBench)
+- Paper: [https://arxiv.org/abs/2308.14508](https://arxiv.org/abs/2308.14508)
+- Original authors: Yushi Bai, Xin Lv, Jiajie Zhang, Hongchang Lyu, Jiankai Tang, Zhidian Huang, Zhengxiao Du, Xiao Liu, Aohan Zeng, Lei Hou, Yuxiao Dong, Jie Tang, and Juanzi Li.
+- This repository: `GinkgoQ/LongBench`
+- Packaging contribution: typed Parquet configs, Hub-valid metadata, local build metadata, and per-row `cl100k_base` token counts.
+- Attribution note: the benchmark design and source records remain LongBench.
+
+## Dataset Structure
+
+Each LongBench task is exposed as a separate Hugging Face configuration. Every configuration has a single `test` split.
+
+### Schema
+
+| Field | Type | Description |
+|---|---|---|
+| `input` | `string` | The model-facing question, prompt, instruction, query, or task input. |
+| `context` | `string` | The long-context document, passage set, dialogue, code context, or retrieved evidence. |
+| `answers` | `list[string]` | Gold reference answer or answer candidates. |
+| `length` | `int32` | Source-provided context length metadata. |
+| `input_tokens` | `int32` | Number of `cl100k_base` tokens in `input`. Added by this repackaging. |
+| `context_tokens` | `int32` | Number of `cl100k_base` tokens in `context`. Added by this repackaging. |
+| `total_tokens` | `int32` | Number of `cl100k_base` tokens in `input` plus `context`, counted with one newline separator when `input` is non-empty. Added by this repackaging. |
+| `dataset` | `string` | Original dataset/task label from LongBench. |
+| `language` | `string` | Source-provided language label. |
+| `all_classes` | `list[string]` | Candidate class labels when applicable. Empty for tasks where this is not used. |
+| `_id` | `string` | Original example identifier, preserved when available. |
+
+### Configurations
+
+| Configuration | Task Group | Examples | Languages | Mean Source Length | Mean Tokens | Max Tokens |
+|---|---|---:|---|---:|---:|---:|
+| `narrativeqa` | Single-Document QA | 200 | `en` | 18404.94 | 29790.89 | 65293 |
+| `qasper` | Single-Document QA | 200 | `en` | 3618.7 | 4932.52 | 21129 |
+| `multifieldqa_en` | Single-Document QA | 150 | `en` | 4558.7 | 6951.12 | 14962 |
+| `multifieldqa_zh` | Single-Document QA | 200 | `zh` | 6700.68 | 7296.32 | 14962 |
+| `hotpotqa` | Multi-Document QA | 200 | `en` | 9149.22 | 12812.86 | 16346 |
+| `2wikimqa` | Multi-Document QA | 200 | `en` | 4885.31 | 7133.24 | 16356 |
+| `musique` | Multi-Document QA | 200 | `en` | 11017.66 | 15595.57 | 16353 |
+| `dureader` | Multi-Document QA | 200 | `zh` | 15768.04 | 17605.0 | 32255 |
+| `gov_report` | Summarization | 200 | `en` | 8169.36 | 10242.25 | 51394 |
+| `qmsum` | Summarization | 200 | `en` | 10545.94 | 13868.7 | 30389 |
+| `multi_news` | Summarization | 200 | `en` | 2113.49 | 2609.06 | 13935 |
+| `vcsum` | Summarization | 200 | `zh` | 15147.02 | 16896.71 | 49027 |
+| `trec` | Few-Shot Learning | 200 | `en` | 5176.36 | 6768.22 | 11382 |
+| `triviaqa` | Few-Shot Learning | 200 | `en` | 8209.3 | 11771.0 | 23349 |
+| `samsum` | Few-Shot Learning | 200 | `en` | 6258.35 | 9155.56 | 17981 |
+| `lsht` | Few-Shot Learning | 200 | `zh` | 22332.62 | 26322.06 | 51727 |
+| `passage_count` | Synthetic Tasks | 200 | `en` | 11140.59 | 14898.67 | 28965 |
+| `passage_retrieval_en` | Synthetic Tasks | 200 | `en` | 9287.97 | 12471.94 | 15188 |
+| `passage_retrieval_zh` | Synthetic Tasks | 200 | `zh` | 6745.15 | 7765.06 | 10736 |
+| `lcc` | Code Completion | 500 | `csharp`, `java`, `python` | 1235.28 | 3165.98 | 30150 |
+| `repobench-p` | Code Completion | 500 | `java`, `python` | 4205.93 | 10813.41 | 39128 |
+| `qasper_e` | LongBench-E | 224 | `en` | 4620.48 | 6218.5 | 21129 |
+| `multifieldqa_en_e` | LongBench-E | 150 | `en` | 4558.7 | 6951.12 | 14962 |
+| `hotpotqa_e` | LongBench-E | 300 | `en` | 6657.96 | 9470.88 | 16329 |
+| `2wikimqa_e` | LongBench-E | 300 | `en` | 6146.54 | 8874.2 | 16333 |
+| `gov_report_e` | LongBench-E | 300 | `en` | 7140.79 | 8160.53 | 27686 |
+| `multi_news_e` | LongBench-E | 294 | `en` | 5999.31 | 7883.37 | 38322 |
+| `trec_e` | LongBench-E | 300 | `en` | 6259.26 | 8181.84 | 17185 |
+| `triviaqa_e` | LongBench-E | 300 | `en` | 6684.6 | 9693.12 | 36228 |
+| `samsum_e` | LongBench-E | 300 | `en` | 6170.48 | 9035.07 | 18223 |
+| `passage_count_e` | LongBench-E | 300 | `en` | 6117.3 | 8232.71 | 22952 |
+| `passage_retrieval_en_e` | LongBench-E | 300 | `en` | 6115.38 | 8185.44 | 14490 |
+| `lcc_e` | LongBench-E | 300 | `csharp`, `java`, `python` | 5546.3 | 13516.84 | 49200 |
+| `repobench-p_e` | LongBench-E | 300 | `java`, `python` | 6067.31 | 15312.48 | 41008 |
+
+## Task Groups
+
+### Single-Document QA
+
+- Configurations: `narrativeqa`, `qasper`, `multifieldqa_en`, `multifieldqa_zh`
+- Examples: **750**
+### Multi-Document QA
+
+- Configurations: `hotpotqa`, `2wikimqa`, `musique`, `dureader`
+- Examples: **800**
+### Summarization
+
+- Configurations: `gov_report`, `qmsum`, `multi_news`, `vcsum`
+- Examples: **800**
+### Few-Shot Learning
+
+- Configurations: `trec`, `triviaqa`, `samsum`, `lsht`
+- Examples: **800**
+### Synthetic Tasks
+
+- Configurations: `passage_count`, `passage_retrieval_en`, `passage_retrieval_zh`
+- Examples: **600**
+### Code Completion
+
+- Configurations: `lcc`, `repobench-p`
+- Examples: **1000**
+### LongBench-E
+
+- Configurations: `qasper_e`, `multifieldqa_en_e`, `hotpotqa_e`, `2wikimqa_e`, `gov_report_e`, `multi_news_e`, `trec_e`, `triviaqa_e`, `samsum_e`, `passage_count_e`, `passage_retrieval_en_e`, `lcc_e`, `repobench-p_e`
+- Examples: **3668**
+
+## Languages
+
+Row-level labels: `csharp`, `en`, `java`, `python`, `zh`
+
+Hub metadata labels: `code`, `en`, `zh`
+
+Code labels preserved in rows: `csharp`, `java`, `python`
+
+## Source Dataset Labels
+
+`2wikimqa`, `2wikimqa_e`, `dureader`, `gov_report`, `gov_report_e`, `hotpotqa`, `hotpotqa_e`, `lcc`, `lcc_e`, `lsht`, `multi_news`, `multi_news_e`, `multifieldqa_en`, `multifieldqa_en_e`, `multifieldqa_zh`, `musique`, `narrativeqa`, `passage_count`, `passage_count_e`, `passage_retrieval_en`, `passage_retrieval_en_e`, `passage_retrieval_zh`, `qasper`, `qasper_e`, `qmsum`, `repobench-p`, `repobench-p_e`, `samsum`, `samsum_e`, `trec`, `trec_e`, `triviaqa`, `triviaqa_e`, `vcsum`
+
+## Token Counts
+
+Token counts are generated during packaging with `cl100k_base`:
+
+- `input_tokens`: tokens in the task input or question.
+- `context_tokens`: tokens in the long context.
+- `total_tokens`: tokens in the combined input/context prompt.
+
+Across this build, the mean `total_tokens` is **10450.43** and the largest row has **65293** tokens.
+
+## Loading
+
+Load one task:
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("GinkgoQ/LongBench", "narrativeqa", split="test")
+print(dataset)
+print(dataset[0])
+```
+
+Load multiple tasks:
+
+```python
+from datasets import load_dataset
+
+tasks = [
+  "narrativeqa",
+  "qasper",
+  "multifieldqa_en",
+  "multifieldqa_zh",
+  "hotpotqa",
+  "2wikimqa",
+  "musique",
+  "dureader",
+  "gov_report",
+  "qmsum",
+  "multi_news",
+  "vcsum",
+  "trec",
+  "triviaqa",
+  "samsum",
+  "lsht",
+  "passage_count",
+  "passage_retrieval_en",
+  "passage_retrieval_zh",
+  "lcc",
+  "repobench-p",
+  "qasper_e",
+  "multifieldqa_en_e",
+  "hotpotqa_e",
+  "2wikimqa_e",
+  "gov_report_e",
+  "multi_news_e",
+  "trec_e",
+  "triviaqa_e",
+  "samsum_e",
+  "passage_count_e",
+  "passage_retrieval_en_e",
+  "lcc_e",
+  "repobench-p_e"
+]
+
+datasets_by_task = {
+    task: load_dataset("GinkgoQ/LongBench", task, split="test")
+    for task in tasks
+}
+```
+
+Load all available configurations dynamically:
+
+```python
+from datasets import get_dataset_config_names, load_dataset
+
+repo_id = "GinkgoQ/LongBench"
+configs = get_dataset_config_names(repo_id)
+
+datasets_by_task = {
+    config: load_dataset(repo_id, config, split="test")
+    for config in configs
+}
+```
+
+## Example Record
+
+```json
+{
+  "input": "...",
+  "context": "...",
+  "answers": ["..."],
+  "length": 12345,
+  "input_tokens": 12,
+  "context_tokens": 6789,
+  "total_tokens": 6802,
+  "dataset": "narrativeqa",
+  "language": "en",
+  "all_classes": [],
+  "_id": "..."
+}
+```
+
+## Intended Use
+
+This dataset is intended for:
+
+* Long-context language model evaluation
+* Benchmarking retrieval-augmented and long-context systems
+* Comparing performance across long-document QA, multi-document QA, summarization, classification, synthetic reasoning, and code-completion tasks
+* Reproducible evaluation workflows using the Hugging Face `datasets` library
+
+## Out-of-Scope Use
+
+This dataset should not be used as the sole evidence for claims about general model safety, factuality, robustness, legal compliance, medical reliability, or deployment readiness. It is an evaluation benchmark and should be combined with domain-specific tests when used for production model assessment.
+
+## Data Fields
+
+### `input`
+
+The model-facing user query, prompt, question, task instruction, or completion prefix.
+
+### `context`
+
+The long context provided to the model. Depending on the task, this may contain documents, passages, reports, dialogue, retrieved evidence, or source code.
+
+### `answers`
+
+Reference answer list. Some tasks may include multiple valid answers.
+
+### `length`
+
+Source-provided length metadata.
+
+### `input_tokens`
+
+Number of `cl100k_base` tokens in `input`, added by this packaging script.
+
+### `context_tokens`
+
+Number of `cl100k_base` tokens in `context`, added by this packaging script.
+
+### `total_tokens`
+
+Number of `cl100k_base` tokens in the combined input/context prompt. When `input` is non-empty, the counter uses `input + "\n" + context`; otherwise it counts `context`.
+
+### `dataset`
+
+Original dataset or task label.
+
+### `language`
+
+Source-provided language metadata.
+
+### `all_classes`
+
+Candidate labels for classification-style tasks. Empty when not applicable.
+
+### `_id`
+
+Original example identifier when available. If an identifier was missing in a local source row, this build pipeline generated a deterministic fallback identifier using the task name and row index.
+
+## Build Details
+
+This repository was generated automatically from local JSONL files using a validation and conversion pipeline.
+
+* Build timestamp UTC: `2026-05-24T08:39:15.338043+00:00`
+* Source directory: `/home/arman/project/LongBench/LongBench_data/data`
+* Number of configurations: **34**
+* Total examples: **8418**
+* File format: Parquet
+* Split: `test`
+* Schema: fixed typed schema shared by all configurations
+* Validation mode: `strict`
+* Max shard size: `500MB`
+* Token count method: `cl100k_base`
+
+## Processing Pipeline
+
+The build pipeline performs the following steps:
+
+1. Detects available LongBench JSONL files.
+2. Validates task names against the known LongBench task list.
+3. Reads each JSONL file line by line.
+4. Validates JSON syntax and row object type.
+5. Normalizes all original fields into a consistent Hugging Face schema.
+6. Adds `input_tokens`, `context_tokens`, and `total_tokens` with `cl100k_base`.
+7. Preserves the original LongBench fields.
+8. Converts each task into a typed Hugging Face `Dataset`.
+9. Writes each task as Parquet under `data/<config>/test-*.parquet`.
+10. Generates this dataset card dynamically from the detected files and statistics.
+11. Generates `dataset_infos.json` and `build_metadata.json`.
+12. Optionally creates the Hugging Face dataset repository.
+13. Uploads the generated repository folder to the Hugging Face Hub.
+14. Optionally performs a remote smoke test with `load_dataset`.
+
+## Validation Notes
+
+The build script supports strict and non-strict modes.
+
+In strict mode, the script fails if required fields are missing, if `input` or `context` are empty, if `length` is negative, or if list-like fields cannot be normalized.
+
+In non-strict mode, the script preserves maximum compatibility by filling missing optional values with deterministic defaults where possible.
+
+## Citation
+
+If you use this repackaged dataset, cite the original LongBench paper:
+
+```bibtex
+@article{bai2023longbench,
+  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},
+  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},
+  journal={arXiv preprint arXiv:2308.14508},
+  year={2023}
+}
+```
+
+## License
+
+This repository uses the license metadata `apache-2.0`. Users should verify licensing and redistribution requirements against the original LongBench project and any upstream datasets included in LongBench before public redistribution or commercial usage.
+
+## Acknowledgements
+
+All benchmark design, task construction, and source data attribution belong to the LongBench authors and the THUDM LongBench project. This repository only repackages the source files for easier loading and use through the Hugging Face Hub.

build_metadata.json

@@ -0,0 +1,1696 @@
+{
+  "build_info": {
+    "timestamp_utc": "2026-05-24T08:39:15.338043+00:00",
+    "source_dir": "/home/arman/project/LongBench/LongBench_data/data",
+    "output_dir": "/home/arman/project/LongBench/LongBench_data/hf_longbench_dataset",
+    "repo_id": "GinkgoQ/LongBench",
+    "pretty_name": "LongBench",
+    "license": "apache-2.0",
+    "validation_mode": "strict",
+    "max_shard_size": "500MB",
+    "token_count_method": "cl100k_base",
+    "datasets_version": "4.2.0"
+  },
+  "source": {
+    "homepage": "https://github.com/THUDM/LongBench",
+    "paper": "https://arxiv.org/abs/2308.14508",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}"
+  },
+  "features": {
+    "input": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "context": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "answers": {
+      "feature": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "_type": "List"
+    },
+    "length": {
+      "dtype": "int32",
+      "_type": "Value"
+    },
+    "input_tokens": {
+      "dtype": "int32",
+      "_type": "Value"
+    },
+    "context_tokens": {
+      "dtype": "int32",
+      "_type": "Value"
+    },
+    "total_tokens": {
+      "dtype": "int32",
+      "_type": "Value"
+    },
+    "dataset": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "language": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "all_classes": {
+      "feature": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "_type": "List"
+    },
+    "_id": {
+      "dtype": "string",
+      "_type": "Value"
+    }
+  },
+  "tasks": [
+    "narrativeqa",
+    "qasper",
+    "multifieldqa_en",
+    "multifieldqa_zh",
+    "hotpotqa",
+    "2wikimqa",
+    "musique",
+    "dureader",
+    "gov_report",
+    "qmsum",
+    "multi_news",
+    "vcsum",
+    "trec",
+    "triviaqa",
+    "samsum",
+    "lsht",
+    "passage_count",
+    "passage_retrieval_en",
+    "passage_retrieval_zh",
+    "lcc",
+    "repobench-p",
+    "qasper_e",
+    "multifieldqa_en_e",
+    "hotpotqa_e",
+    "2wikimqa_e",
+    "gov_report_e",
+    "multi_news_e",
+    "trec_e",
+    "triviaqa_e",
+    "samsum_e",
+    "passage_count_e",
+    "passage_retrieval_en_e",
+    "lcc_e",
+    "repobench-p_e"
+  ],
+  "task_groups": {
+    "Single-Document QA": [
+      "narrativeqa",
+      "qasper",
+      "multifieldqa_en",
+      "multifieldqa_zh"
+    ],
+    "Multi-Document QA": [
+      "hotpotqa",
+      "2wikimqa",
+      "musique",
+      "dureader"
+    ],
+    "Summarization": [
+      "gov_report",
+      "qmsum",
+      "multi_news",
+      "vcsum"
+    ],
+    "Few-Shot Learning": [
+      "trec",
+      "triviaqa",
+      "samsum",
+      "lsht"
+    ],
+    "Synthetic Tasks": [
+      "passage_count",
+      "passage_retrieval_en",
+      "passage_retrieval_zh"
+    ],
+    "Code Completion": [
+      "lcc",
+      "repobench-p"
+    ],
+    "LongBench-E": [
+      "qasper_e",
+      "multifieldqa_en_e",
+      "hotpotqa_e",
+      "2wikimqa_e",
+      "gov_report_e",
+      "multi_news_e",
+      "trec_e",
+      "triviaqa_e",
+      "samsum_e",
+      "passage_count_e",
+      "passage_retrieval_en_e",
+      "lcc_e",
+      "repobench-p_e"
+    ]
+  },
+  "task_stats": {
+    "narrativeqa": {
+      "task": "narrativeqa",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/narrativeqa.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "narrativeqa": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 5397,
+      "max_length": 36418,
+      "mean_length": 18404.94,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 4,
+      "max_input_tokens": 26,
+      "mean_input_tokens": 11.03,
+      "min_context_tokens": 7966,
+      "max_context_tokens": 65276,
+      "mean_context_tokens": 29779.86,
+      "min_total_tokens": 7972,
+      "max_total_tokens": 65293,
+      "mean_total_tokens": 29790.89
+    },
+    "qasper": {
+      "task": "qasper",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/qasper.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "qasper": 200
+      },
+      "answer_count_distribution": {
+        "1": 55,
+        "2": 140,
+        "3": 5
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1440,
+      "max_length": 14660,
+      "mean_length": 3618.7,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 5,
+      "max_input_tokens": 26,
+      "mean_input_tokens": 9.45,
+      "min_context_tokens": 1846,
+      "max_context_tokens": 21121,
+      "mean_context_tokens": 4923.06,
+      "min_total_tokens": 1855,
+      "max_total_tokens": 21129,
+      "mean_total_tokens": 4932.52
+    },
+    "multifieldqa_en": {
+      "task": "multifieldqa_en",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/multifieldqa_en.jsonl",
+      "num_examples": 150,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 150
+      },
+      "dataset_labels": {
+        "multifieldqa_en": 150
+      },
+      "answer_count_distribution": {
+        "1": 150
+      },
+      "all_classes_count_distribution": {
+        "0": 150
+      },
+      "min_length": 505,
+      "max_length": 10337,
+      "mean_length": 4558.7,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 6,
+      "max_input_tokens": 30,
+      "mean_input_tokens": 13.33,
+      "min_context_tokens": 1286,
+      "max_context_tokens": 14949,
+      "mean_context_tokens": 6937.79,
+      "min_total_tokens": 1298,
+      "max_total_tokens": 14962,
+      "mean_total_tokens": 6951.12
+    },
+    "multifieldqa_zh": {
+      "task": "multifieldqa_zh",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/multifieldqa_zh.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "zh": 200
+      },
+      "dataset_labels": {
+        "multifieldqa_zh": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1260,
+      "max_length": 16791,
+      "mean_length": 6700.68,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 8,
+      "max_input_tokens": 51,
+      "mean_input_tokens": 20.5,
+      "min_context_tokens": 1277,
+      "max_context_tokens": 14937,
+      "mean_context_tokens": 7275.81,
+      "min_total_tokens": 1297,
+      "max_total_tokens": 14962,
+      "mean_total_tokens": 7296.32
+    },
+    "hotpotqa": {
+      "task": "hotpotqa",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/hotpotqa.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "hotpotqa": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1078,
+      "max_length": 12697,
+      "mean_length": 9149.22,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 8,
+      "max_input_tokens": 48,
+      "mean_input_tokens": 19.54,
+      "min_context_tokens": 1748,
+      "max_context_tokens": 16325,
+      "mean_context_tokens": 12793.29,
+      "min_total_tokens": 1771,
+      "max_total_tokens": 16346,
+      "mean_total_tokens": 12812.86
+    },
+    "2wikimqa": {
+      "task": "2wikimqa",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/2wikimqa.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "2wikimqa": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 535,
+      "max_length": 11950,
+      "mean_length": 4885.31,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 8,
+      "max_input_tokens": 33,
+      "mean_input_tokens": 16.85,
+      "min_context_tokens": 912,
+      "max_context_tokens": 16344,
+      "mean_context_tokens": 7116.4,
+      "min_total_tokens": 932,
+      "max_total_tokens": 16356,
+      "mean_total_tokens": 7133.24
+    },
+    "musique": {
+      "task": "musique",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/musique.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "musique": 200
+      },
+      "answer_count_distribution": {
+        "1": 149,
+        "2": 38,
+        "3": 6,
+        "4": 4,
+        "5": 3
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 3440,
+      "max_length": 17355,
+      "mean_length": 11017.66,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 8,
+      "max_input_tokens": 41,
+      "mean_input_tokens": 18.59,
+      "min_context_tokens": 6484,
+      "max_context_tokens": 16337,
+      "mean_context_tokens": 15576.98,
+      "min_total_tokens": 6498,
+      "max_total_tokens": 16353,
+      "mean_total_tokens": 15595.57
+    },
+    "dureader": {
+      "task": "dureader",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/dureader.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "zh": 200
+      },
+      "dataset_labels": {
+        "dureader": 200
+      },
+      "answer_count_distribution": {
+        "1": 80,
+        "2": 63,
+        "3": 57
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 8065,
+      "max_length": 27096,
+      "mean_length": 15768.04,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 4,
+      "max_input_tokens": 27,
+      "mean_input_tokens": 11.73,
+      "min_context_tokens": 8259,
+      "max_context_tokens": 32239,
+      "mean_context_tokens": 17592.26,
+      "min_total_tokens": 8266,
+      "max_total_tokens": 32255,
+      "mean_total_tokens": 17605.0
+    },
+    "gov_report": {
+      "task": "gov_report",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/gov_report.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "gov_report": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1743,
+      "max_length": 40508,
+      "mean_length": 8169.36,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 2019,
+      "max_context_tokens": 51394,
+      "mean_context_tokens": 10242.25,
+      "min_total_tokens": 2019,
+      "max_total_tokens": 51394,
+      "mean_total_tokens": 10242.25
+    },
+    "qmsum": {
+      "task": "qmsum",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/qmsum.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "qmsum": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1789,
+      "max_length": 24585,
+      "mean_length": 10545.94,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 5,
+      "max_input_tokens": 36,
+      "mean_input_tokens": 13.61,
+      "min_context_tokens": 2575,
+      "max_context_tokens": 30377,
+      "mean_context_tokens": 13855.03,
+      "min_total_tokens": 2584,
+      "max_total_tokens": 30389,
+      "mean_total_tokens": 13868.7
+    },
+    "multi_news": {
+      "task": "multi_news",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/multi_news.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "multi_news": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 258,
+      "max_length": 10933,
+      "mean_length": 2113.49,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 130,
+      "max_context_tokens": 13935,
+      "mean_context_tokens": 2609.06,
+      "min_total_tokens": 130,
+      "max_total_tokens": 13935,
+      "mean_total_tokens": 2609.06
+    },
+    "vcsum": {
+      "task": "vcsum",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/vcsum.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "zh": 200
+      },
+      "dataset_labels": {
+        "vcsum": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1114,
+      "max_length": 42073,
+      "mean_length": 15147.02,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 1359,
+      "max_context_tokens": 49027,
+      "mean_context_tokens": 16896.71,
+      "min_total_tokens": 1359,
+      "max_total_tokens": 49027,
+      "mean_total_tokens": 16896.71
+    },
+    "trec": {
+      "task": "trec",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/trec.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "trec": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "50": 200
+      },
+      "min_length": 1435,
+      "max_length": 8714,
+      "mean_length": 5176.36,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 8,
+      "max_input_tokens": 20,
+      "mean_input_tokens": 12.0,
+      "min_context_tokens": 1854,
+      "max_context_tokens": 11369,
+      "mean_context_tokens": 6756.22,
+      "min_total_tokens": 1866,
+      "max_total_tokens": 11382,
+      "mean_total_tokens": 6768.22
+    },
+    "triviaqa": {
+      "task": "triviaqa",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/triviaqa.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "triviaqa": 200
+      },
+      "answer_count_distribution": {
+        "1": 6,
+        "2": 18,
+        "3": 17,
+        "4": 10,
+        "5": 11,
+        "6": 8,
+        "7": 8,
+        "8": 9,
+        "9": 4,
+        "10": 4,
+        "11": 6,
+        "12": 8,
+        "13": 10,
+        "14": 10,
+        "15": 5,
+        "16": 7,
+        "17": 2,
+        "18": 4,
+        "19": 2,
+        "20": 3,
+        "21": 7,
+        "22": 4,
+        "23": 2,
+        "24": 3,
+        "25": 3,
+        "26": 3,
+        "27": 1,
+        "28": 3,
+        "29": 1,
+        "32": 2,
+        "34": 4,
+        "35": 1,
+        "36": 2,
+        "37": 1,
+        "38": 1,
+        "40": 1,
+        "44": 1,
+        "45": 1,
+        "54": 1,
+        "84": 1,
+        "85": 1,
+        "90": 2,
+        "100": 1,
+        "182": 1
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 1145,
+      "max_length": 16633,
+      "mean_length": 8209.3,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 89,
+      "max_input_tokens": 1929,
+      "mean_input_tokens": 715.6,
+      "min_context_tokens": 1324,
+      "max_context_tokens": 22327,
+      "mean_context_tokens": 11055.41,
+      "min_total_tokens": 1482,
+      "max_total_tokens": 23349,
+      "mean_total_tokens": 11771.0
+    },
+    "samsum": {
+      "task": "samsum",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/samsum.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "samsum": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 936,
+      "max_length": 12252,
+      "mean_length": 6258.35,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 21,
+      "max_input_tokens": 507,
+      "mean_input_tokens": 150.32,
+      "min_context_tokens": 1332,
+      "max_context_tokens": 17938,
+      "mean_context_tokens": 9005.24,
+      "min_total_tokens": 1386,
+      "max_total_tokens": 17981,
+      "mean_total_tokens": 9155.56
+    },
+    "lsht": {
+      "task": "lsht",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/lsht.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "zh": 200
+      },
+      "dataset_labels": {
+        "lsht": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "24": 200
+      },
+      "min_length": 5648,
+      "max_length": 44221,
+      "mean_length": 22332.62,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 42,
+      "max_input_tokens": 5683,
+      "mean_input_tokens": 974.14,
+      "min_context_tokens": 6370,
+      "max_context_tokens": 51435,
+      "mean_context_tokens": 25347.92,
+      "min_total_tokens": 6452,
+      "max_total_tokens": 51727,
+      "mean_total_tokens": 26322.06
+    },
+    "passage_count": {
+      "task": "passage_count",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/passage_count.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "passage_count": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 3554,
+      "max_length": 22099,
+      "mean_length": 11140.59,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 4740,
+      "max_context_tokens": 28965,
+      "mean_context_tokens": 14898.67,
+      "min_total_tokens": 4740,
+      "max_total_tokens": 28965,
+      "mean_total_tokens": 14898.67
+    },
+    "passage_retrieval_en": {
+      "task": "passage_retrieval_en",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/passage_retrieval_en.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 200
+      },
+      "dataset_labels": {
+        "passage_retrieval_en": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 7533,
+      "max_length": 11516,
+      "mean_length": 9287.97,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 68,
+      "max_input_tokens": 445,
+      "mean_input_tokens": 174.88,
+      "min_context_tokens": 9753,
+      "max_context_tokens": 14934,
+      "mean_context_tokens": 12297.06,
+      "min_total_tokens": 9954,
+      "max_total_tokens": 15188,
+      "mean_total_tokens": 12471.94
+    },
+    "passage_retrieval_zh": {
+      "task": "passage_retrieval_zh",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/passage_retrieval_zh.jsonl",
+      "num_examples": 200,
+      "duplicate_id_count": 0,
+      "languages": {
+        "zh": 200
+      },
+      "dataset_labels": {
+        "passage_retrieval_zh": 200
+      },
+      "answer_count_distribution": {
+        "1": 200
+      },
+      "all_classes_count_distribution": {
+        "0": 200
+      },
+      "min_length": 5055,
+      "max_length": 8963,
+      "mean_length": 6745.15,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 16,
+      "max_input_tokens": 1392,
+      "mean_input_tokens": 175.94,
+      "min_context_tokens": 5548,
+      "max_context_tokens": 10437,
+      "mean_context_tokens": 7589.1,
+      "min_total_tokens": 5674,
+      "max_total_tokens": 10736,
+      "mean_total_tokens": 7765.06
+    },
+    "lcc": {
+      "task": "lcc",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/lcc.jsonl",
+      "num_examples": 500,
+      "duplicate_id_count": 0,
+      "languages": {
+        "csharp": 158,
+        "java": 160,
+        "python": 182
+      },
+      "dataset_labels": {
+        "lcc": 500
+      },
+      "answer_count_distribution": {
+        "1": 500
+      },
+      "all_classes_count_distribution": {
+        "0": 500
+      },
+      "min_length": 399,
+      "max_length": 10029,
+      "mean_length": 1235.28,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 989,
+      "max_context_tokens": 30150,
+      "mean_context_tokens": 3165.98,
+      "min_total_tokens": 989,
+      "max_total_tokens": 30150,
+      "mean_total_tokens": 3165.98
+    },
+    "repobench-p": {
+      "task": "repobench-p",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/repobench-p.jsonl",
+      "num_examples": 500,
+      "duplicate_id_count": 0,
+      "languages": {
+        "java": 264,
+        "python": 236
+      },
+      "dataset_labels": {
+        "repobench-p": 500
+      },
+      "answer_count_distribution": {
+        "1": 500
+      },
+      "all_classes_count_distribution": {
+        "0": 500
+      },
+      "min_length": 810,
+      "max_length": 18754,
+      "mean_length": 4205.93,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 127,
+      "max_input_tokens": 3820,
+      "mean_input_tokens": 998.91,
+      "min_context_tokens": 1240,
+      "max_context_tokens": 37941,
+      "mean_context_tokens": 9814.47,
+      "min_total_tokens": 2644,
+      "max_total_tokens": 39128,
+      "mean_total_tokens": 10813.41
+    },
+    "qasper_e": {
+      "task": "qasper_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/qasper_e.jsonl",
+      "num_examples": 224,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 224
+      },
+      "dataset_labels": {
+        "qasper_e": 224
+      },
+      "answer_count_distribution": {
+        "1": 68,
+        "2": 153,
+        "3": 3
+      },
+      "all_classes_count_distribution": {
+        "0": 224
+      },
+      "min_length": 1443,
+      "max_length": 14722,
+      "mean_length": 4620.48,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 5,
+      "max_input_tokens": 26,
+      "mean_input_tokens": 9.8,
+      "min_context_tokens": 1846,
+      "max_context_tokens": 21121,
+      "mean_context_tokens": 6208.7,
+      "min_total_tokens": 1869,
+      "max_total_tokens": 21129,
+      "mean_total_tokens": 6218.5
+    },
+    "multifieldqa_en_e": {
+      "task": "multifieldqa_en_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/multifieldqa_en_e.jsonl",
+      "num_examples": 150,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 150
+      },
+      "dataset_labels": {
+        "multifieldqa_en_e": 150
+      },
+      "answer_count_distribution": {
+        "1": 150
+      },
+      "all_classes_count_distribution": {
+        "0": 150
+      },
+      "min_length": 505,
+      "max_length": 10337,
+      "mean_length": 4558.7,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 6,
+      "max_input_tokens": 30,
+      "mean_input_tokens": 13.33,
+      "min_context_tokens": 1286,
+      "max_context_tokens": 14949,
+      "mean_context_tokens": 6937.79,
+      "min_total_tokens": 1298,
+      "max_total_tokens": 14962,
+      "mean_total_tokens": 6951.12
+    },
+    "hotpotqa_e": {
+      "task": "hotpotqa_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/hotpotqa_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "hotpotqa_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 111,
+      "max_length": 12480,
+      "mean_length": 6657.96,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 10,
+      "max_input_tokens": 49,
+      "mean_input_tokens": 19.8,
+      "min_context_tokens": 167,
+      "max_context_tokens": 16313,
+      "mean_context_tokens": 9451.05,
+      "min_total_tokens": 186,
+      "max_total_tokens": 16329,
+      "mean_total_tokens": 9470.88
+    },
+    "2wikimqa_e": {
+      "task": "2wikimqa_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/2wikimqa_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "2wikimqa_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 987,
+      "max_length": 12334,
+      "mean_length": 6146.54,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 9,
+      "max_input_tokens": 31,
+      "mean_input_tokens": 16.6,
+      "min_context_tokens": 1379,
+      "max_context_tokens": 16319,
+      "mean_context_tokens": 8857.59,
+      "min_total_tokens": 1394,
+      "max_total_tokens": 16333,
+      "mean_total_tokens": 8874.2
+    },
+    "gov_report_e": {
+      "task": "gov_report_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/gov_report_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "gov_report_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 881,
+      "max_length": 23442,
+      "mean_length": 7140.79,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 1019,
+      "max_context_tokens": 27686,
+      "mean_context_tokens": 8160.53,
+      "min_total_tokens": 1019,
+      "max_total_tokens": 27686,
+      "mean_total_tokens": 8160.53
+    },
+    "multi_news_e": {
+      "task": "multi_news_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/multi_news_e.jsonl",
+      "num_examples": 294,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 294
+      },
+      "dataset_labels": {
+        "multi_news_e": 294
+      },
+      "answer_count_distribution": {
+        "1": 294
+      },
+      "all_classes_count_distribution": {
+        "0": 294
+      },
+      "min_length": 374,
+      "max_length": 27973,
+      "mean_length": 5999.31,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 359,
+      "max_context_tokens": 38322,
+      "mean_context_tokens": 7883.37,
+      "min_total_tokens": 359,
+      "max_total_tokens": 38322,
+      "mean_total_tokens": 7883.37
+    },
+    "trec_e": {
+      "task": "trec_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/trec_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "trec_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "50": 300
+      },
+      "min_length": 746,
+      "max_length": 13237,
+      "mean_length": 6259.26,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 8,
+      "max_input_tokens": 24,
+      "mean_input_tokens": 12.09,
+      "min_context_tokens": 972,
+      "max_context_tokens": 17173,
+      "mean_context_tokens": 8169.75,
+      "min_total_tokens": 982,
+      "max_total_tokens": 17185,
+      "mean_total_tokens": 8181.84
+    },
+    "triviaqa_e": {
+      "task": "triviaqa_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/triviaqa_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "triviaqa_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 7,
+        "2": 26,
+        "3": 21,
+        "4": 12,
+        "5": 13,
+        "6": 20,
+        "7": 16,
+        "8": 18,
+        "9": 11,
+        "10": 6,
+        "11": 7,
+        "12": 9,
+        "13": 16,
+        "14": 11,
+        "15": 3,
+        "16": 7,
+        "17": 3,
+        "18": 4,
+        "19": 2,
+        "20": 6,
+        "21": 10,
+        "22": 6,
+        "23": 6,
+        "24": 7,
+        "25": 5,
+        "26": 5,
+        "27": 2,
+        "28": 6,
+        "29": 2,
+        "30": 1,
+        "32": 7,
+        "34": 4,
+        "35": 1,
+        "36": 2,
+        "37": 2,
+        "40": 2,
+        "44": 2,
+        "45": 2,
+        "50": 1,
+        "54": 1,
+        "56": 1,
+        "84": 1,
+        "90": 1,
+        "92": 1,
+        "100": 2,
+        "182": 2
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 804,
+      "max_length": 15960,
+      "mean_length": 6684.6,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 89,
+      "max_input_tokens": 1929,
+      "mean_input_tokens": 696.78,
+      "min_context_tokens": 495,
+      "max_context_tokens": 36061,
+      "mean_context_tokens": 8996.34,
+      "min_total_tokens": 1054,
+      "max_total_tokens": 36228,
+      "mean_total_tokens": 9693.12
+    },
+    "samsum_e": {
+      "task": "samsum_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/samsum_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "samsum_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 936,
+      "max_length": 12403,
+      "mean_length": 6170.48,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 30,
+      "max_input_tokens": 543,
+      "mean_input_tokens": 153.12,
+      "min_context_tokens": 1332,
+      "max_context_tokens": 18171,
+      "mean_context_tokens": 8881.95,
+      "min_total_tokens": 1386,
+      "max_total_tokens": 18223,
+      "mean_total_tokens": 9035.07
+    },
+    "passage_count_e": {
+      "task": "passage_count_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/passage_count_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "passage_count_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 1407,
+      "max_length": 14537,
+      "mean_length": 6117.3,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 1841,
+      "max_context_tokens": 22952,
+      "mean_context_tokens": 8232.71,
+      "min_total_tokens": 1841,
+      "max_total_tokens": 22952,
+      "mean_total_tokens": 8232.71
+    },
+    "passage_retrieval_en_e": {
+      "task": "passage_retrieval_en_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/passage_retrieval_en_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "en": 300
+      },
+      "dataset_labels": {
+        "passage_retrieval_en_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 2358,
+      "max_length": 10607,
+      "mean_length": 6115.38,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 44,
+      "max_input_tokens": 394,
+      "mean_input_tokens": 175.62,
+      "min_context_tokens": 3062,
+      "max_context_tokens": 14312,
+      "mean_context_tokens": 8009.82,
+      "min_total_tokens": 3169,
+      "max_total_tokens": 14490,
+      "mean_total_tokens": 8185.44
+    },
+    "lcc_e": {
+      "task": "lcc_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/lcc_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "csharp": 97,
+        "java": 91,
+        "python": 112
+      },
+      "dataset_labels": {
+        "lcc_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 386,
+      "max_length": 23278,
+      "mean_length": 5546.3,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 0,
+      "max_input_tokens": 0,
+      "mean_input_tokens": 0.0,
+      "min_context_tokens": 1099,
+      "max_context_tokens": 49200,
+      "mean_context_tokens": 13516.84,
+      "min_total_tokens": 1099,
+      "max_total_tokens": 49200,
+      "mean_total_tokens": 13516.84
+    },
+    "repobench-p_e": {
+      "task": "repobench-p_e",
+      "source_file": "/home/arman/project/LongBench/LongBench_data/data/repobench-p_e.jsonl",
+      "num_examples": 300,
+      "duplicate_id_count": 0,
+      "languages": {
+        "java": 167,
+        "python": 133
+      },
+      "dataset_labels": {
+        "repobench-p_e": 300
+      },
+      "answer_count_distribution": {
+        "1": 300
+      },
+      "all_classes_count_distribution": {
+        "0": 300
+      },
+      "min_length": 785,
+      "max_length": 18864,
+      "mean_length": 6067.31,
+      "token_count_method": "cl100k_base",
+      "min_input_tokens": 147,
+      "max_input_tokens": 4330,
+      "mean_input_tokens": 1073.45,
+      "min_context_tokens": 1240,
+      "max_context_tokens": 40430,
+      "mean_context_tokens": 14238.96,
+      "min_total_tokens": 2168,
+      "max_total_tokens": 41008,
+      "mean_total_tokens": 15312.48
+    }
+  },
+  "parquet_files": {
+    "narrativeqa": [
+      "data/narrativeqa/test-00000-of-00001.parquet"
+    ],
+    "qasper": [
+      "data/qasper/test-00000-of-00001.parquet"
+    ],
+    "multifieldqa_en": [
+      "data/multifieldqa_en/test-00000-of-00001.parquet"
+    ],
+    "multifieldqa_zh": [
+      "data/multifieldqa_zh/test-00000-of-00001.parquet"
+    ],
+    "hotpotqa": [
+      "data/hotpotqa/test-00000-of-00001.parquet"
+    ],
+    "2wikimqa": [
+      "data/2wikimqa/test-00000-of-00001.parquet"
+    ],
+    "musique": [
+      "data/musique/test-00000-of-00001.parquet"
+    ],
+    "dureader": [
+      "data/dureader/test-00000-of-00001.parquet"
+    ],
+    "gov_report": [
+      "data/gov_report/test-00000-of-00001.parquet"
+    ],
+    "qmsum": [
+      "data/qmsum/test-00000-of-00001.parquet"
+    ],
+    "multi_news": [
+      "data/multi_news/test-00000-of-00001.parquet"
+    ],
+    "vcsum": [
+      "data/vcsum/test-00000-of-00001.parquet"
+    ],
+    "trec": [
+      "data/trec/test-00000-of-00001.parquet"
+    ],
+    "triviaqa": [
+      "data/triviaqa/test-00000-of-00001.parquet"
+    ],
+    "samsum": [
+      "data/samsum/test-00000-of-00001.parquet"
+    ],
+    "lsht": [
+      "data/lsht/test-00000-of-00001.parquet"
+    ],
+    "passage_count": [
+      "data/passage_count/test-00000-of-00001.parquet"
+    ],
+    "passage_retrieval_en": [
+      "data/passage_retrieval_en/test-00000-of-00001.parquet"
+    ],
+    "passage_retrieval_zh": [
+      "data/passage_retrieval_zh/test-00000-of-00001.parquet"
+    ],
+    "lcc": [
+      "data/lcc/test-00000-of-00001.parquet"
+    ],
+    "repobench-p": [
+      "data/repobench-p/test-00000-of-00001.parquet"
+    ],
+    "qasper_e": [
+      "data/qasper_e/test-00000-of-00001.parquet"
+    ],
+    "multifieldqa_en_e": [
+      "data/multifieldqa_en_e/test-00000-of-00001.parquet"
+    ],
+    "hotpotqa_e": [
+      "data/hotpotqa_e/test-00000-of-00001.parquet"
+    ],
+    "2wikimqa_e": [
+      "data/2wikimqa_e/test-00000-of-00001.parquet"
+    ],
+    "gov_report_e": [
+      "data/gov_report_e/test-00000-of-00001.parquet"
+    ],
+    "multi_news_e": [
+      "data/multi_news_e/test-00000-of-00001.parquet"
+    ],
+    "trec_e": [
+      "data/trec_e/test-00000-of-00001.parquet"
+    ],
+    "triviaqa_e": [
+      "data/triviaqa_e/test-00000-of-00001.parquet"
+    ],
+    "samsum_e": [
+      "data/samsum_e/test-00000-of-00001.parquet"
+    ],
+    "passage_count_e": [
+      "data/passage_count_e/test-00000-of-00001.parquet"
+    ],
+    "passage_retrieval_en_e": [
+      "data/passage_retrieval_en_e/test-00000-of-00001.parquet"
+    ],
+    "lcc_e": [
+      "data/lcc_e/test-00000-of-00001.parquet"
+    ],
+    "repobench-p_e": [
+      "data/repobench-p_e/test-00000-of-00001.parquet"
+    ]
+  },
+  "parquet_stats": {
+    "narrativeqa": {
+      "data/narrativeqa/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4538,
+        "file_size": 12714807
+      }
+    },
+    "qasper": {
+      "data/qasper/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4625,
+        "file_size": 2354374
+      }
+    },
+    "multifieldqa_en": {
+      "data/multifieldqa_en/test-00000-of-00001.parquet": {
+        "num_rows": 150,
+        "num_row_groups": 1,
+        "serialized_size": 4851,
+        "file_size": 2301619
+      }
+    },
+    "multifieldqa_zh": {
+      "data/multifieldqa_zh/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4498,
+        "file_size": 1959043
+      }
+    },
+    "hotpotqa": {
+      "data/hotpotqa/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4558,
+        "file_size": 6598795
+      }
+    },
+    "2wikimqa": {
+      "data/2wikimqa/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4457,
+        "file_size": 3592863
+      }
+    },
+    "musique": {
+      "data/musique/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4512,
+        "file_size": 8116451
+      }
+    },
+    "dureader": {
+      "data/dureader/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 5526,
+        "file_size": 5170217
+      }
+    },
+    "gov_report": {
+      "data/gov_report/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 8298,
+        "file_size": 5490476
+      }
+    },
+    "qmsum": {
+      "data/qmsum/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 5290,
+        "file_size": 5197864
+      }
+    },
+    "multi_news": {
+      "data/multi_news/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 7628,
+        "file_size": 1495263
+      }
+    },
+    "vcsum": {
+      "data/vcsum/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 5465,
+        "file_size": 5141334
+      }
+    },
+    "trec": {
+      "data/trec/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4463,
+        "file_size": 2675373
+      }
+    },
+    "triviaqa": {
+      "data/triviaqa/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 6734,
+        "file_size": 6286656
+      }
+    },
+    "samsum": {
+      "data/samsum/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 5504,
+        "file_size": 4114823
+      }
+    },
+    "lsht": {
+      "data/lsht/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 8056,
+        "file_size": 8145640
+      }
+    },
+    "passage_count": {
+      "data/passage_count/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 4319,
+        "file_size": 4952237
+      }
+    },
+    "passage_retrieval_en": {
+      "data/passage_retrieval_en/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 5632,
+        "file_size": 7041106
+      }
+    },
+    "passage_retrieval_zh": {
+      "data/passage_retrieval_zh/test-00000-of-00001.parquet": {
+        "num_rows": 200,
+        "num_row_groups": 1,
+        "serialized_size": 5028,
+        "file_size": 2680042
+      }
+    },
+    "lcc": {
+      "data/lcc/test-00000-of-00001.parquet": {
+        "num_rows": 500,
+        "num_row_groups": 1,
+        "serialized_size": 4408,
+        "file_size": 2350700
+      }
+    },
+    "repobench-p": {
+      "data/repobench-p/test-00000-of-00001.parquet": {
+        "num_rows": 500,
+        "num_row_groups": 1,
+        "serialized_size": 4414,
+        "file_size": 7759355
+      }
+    },
+    "qasper_e": {
+      "data/qasper_e/test-00000-of-00001.parquet": {
+        "num_rows": 224,
+        "num_row_groups": 1,
+        "serialized_size": 4584,
+        "file_size": 3315926
+      }
+    },
+    "multifieldqa_en_e": {
+      "data/multifieldqa_en_e/test-00000-of-00001.parquet": {
+        "num_rows": 150,
+        "num_row_groups": 1,
+        "serialized_size": 4856,
+        "file_size": 2176367
+      }
+    },
+    "hotpotqa_e": {
+      "data/hotpotqa_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 4502,
+        "file_size": 7180660
+      }
+    },
+    "2wikimqa_e": {
+      "data/2wikimqa_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 4454,
+        "file_size": 6801678
+      }
+    },
+    "gov_report_e": {
+      "data/gov_report_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 5548,
+        "file_size": 6656574
+      }
+    },
+    "multi_news_e": {
+      "data/multi_news_e/test-00000-of-00001.parquet": {
+        "num_rows": 294,
+        "num_row_groups": 1,
+        "serialized_size": 8297,
+        "file_size": 5849270
+      }
+    },
+    "trec_e": {
+      "data/trec_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 4504,
+        "file_size": 4858141
+      }
+    },
+    "triviaqa_e": {
+      "data/triviaqa_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 9834,
+        "file_size": 7542611
+      }
+    },
+    "samsum_e": {
+      "data/samsum_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 5646,
+        "file_size": 6085827
+      }
+    },
+    "passage_count_e": {
+      "data/passage_count_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 4323,
+        "file_size": 3812754
+      }
+    },
+    "passage_retrieval_en_e": {
+      "data/passage_retrieval_en_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 5643,
+        "file_size": 6955743
+      }
+    },
+    "lcc_e": {
+      "data/lcc_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 4379,
+        "file_size": 5520937
+      }
+    },
+    "repobench-p_e": {
+      "data/repobench-p_e/test-00000-of-00001.parquet": {
+        "num_rows": 300,
+        "num_row_groups": 1,
+        "serialized_size": 8543,
+        "file_size": 6622900
+      }
+    }
+  },
+  "total_examples": 8418
+}

data/2wikimqa/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a77249bb10da59e15b2d7ca5f192acce5f434772a74d6bef71aba395b766a70
+size 3592863

data/2wikimqa_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecdfa9dd70ae5c0b1f53f77ad00a911382c1a82bd3349c03a6de4f657fde4ee8
+size 6801678

data/dureader/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:327b76482e024f533bf5f82544073462e0ccf7ff597fa2312986c653967eacb4
+size 5170217

data/gov_report/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:076081895dba1a7357924f34690a4602ddd8a26d400f3e09b8448d03aca5369f
+size 5490476

data/gov_report_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00b296276996b3fc66291734b410543a74cb596d879ea9060ba002cdabb52e89
+size 6656574

data/hotpotqa/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fce9164f5f4d9ef52a2398e9db0cf412d52e3e426e985a4cd2896c2eddcda8f3
+size 6598795

data/hotpotqa_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19d39f6d1047fa170f21dfdf98e82d53a0c1c8814e01225567dc94f68f467e53
+size 7180660

data/lcc/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:948d3dae59811bf4a2166313c0bfa87564ac07b987d9f14d2d0d172b481e126f
+size 2350700

data/lcc_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13218e29793252ec3020ff7e6569441c05faac5c2fd11a9f3fbccfac5d369b26
+size 5520937

data/lsht/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5095e173da6204105ce0577b081c0280060f7ea05287a2f69929fc360e104ac7
+size 8145640

data/multi_news/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62438dd749d1ba3c8e2d66b7b8f7a209905dcead4eb52372da0f80c8ca188c80
+size 1495263

data/multi_news_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e9c42c801fc6be94d984582ab4760d5e2f80cee16429fbd773a3b7c98854b45
+size 5849270

data/multifieldqa_en/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0d3f986e8a6cf51c894ce47124dc01b12b6d4433e8509a5ca8938e268b5404dc
+size 2301619

data/multifieldqa_en_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a8bf2ed51a07f57e91dfe267069b9e6082ab81decaf2d77a2b105a6ab607556
+size 2176367

data/multifieldqa_zh/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d5f095f84bde485b8afae0eeeacd6cee369f9d1fb017eb905dcee6c78f5edf6
+size 1959043

data/musique/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c82f3368b7dbd295fa463c35b2d61cd9f7dd43db4b2487a71dd6d53e8bbc3f6
+size 8116451

data/narrativeqa/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0653f7e25a0b953fe5c77a2bc6da51808e5b06425f7f388912f24523538299a3
+size 12714807

data/passage_count/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5a0cdfda03b947f2452e110663ede885fb1d6b32db85f6ba60088a7662e3045
+size 4952237

data/passage_count_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97e606579c20e30a5fc6d16b4f48c621f943edf7ca365082a06e96d121d0e397
+size 3812754

data/passage_retrieval_en/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45887fb8078fdd99e29ba583ea3e43839049a2463b837beae4dd6cd2b9fb888a
+size 7041106

data/passage_retrieval_en_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6365afcb0c70f018aef3a1bdc648efec488f6d457375271f520357eeb0d69909
+size 6955743

data/passage_retrieval_zh/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e8763ad0e38ce9c3e214be4358be54e8d9171cf6dda80beb928f7da22cb7c57
+size 2680042

data/qasper/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:944e094833f07dec5ed6367d8c59e6c355ca132ace286696f4fa81e5b86e12b1
+size 2354374

data/qasper_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32d27b9ca16c9c19d20cf03598bb4461291f8a68178145459de977319491bf11
+size 3315926

data/qmsum/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f4360b18d8f50e4d97c4ba3f433d263a66e0f733e822fca127be1317d5f4210
+size 5197864

data/repobench-p/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a68ae6dc040de07166d9b1f83cb5f2b7ca07c865f2564abece04d5f10e812b3a
+size 7759355

data/repobench-p_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:108dd6b6d8e797f77db70e016159cd8b66b19fad07d1ffc1b46b85b0f3105c4b
+size 6622900

data/samsum/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c41dc8236df07c42ffd30e78694d37c4d338fb7ab839bfa6bbe4de19c75b81c0
+size 4114823

data/samsum_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e0a51086fab0ad7f9a88de1c9547da909156218cebee9442ab24e715ed5f0e6
+size 6085827

data/trec/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f1d100de4aaf5fb48e19ae6ca9f6e107234922194d0b89c97cb8894e7cd0d5eb
+size 2675373

data/trec_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b39bfa3b0d7f2e0220ab891fd9a6204acdcb6fd22be22e1294379de2d049003
+size 4858141

data/triviaqa/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52ad526858662b5a3206aba7f00e336f2eca622af7a6c788ce437baf65118f80
+size 6286656

data/triviaqa_e/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ea770117cef1dc3ede99b7d8ef3f068c77d686eb862a306aa99a77d86208492
+size 7542611

data/vcsum/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f90236ef7c12c9877f4623db56598b3f75cb0e0aace1c7c6254a839b4644f9fa
+size 5141334

dataset_infos.json

@@ -0,0 +1,2348 @@
+{
+  "narrativeqa": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "narrativeqa",
+    "config_name": "narrativeqa",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "narrativeqa"
+      }
+    }
+  },
+  "qasper": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "qasper",
+    "config_name": "qasper",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "qasper"
+      }
+    }
+  },
+  "multifieldqa_en": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "multifieldqa_en",
+    "config_name": "multifieldqa_en",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 150,
+        "dataset_name": "multifieldqa_en"
+      }
+    }
+  },
+  "multifieldqa_zh": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "multifieldqa_zh",
+    "config_name": "multifieldqa_zh",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "multifieldqa_zh"
+      }
+    }
+  },
+  "hotpotqa": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "hotpotqa",
+    "config_name": "hotpotqa",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "hotpotqa"
+      }
+    }
+  },
+  "2wikimqa": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "2wikimqa",
+    "config_name": "2wikimqa",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "2wikimqa"
+      }
+    }
+  },
+  "musique": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "musique",
+    "config_name": "musique",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "musique"
+      }
+    }
+  },
+  "dureader": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "dureader",
+    "config_name": "dureader",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "dureader"
+      }
+    }
+  },
+  "gov_report": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "gov_report",
+    "config_name": "gov_report",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "gov_report"
+      }
+    }
+  },
+  "qmsum": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "qmsum",
+    "config_name": "qmsum",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "qmsum"
+      }
+    }
+  },
+  "multi_news": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "multi_news",
+    "config_name": "multi_news",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "multi_news"
+      }
+    }
+  },
+  "vcsum": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "vcsum",
+    "config_name": "vcsum",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "vcsum"
+      }
+    }
+  },
+  "trec": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "trec",
+    "config_name": "trec",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "trec"
+      }
+    }
+  },
+  "triviaqa": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "triviaqa",
+    "config_name": "triviaqa",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "triviaqa"
+      }
+    }
+  },
+  "samsum": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "samsum",
+    "config_name": "samsum",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "samsum"
+      }
+    }
+  },
+  "lsht": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "lsht",
+    "config_name": "lsht",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "lsht"
+      }
+    }
+  },
+  "passage_count": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "passage_count",
+    "config_name": "passage_count",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "passage_count"
+      }
+    }
+  },
+  "passage_retrieval_en": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "passage_retrieval_en",
+    "config_name": "passage_retrieval_en",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "passage_retrieval_en"
+      }
+    }
+  },
+  "passage_retrieval_zh": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "passage_retrieval_zh",
+    "config_name": "passage_retrieval_zh",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 200,
+        "dataset_name": "passage_retrieval_zh"
+      }
+    }
+  },
+  "lcc": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "lcc",
+    "config_name": "lcc",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 500,
+        "dataset_name": "lcc"
+      }
+    }
+  },
+  "repobench-p": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "repobench-p",
+    "config_name": "repobench-p",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 500,
+        "dataset_name": "repobench-p"
+      }
+    }
+  },
+  "qasper_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "qasper_e",
+    "config_name": "qasper_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 224,
+        "dataset_name": "qasper_e"
+      }
+    }
+  },
+  "multifieldqa_en_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "multifieldqa_en_e",
+    "config_name": "multifieldqa_en_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 150,
+        "dataset_name": "multifieldqa_en_e"
+      }
+    }
+  },
+  "hotpotqa_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "hotpotqa_e",
+    "config_name": "hotpotqa_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "hotpotqa_e"
+      }
+    }
+  },
+  "2wikimqa_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "2wikimqa_e",
+    "config_name": "2wikimqa_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "2wikimqa_e"
+      }
+    }
+  },
+  "gov_report_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "gov_report_e",
+    "config_name": "gov_report_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "gov_report_e"
+      }
+    }
+  },
+  "multi_news_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "multi_news_e",
+    "config_name": "multi_news_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 294,
+        "dataset_name": "multi_news_e"
+      }
+    }
+  },
+  "trec_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "trec_e",
+    "config_name": "trec_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "trec_e"
+      }
+    }
+  },
+  "triviaqa_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "triviaqa_e",
+    "config_name": "triviaqa_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "triviaqa_e"
+      }
+    }
+  },
+  "samsum_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "samsum_e",
+    "config_name": "samsum_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "samsum_e"
+      }
+    }
+  },
+  "passage_count_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "passage_count_e",
+    "config_name": "passage_count_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "passage_count_e"
+      }
+    }
+  },
+  "passage_retrieval_en_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "passage_retrieval_en_e",
+    "config_name": "passage_retrieval_en_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "passage_retrieval_en_e"
+      }
+    }
+  },
+  "lcc_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "lcc_e",
+    "config_name": "lcc_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "lcc_e"
+      }
+    }
+  },
+  "repobench-p_e": {
+    "description": "LongBench is a bilingual, multitask benchmark for evaluating long-context understanding in large language models. It covers long-text application scenarios including single-document question answering, multi-document question answering, summarization, few-shot learning, synthetic long-context tasks, and code completion.\n\nThis Hugging Face dataset repository repackages locally downloaded LongBench JSONL files into a clean, typed, data-only Hugging Face dataset layout with one configuration per task. The goal of this repackaging is ease of use, reproducibility, dataset viewer compatibility, efficient loading, and convenient downstream evaluation. The dataset content, task design, and original benchmark are attributed to the LongBench authors and the THUDM LongBench project.\n",
+    "citation": "@article{bai2023longbench,\n  title={LongBench: A Bilingual, Multitask Benchmark for Long Context Understanding},\n  author={Bai, Yushi and Lv, Xin and Zhang, Jiajie and Lyu, Hongchang and Tang, Jiankai and Huang, Zhidian and Du, Zhengxiao and Liu, Xiao and Zeng, Aohan and Hou, Lei and Dong, Yuxiao and Tang, Jie and Li, Juanzi},\n  journal={arXiv preprint arXiv:2308.14508},\n  year={2023}\n}",
+    "homepage": "https://github.com/THUDM/LongBench",
+    "license": "apache-2.0",
+    "features": {
+      "input": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "context": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "answers": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "length": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "input_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "context_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "total_tokens": {
+        "dtype": "int32",
+        "_type": "Value"
+      },
+      "dataset": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "language": {
+        "dtype": "string",
+        "_type": "Value"
+      },
+      "all_classes": {
+        "feature": {
+          "dtype": "string",
+          "_type": "Value"
+        },
+        "_type": "List"
+      },
+      "_id": {
+        "dtype": "string",
+        "_type": "Value"
+      }
+    },
+    "builder_name": "parquet",
+    "dataset_name": "repobench-p_e",
+    "config_name": "repobench-p_e",
+    "version": "1.0.0",
+    "splits": {
+      "test": {
+        "name": "test",
+        "num_examples": 300,
+        "dataset_name": "repobench-p_e"
+      }
+    }
+  }
+}