Update README.md

README.md

@@ -11,13 +11,220 @@ tags:
 size_categories:
 - 1K<n<10K
 ---
-# QA Increasing Context Length
-
-This dataset contains a single CSV (`longbench_all_buckets_100.csv`) with QA examples
-bucketed by context length (2k, 4k, 8k, 16k, 32k). Each row has:
-- `context`
-- `question`
-- `answer`
-- `length` (token count)
-- `dataset` (LongBench subset)
-- `context_range` (2k/4k/8k/16k/32k)
+Below is a structured, professional‐tone description of the “QA Increasing Context Length” dataset. You can use this text as a README, a data card, or incorporate it directly into documentation.
+
+---
+
+# QA Increasing Context Length Dataset
+
+## 1. Overview
+
+The **QA Increasing Context Length** dataset is designed to facilitate benchmarking and research on question‐answering (QA) systems as the size of the input context grows. It compiles QA examples drawn from multiple LongBench subsets, each bucketed by ascending context length (measured in tokens). Researchers can use this dataset to evaluate how modern language models and retrieval‐augmented systems handle progressively larger contexts (from 2 K tokens up to 32 K tokens) in terms of accuracy, latency, memory usage, and robustness.
+
+* **Intended purpose**
+
+  * To measure QA performance (e.g., exact match, F1) under different context‐length regimes.
+  * To assess inference latency, throughput, and resource utilization when models process long documents.
+  * To compare retrieval strategies or memory‐efficient attention mechanisms as context size increases.
+
+* **Key features**
+
+  1. A single CSV (`longbench_all_buckets_100.csv`) containing examples from five context‐length buckets: **2 K**, **4 K**, **8 K**, **16 K**, and **32 K** tokens.
+  2. Each row includes a complete (potentially multi‐paragraph) passage, a target question, and its ground‐truth answer, along with metadata fields that facilitate grouping, filtering, or statistical analysis.
+  3. Examples are drawn from diverse domains (scientific articles, technical reports, web pages, etc.), as indicated by the `dataset` field.
+
+## 2. Dataset Structure
+
+The dataset is provided as one CSV file:
+
+```
+longbench_all_buckets_100.csv
+```
+
+* **File format**: Comma‐separated values (UTF-8 encoded)
+* **Number of rows**: Varies by bucket (typically 100 examples per bucket)
+* **Total buckets**: 5 (`“2k”`, `“4k”`, `“8k”`, `“16k”`, `“32k”`)
+
+### 2.1. Column Descriptions
+
+Each row (example) has six columns:
+
+| Column Name        | Type     | Description                                                                                                |
+| ------------------ | -------- | ---------------------------------------------------------------------------------------------------------- |
+| **context**        | `string` | A (long) text passage whose token count falls into one of the predefined buckets (2 K – 32 K).             |
+| **question**       | `string` | A natural‐language question referring to information contained in `context`.                               |
+| **answer**         | `string` | The ground‐truth answer (text span or summary) extracted from the context.                                 |
+| **length**         | `int`    | The exact token count of the `context` (as measured by a standard tokenizer, e.g., T5/BPE).                |
+| **dataset**        | `string` | The original LongBench subset (e.g., “scitldr”, “arxiv”, “pubmed”, etc.) from which the example was drawn. |
+| **context\_range** | `string` | One of `"2k"`, `"4k"`, `"8k"`, `"16k"`, or `"32k"`. Indicates the bucket into which `length` falls.        |
+
+* **Context buckets (`context_range`)**
+
+  * `"2k"`:  1 500 – 2 499 tokens (approximate; exact boundaries may vary)
+
+  * `"4k"`:  3 000 – 4 999 tokens
+
+  * `"8k"`:  6 000 – 9 999 tokens
+
+  * `"16k"`: 12 000 – 17 999 tokens
+
+  * `"32k"`: 24 000 – 34 999 tokens
+
+  > **Note**: The buckets are chosen to stress‐test long‐context inference. The exact cutoff may be implementation‐dependent, but each row’s `length` field indicates the precise token count.
+
+## 3. Usage Examples
+
+Below are common ways to load and inspect the dataset, either via Hugging Face DL Hub or using the local CSV directly.
+
+### 3.1. Loading with Hugging Face Datasets
+
+If the dataset has been published under a dataset ID (for example, `username/longbench-qa-increasing-context`), you can load it directly:
+
+```python
+from datasets import load_dataset
+
+# Replace with the actual HF dataset ID if different
+dataset = load_dataset("username/longbench-qa-increasing-context")
+
+# Print a summary of splits (e.g., “train”, “validation”, etc.)
+print(dataset)
+
+# Inspect column names
+print(dataset["train"].column_names)
+```
+
+Internally, you will see:
+
+```
+DatasetDict({
+    train: Dataset({
+        features: ['context', 'question', 'answer', 'length', 'dataset', 'context_range'],
+        num_rows: <total_rows>
+    })
+})
+```
+
+### 3.2. Loading from Local CSV via Hugging Face Datasets
+
+```python
+from datasets import load_dataset
+
+# If you already have the CSV file in the current directory:
+data_files = "longbench_all_buckets_100.csv"
+ds = load_dataset("csv", data_files=data_files)
+
+# The library assigns the single split name “train” by default:
+print(ds)  # {"train": Dataset}
+print(ds["train"].column_names)
+```
+
+```python
+# Example: count number of examples per context_range
+from collections import Counter
+counts = Counter(ds["train"]["context_range"])
+print(counts)  # e.g., {'2k': 100, '4k': 100, '8k': 100, '16k': 100, '32k': 100}
+```
+
+### 3.3. Loading Directly with pandas
+
+```python
+import pandas as pd
+
+df = pd.read_csv("longbench_all_buckets_100.csv")
+
+# View the first few rows
+df.head()
+
+# Output:
+#   context_range  length   dataset                     context        question    answer
+# 0           2k    1985   scitldr   "Long scientific abstract…"   "What is the title?"  "X Study"
+# 1           2k    2021   pubmed    "Biomedical paper text…"     "What did authors find?"  "Y"
+# 2           4k    3812   arxiv     "An arXiv article excerpt…" "Which method used?"    "Method Z"
+# ...
+```
+
+Once loaded, you can:
+
+* **Filter** a specific bucket:
+
+  ```python
+  df_16k = df[df["context_range"] == "16k"]
+  ```
+* **Compute statistics**:
+
+  ```python
+  df.groupby("context_range")["length"].describe()
+  ```
+* **Inspect sample contexts**:
+
+  ```python
+  for bucket in ["2k","4k","8k","16k","32k"]:
+      sample = df[df["context_range"] == bucket].sample(1).iloc[0]
+      print(f"Bucket: {bucket}")
+      print("Length:", sample["length"])
+      print("Question:", sample["question"])
+      print("Answer:", sample["answer"])
+      print("---")
+  ```
+
+---
+
+## 4. Potential Applications
+
+1. **Long-Context QA Benchmarking**
+
+   * Evaluate how QA accuracy (Exact Match, F1 score) degrades or holds steady as context length increases from 2K to 32K tokens.
+   * Compare performance across different model architectures (e.g., transformer‐based models with full attention vs. sparse or windowed attention).
+
+2. **Latency & Memory Profiling**
+
+   * Measure inference time (e.g., time-to-first-token, throughput) as a function of `length`.
+   * Monitor GPU/CPU memory usage and peak consumption for each bucket, especially for engines that implement paged KV-cache or offloading to CPU.
+
+3. **Retrieval and Reranking Research**
+
+   * Use “dataset” metadata to explore domain‐specific retrieval strategies (e.g., scientific vs. biomedical abstracts).
+   * Investigate how downstream QA accuracy changes when retrieving increasingly large context chunks.
+
+4. **Failure Mode Analysis**
+
+   * Characterize the types of questions that become “unanswerable” when the context is extremely large (32 K tokens).
+   * Analyze error patterns (e.g., where the gold answer appears near the beginning vs. the end of a long document).
+
+5. **Adaptive Context Truncation / Compression**
+
+   * Develop algorithms that select only the most relevant 2 K–4 K tokens from a 32 K‐token context to maintain accuracy while reducing inference cost.
+   * Evaluate how aggressive summarization or chunking influences QA performance.
+
+---
+
+## 5. Citation & License
+
+* If you plan to publish results using this dataset, please refer to the original LongBench publication (LongBench: A Bedrock-Level Benchmark for Foundation Models) and cite the specific subset(s) from which examples were drawn.
+* Check the Hugging Face hub (dataset card) for detailed licensing information. Typically, LongBench subsets carry permissive licenses for research use, but always verify at [https://huggingface.co/datasets/…](https://huggingface.co/datasets/…) before redistribution.
+
+---
+
+## 6. Contact & Repository
+
+* **Hugging Face dataset page**:
+  [https://huggingface.co/datasets/USERNAME/longbench-qa-increasing-context](https://huggingface.co/datasets/USERNAME/longbench-qa-increasing-context)
+  (Replace `USERNAME` with the dataset owner’s name.)
+
+* **GitHub/Source code**:
+  If there is a linked GitHub repo or script for generating this CSV, include its URL here.
+  Example:
+
+  ```
+  https://github.com/longbench/longbench-qa
+  ```
+
+* **Maintainers**:
+
+  * [Name 1](mailto:email1@institute.edu)
+  * [Name 2](mailto:email2@institute.edu)
+
+---
+
+**Summary:**
+The **QA Increasing Context Length** dataset is a single CSV of QA examples bucketed into five context‐length tiers (2 K–32 K tokens). Each record contains the full passage (`context`), a `question`, its `answer`, plus metadata fields (`length`, `dataset`, `context_range`). Researchers can seamlessly load it with Hugging Face `datasets` or pandas and apply it to study model behavior under very long contexts—ranging from accuracy trends to hardware profiling and retrieval strategies.