Update README.md

README.md

@@ -35,15 +35,9 @@ The **QA Increasing Context Length** dataset is designed to facilitate benchmark
 
 ## 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”`)
+* **Context lengths**: 5 (`“2k”`, `“4k”`, `“8k”`, `“16k”`, `“32k”`)
 
 ### 2.1. Column Descriptions
 
@@ -72,159 +66,54 @@ Each row (example) has six columns:
 
   > **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
+## 3. Loading 
 
-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:
+If this collection has been published under a Hugging Face dataset ID (for example, `slinusc/qa_increasing_context_length`), 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")
+dataset = load_dataset("slinusc/qa_increasing_context_length")
 
-# Print a summary of splits (e.g., “train”, “validation”, etc.)
+# Print overall structure and splits
 print(dataset)
 
-# Inspect column names
+# Inspect column names in the “train” split
 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
+By default, the single CSV is assigned a “train” split. You can then filter or sample by `context_range`:
 
 ```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
+# Example: count examples per bucket
 from collections import Counter
-counts = Counter(ds["train"]["context_range"])
+counts = Counter(dataset["train"]["context_range"])
 print(counts)  # e.g., {'2k': 100, '4k': 100, '8k': 100, '16k': 100, '32k': 100}
+
+# Filter to only 16k‐token contexts
+ds_16k = dataset["train"].filter(lambda x: x["context_range"] == "16k")
+print(len(ds_16k))
 ```
 
-### 3.3. Loading Directly with pandas
+If you have downloaded `longbench_all_buckets_100.csv` locally, you can also load it via:
 
 ```python
-import pandas as pd
-
-df = pd.read_csv("longbench_all_buckets_100.csv")
-
-# View the first few rows
-df.head()
+from datasets import load_dataset
 
-# 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"
-# ...
+dataset = load_dataset("csv", data_files="longbench_all_buckets_100.csv")
+print(dataset["train"].column_names)
 ```
 
-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("---")
-  ```
+After loading, each row will expose the fields:
 
----
-
-## 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.
+```
+["context", "question", "answer", "length", "dataset", "context_range"]
+```
 
----
 
-## 5. Citation & License
+## 4. 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.