Duplicate from nvidia/SPEED-Bench

Co-authored-by: Maor Ashkenazi <maorashnvidia@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow 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,394 @@
+---
+license: other
+license_name: nvidia-evaluation-dataset-license
+dataset_info:
+- config_name: qualitative
+  features:
+  - name: question_id
+    dtype: string
+  - name: category
+    dtype: string
+  - name: sub_category
+    dtype: string
+  - name: turns
+    list: string
+  - name: source
+    dtype: string
+  - name: src_id
+    dtype: string
+  - name: difficulty
+    dtype: string
+  - name: multiturn
+    dtype: bool
+  splits:
+  - name: test
+    num_bytes: 909126
+    num_examples: 880
+  download_size: 364138
+  dataset_size: 909126
+- config_name: throughput_16k
+  features:
+  - name: question_id
+    dtype: string
+  - name: category
+    dtype: string
+  - name: sub_category
+    dtype: string
+  - name: turns
+    list: string
+  - name: source
+    dtype: string
+  - name: src_id
+    dtype: string
+  - name: difficulty
+    dtype: string
+  - name: multiturn
+    dtype: bool
+  splits:
+  - name: test
+    num_bytes: 53496289
+    num_examples: 1536
+  download_size: 25523756
+  dataset_size: 53496289
+- config_name: throughput_1k
+  features:
+  - name: question_id
+    dtype: string
+  - name: category
+    dtype: string
+  - name: sub_category
+    dtype: string
+  - name: turns
+    list: string
+  - name: source
+    dtype: string
+  - name: src_id
+    dtype: string
+  - name: difficulty
+    dtype: string
+  - name: multiturn
+    dtype: bool
+  splits:
+  - name: test
+    num_bytes: 4212842
+    num_examples: 1536
+  download_size: 1952802
+  dataset_size: 4212842
+- config_name: throughput_2k
+  features:
+  - name: question_id
+    dtype: string
+  - name: category
+    dtype: string
+  - name: sub_category
+    dtype: string
+  - name: turns
+    list: string
+  - name: source
+    dtype: string
+  - name: src_id
+    dtype: string
+  - name: difficulty
+    dtype: string
+  - name: multiturn
+    dtype: bool
+  splits:
+  - name: test
+    num_bytes: 8151334
+    num_examples: 1536
+  download_size: 3713378
+  dataset_size: 8151334
+- config_name: throughput_32k
+  features:
+  - name: question_id
+    dtype: string
+  - name: category
+    dtype: string
+  - name: sub_category
+    dtype: string
+  - name: turns
+    list: string
+  - name: source
+    dtype: string
+  - name: src_id
+    dtype: string
+  - name: difficulty
+    dtype: string
+  - name: multiturn
+    dtype: bool
+  splits:
+  - name: test
+    num_bytes: 110525325
+    num_examples: 1536
+  download_size: 52281772
+  dataset_size: 110525325
+- config_name: throughput_8k
+  features:
+  - name: question_id
+    dtype: string
+  - name: category
+    dtype: string
+  - name: sub_category
+    dtype: string
+  - name: turns
+    list: string
+  - name: source
+    dtype: string
+  - name: src_id
+    dtype: string
+  - name: difficulty
+    dtype: string
+  - name: multiturn
+    dtype: bool
+  splits:
+  - name: test
+    num_bytes: 27768504
+    num_examples: 1536
+  download_size: 12959248
+  dataset_size: 27768504
+configs:
+- config_name: qualitative
+  data_files:
+  - split: test
+    path: qualitative/test-*
+- config_name: throughput_16k
+  data_files:
+  - split: test
+    path: throughput_16k/test-*
+- config_name: throughput_1k
+  data_files:
+  - split: test
+    path: throughput_1k/test-*
+- config_name: throughput_2k
+  data_files:
+  - split: test
+    path: throughput_2k/test-*
+- config_name: throughput_32k
+  data_files:
+  - split: test
+    path: throughput_32k/test-*
+- config_name: throughput_8k
+  data_files:
+  - split: test
+    path: throughput_8k/test-*
+---
+
+<div align="center">
+  <img alt="SpeedBench" src="./assets/speed_bench_logo.png" width="450" />
+</div>
+<p align="center">
+  <a href="">📒 Blog</a> |
+  <a href="https://research.nvidia.com/publication/2026-02_speed-bench-unified-and-diverse-benchmark-speculative-decoding">📄 Paper</a> |
+  <a href="https://huggingface.co/datasets/nvidia/SPEED-Bench">🤗 Data</a> |
+  <a href="https://github.com/NVIDIA/Model-Optimizer/tree/main/examples/specdec_bench">⚙️ Measurement Framework</a>
+</p>
+
+
+SPEED-Bench (**SPE**culative **E**valuation **D**ataset) is a unified benchmark designed to evaluate speculative decoding (SD) across diverse semantic domains and realistic serving regimes, using production-grade inference engines.
+It measures both acceptance-rate characteristics and end-to-end throughput, enabling fair, reproducible, and robust comparisons between SD strategies. 
+SPEED-Bench introduces a benchmarking ecosystem for SD.
+It combines two purpose-built dataset splits and a unified measurement framework, each designed to capture a different aspect of SD behavior:
+
+1. A **"Qualitative" data split**, optimized for semantic diversity and designed to measure speculation quality (drafter accuracy) across domains.
+
+2. **A "Throughput" data split**, constructed to evaluate system-level performance across various input sequence lengths and high concurrency.
+
+3. A [**unified measurement framework**](https://github.com/NVIDIA/Model-Optimizer/tree/main/examples/specdec_bench), integrated with production inference engines, that standardizes evaluation across systems.
+
+<img src="./assets/main_figure.png" alt="Main figure" width="1000"/>
+
+
+## Dataset Details
+
+### Dataset Description
+
+SPEED-Bench is a unified benchmark designed to standardize and improve the evaluation of SD algorithms. 
+
+[SpecBench](https://arxiv.org/pdf/2401.07851) introduced the first unified SD benchmark across diverse application scenarios, such as multi-turn conversation, translation, and mathematical reasoning, by aggregating instances from widely used datasets into a unified testing environment. However, despite being a significant step toward standardized evaluations, it has critical limitations regarding scale and diversity. Most categories contain as few as 10 samples with short mean input lengths (< 100 tokens) that may fail to stress modern drafters. Additionally, some of its categories often lack structural diversity, such as the multilingual category consisting entirely of German-to-English translation prompts.
+
+Our benchmark introduces two main dataset configurations:
+
+1. A **Qualitative data split**: This configuration combines and refines multiple existing benchmarks, covering categories similar to the original SpecBench. We aggregate data from 18 publicly available sources and organize it into 11 categories, including *Coding*, *Math*, *Humanities*, *STEM*, *Writing*, *Summarization*, *Roleplay*, *RAG*, *Multilingual*, *Reasoning*, and *QA*. Unlike prior benchmarks, which often suffer from low intra-category diversity, the SPEED-Bench Qualitative split explicitly prioritizes semantic diversity. It is designed to evaluate acceptance rates and overall performance of SD algorithms across different task domains.
+
+2. A **Throughput data split**: This configuration consists of fixed-length input sequences (1K, 2K, 8K, 16K and 32K) organized into three coarse difficulty categories: low-entropy domains (such as coding), high-entropy domains (such as creative writing), and mixed-entropy domains. The goal is to assess throughput under high concurrency and a wide range of input sequence lengths (ISLs), which are often much longer than the short ISL samples used in many SD benchmarks. As batch size increases, inference often transitions from a compute-bound regime to a memory-bound regime, fundamentally changing the cost-benefit trade-offs of speculative decoding.
+
+
+| ⚠️ **Important:** Some examples in the dataset are masked with the sentence "FULL BENCHMARK DATA SHOULD BE FETCHED FROM THE SOURCE USING SPECDEC_BENCH". To access the complete benchmark data, use the accompanying measurement framework, which fetches the full data directly from the sources.   |
+|----------------------------------------------|
+
+## Dataset Structure
+
+Each data point contains the following fields:
+
+1. `question_id` - unique identifier of the data point in SPEED-Bench.
+2. `category` - data point category
+    1. For qualitative can be one of: coding, stem, humanities, math, multilingual, qa, rag, roleplay, reasoning, summarization, writing.
+    2. For throughput can be one of: high_entropy, mixed, low_entropy.
+3. `sub_category` - a fine-grained category of the data point, if provided by the original data source.
+4. `turns` - a list of prompts, used to form the conversation.
+5. `source` - URL for the original data source.
+6. `src_id` - original ID of the example in the data source.
+7. `difficulty` - the difficuly level of the example, if provided by the original data source.
+8. `multiturn` - a boolean field to indicate whether the data point contain a multi-turn conversation (i.e. `len(turns) > 1`).
+
+## Dataset Creation
+
+### Curation Rationale - The Qualitative Split
+
+The goal of the Qualitative split is to measure SD quality, specifically conditional acceptance rates (ARs) and acceptance lengths (ALs), across a wide range of semantic domains.
+
+While extensive evaluation across numerous datasets is theoretically possible, it is tedious, impractical for rapid experimentation, and hinders direct comparisons between different research groups releasing SD algorithms and models. Instead of relying on exhaustive evaluations across disparate datasets, we curate a compact yet highly representative subset designed to maximize semantic diversity.
+We aggregate data from 18 publicly available sources and organize it into 11 categories, including Coding, Math, Humanities, STEM, Writing, Summarization, Roleplay, RAG, Multilingual, Reasoning, and QA.
+
+Unlike prior benchmarks, which often suffer from low intra-category diversity, the SPEED-Bench Qualitative split explicitly prioritizes semantic diversity.
+To achieve this, each candidate prompt is embedded into a dense vector space using a pretrained text embedder (`openai/text-embedding-3-small`).  
+We then apply a selection algorithm that minimizes average pairwise cosine similarity within each category.  
+This ensures that the selected samples span the semantic space as widely as possible, reducing redundancy and increasing evaluation fidelity.
+
+##### Sampling Algorithm
+
+For each category, our goal is to select a subset of 80 examples that maximizes semantic diversity. 
+The motivation is to produce more reliable acceptance rate measurements for speculative decoding algorithms across varied inputs.
+
+Procedure:
+
+1. Embedding computation: We compute embeddings for all examples in the category using the OpenAI `text-embedding-3-small` model.
+2. Greedy selection: Starting from a random example, we iteratively select examples that minimize semantic similarity with the already chosen subset, until reaching 80 examples.
+3. Subset optimization: After the initial selection, we perform swaps between selected and unselected examples to further reduce similarity and enhance semantic diversity.
+
+The table below shows the average semantic similarity of SpecBench examples compared to SPEED-Bench subsets selected using random selection and the greedy selection (as described in the sampling algorithm above).
+All values were computed using cosine similarity on embeddings generated with the OpenAI `text-embedding-3-small` model.
+
+Lower values indicate better semantic diversity. The numbers in parentheses show the relative change compared to SpecBench.
+
+| Category       | SpecBench | SPEED (random selection) | SPEED (greedy algorithm)   |
+|----------------|-----------|----------------------|------------------------|
+| Math           | 0.24      | 0.21 (-12.5%)        | 0.15 (-37.5%)          |
+| Coding         | 0.33      | 0.48 (+45%)           | 0.16 (-51%)             |
+| Multilingual   | 0.36      | 0.18 (-50%)           | 0.06 (-83%)             |
+| Writing        | 0.35      | 0.29 (-17%)           | 0.18 (-48%)             |
+| Humanities     | 0.26      | 0.14 (-46%)           | 0.12 (-54%)             |
+| STEM           | 0.24      | 0.19 (-21%)           | 0.12 (-50%)             |
+| Reasoning      | 0.24      | 0.21 (-12.5%)         | 0.14 (-41%)             |
+| RAG            | 0.15      | 0.17 (+13%)           | 0.13 (-13%)             |
+| Roleplay       | 0.28      | 0.25 (-11%)           | 0.24 (-14%)             |
+| Summarization  | 0.21      | 0.24 (+14%)           | 0.11 (-48%)             |
+| QA             | 0.10      | unchanged samples     | unchanged samples       |
+
+
+### Curation Rationale - The Throughput Split
+
+While the Qualitative split captures draft accuracy, it is insufficient for evaluating system-level speedups.
+The Throughput split is designed specifically to capture this.
+
+We construct fixed ISL buckets ranging from 1k to 32k tokens, reflecting the growing importance of long-context applications such as coding assistants and retrieval-augmented generation.  
+For each ISL bucket, prompts are aggregated into three coarse difficulty categories corresponding to low-, mixed-, and high-entropy domains.
+To ensure deterministic prefill cost, prompts are either truncated or padded in a controlled manner, while preserving their semantic content.
+
+Each ISL bucket contains 1,536 prompts (512 per difficulty category), providing sufficient volume to construct stable throughput Pareto curves across a wide range of batch sizes.
+
+Importantly, SPEED-Bench avoids the use of random token inputs for throughput benchmarking. Random tokens can severely distort acceptance behavior, expert routing in MoE models, and throughput measurements, leading to overly optimistic conclusions.
+
+
+### Data Sources
+
+We use the following data sources in our benchmark:
+
+| Data Source             | Categories                                          | Construction Details                         |
+|-------------------------|-----------------------------------------------------|-----------------------------------------------|
+| [SpecBench](https://github.com/hemingkx/Spec-Bench)               | STEM, Humanities, Writing, Coding, Math, Roleplay, Reasoning, QA, RAG | Used directly from source |
+| [CNN/Daily Mail](https://huggingface.co/datasets/abisee/cnn_dailymail) | Summarization                                   | Used articles directly from source with instructions to summarize the content.|
+| [Humanity's Last Exam](https://huggingface.co/datasets/cais/hle)    | STEM, Humanities, Math   |  Filtered to text-only samples (no images) with exact-match answer type. For STEM: filtered to Physics, CS/AI, Biology/Medicine, Chemistry, Engineering. For Humanities: filtered to Humanities/Social Science category. |
+| [LiveCodeBench Lite](https://huggingface.co/datasets/livecodebench/code_generation_lite)      | Coding                                              | Constructed instruction prompts requesting code generation in a randomly selected programming language (Python, Java, C++, Go, JavaScript, Rust). Includes starter code when available. |
+| [Code Contests](https://huggingface.co/datasets/deepmind/code_contests)                       | Coding                                              | Constructed instruction prompts requesting program generation in a randomly selected language (Python, Java, C++). Problem descriptions used directly from source. |
+| [HumanEvalPack](https://huggingface.co/datasets/bigcode/humanevalpack)                        | Coding                                              | Used code completion prompts directly from source. |
+| [RoleBench](https://huggingface.co/datasets/ZenMoore/RoleBench)               | Roleplay                                            | Constructed multi-turn roleplay prompts using role descriptions and questions. Questions grouped by role into conversations (1--5 turns). System prompts randomly sampled from 8 prompt templates instructing the model to embody the character. |
+| [CoSER](https://huggingface.co/datasets/Neph0s/CoSER)               | Roleplay                                            | Constructed roleplay prompts with character profiles, scenario, and character motivation, only for books that are available in the public domain. |
+| [WritingBench](https://github.com/X-PLUG/WritingBench)            | Writing                                             | Filtered to English samples. Writing queries used directly as single-turn prompts. |
+| [Creative Writing V3](https://github.com/EQ-bench/creative-writing-bench)     | Writing                                             | Expanded prompts by replacing `<SEED>` placeholders with the seed modifiers provided, creating multiple variations per base prompt. |
+| [MT-Bench 101](https://github.com/mtbench101/mt-bench-101)            | Reasoning                                           | Filtered to general reasoning and mathematical reasoning tasks. |
+| [MMLU-Pro](https://huggingface.co/datasets/TIGER-Lab/MMLU-Pro)                | Reasoning                                           | Grouped questions by category and combined multiple questions together to create multi-turn samples. |
+| [MMATH](https://github.com/RUCAIBox/MMATH/tree/main)                   | Multilingual                                       |   Questions used directly from source. | 
+| [OPUS-100](https://huggingface.co/datasets/Helsinki-NLP/opus-100)                | Multilingual                                       | Constructed translation prompts by prepending "Translate the following text from [source language] to [target language]:".  |
+| [MCIF](https://huggingface.co/datasets/FBK-MT/MCIF)                    | Multilingual                                  | Selected prompts for QA, translation, and summarization tasks with *long_mixed-prompt* format. |
+| [ChatRAG-Bench](https://huggingface.co/datasets/nvidia/ChatRAG-Bench)           | RAG                                                 | Constructed prompts with context (concatenated retrieved passages) and multi-turn questions for the *hybridial* and *sqa* splits. |
+| [MCIF](https://huggingface.co/datasets/FBK-MT/MCIF)                    | RAG                                  | SUsed English QA prompts with *long_mixed-prompt* format, grouping questions by document into multi-turn conversations. |
+| [BAMBOO](https://github.com/RUCAIBox/BAMBOO/tree/main)                  | Throughput split (writing - high entropy)          | Used MeetingPred and ShowsPred subsets. Constructed dialogue completion prompts asking the model to continue conversations. For longer contexts (>16k tokens), concatenated multiple dialogues. Padded/truncated to target token count. |
+| [Project Gutenberg](https://www.gutenberg.org/)                  | Throughput split (writing - high entropy)          | Constructed book continuation prompts. Filtered to books with sufficient length and padded/truncated to target token count. |
+| [WritingBench](https://github.com/X-PLUG/WritingBench)            | Throughput split (writing - high entropy)                                             | Reused English writing prompts from Qualitative Split. Filtered to prompts within 0.7--2x target token count, then padded/truncated. |
+| [AdaLEval (StackSelect)](https://github.com/open-compass/Ada-LEval)                | Throughput split (NIAH - mixed) | Constructed needle-in-a-haystack prompts asking models to select the most helpful answer from a set of StackOverflow answers and provide explanations for each choice. Padded/truncated to target token count. |
+| [Humanity's Last Exam](https://huggingface.co/datasets/cais/hle)    | Throughput split (mixed)   |  Used 50% of HLE data for few-shot prompting. Constructed prompts with category-specific demonstrations sampled from held-out examples, followed by the target question. Padded/truncated to target token count. |
+| [Long Code Arena](https://huggingface.co/spaces/JetBrains-Research/long-code-arena)         | Throughput split (coding - low entropy)            |  Used project-level code completion subset. Constructed prompts with repository context and file with `[COMPLETE]` markers for line-level completion.  |
+| [RepoBench Python](https://huggingface.co/datasets/tianyang/repobench_python_v1.1)     | Throughput split (coding - low entropy)            | Constructed cross-file code completion prompts with repository context snippets and in-file code. Padded/truncated to target token count. |
+| [RepoBench Java](https://huggingface.co/datasets/tianyang/repobench_java_v1.1)         | Throughput split (coding - low entropy)            | Same construction as RepoBench Python but for Java code. |
+| [AdaLEval (TextSort)](https://github.com/open-compass/Ada-LEval)                | Throughput split (sorting - low entropy) | Modified original sorting task to require outputting sorted text segments in order rather than just returning indices. Padded/truncated to target token count. |
+
+
+
+## Detailed Data Comparison with SpecBench
+
+
+| Metric | **SPEED-Bench** | **SpecBench** |
+| :--- | :--- | :--- |
+| # Samples per Category | 80 (qualitative), 512 x 3 (throughput) | 10 (for 8 categories), 80 (the rest) |
+| # Total Samples | 880 (qualitative), 1536 x 5 (throughput) | 480 |
+| # Data Sources | 24 | 5 |
+| Avg. Pairwise Similarity | 0.14 | 0.22 |
+| # Multiturn Prompts | 167 | 80 |
+| Max # Turns | 5 | 2 |
+| Subcategories | ✅ | ❌ |
+| Difficulties | ✅ (for *Math*, *STEM*, *Humanities*, *Coding*) | ❌ |
+| Long ISLs (16k-32k) | ✅ | ❌ |
+| Large batches of fixed-size ISLs | ✅ | ❌ |
+| Programming Languages Explicitly Mentioned in *Coding* | Python (27), CPP (9), Java (10), Go (13), Javascript (11), Rust (3), HTML (1), CSS (1) | Python (3), CPP (1), HTML (1), CSS (1) |
+| # Distinct Languages in *Multilingual* | 23 | 2 |
+| Languages in *Multilingual* | EN, DE, ZH, IT, MG, FR, JA, PT, AR, MK, DA, NL, KO, ES, NN, TH, VI, BN, GU, CS, GD, EU, RU | EN, DE |
+| Difficulty level in *Math*, *Humanities* and *STEM* categories | Academic level | High school level |
+
+
+### Examples of similarity matrix between SpecBench and SPEED-Bench for two categories (lower values are better):
+<img src="./assets/similarity_multilingual.png" alt="Semantic similarity between translation and multilingual examples (lower is better)" width="1000"/>
+
+<img src="./assets/similarity_math.png" alt="Semantic similarity between math examples (lower is better)" width=1000/>
+
+
+## Dataset Owner(s):
+NVIDIA Corporation
+
+## Dataset Creation Date:
+February 2026
+
+## License/Terms of Use: 
+GOVERNING TERMS: This dataset is governed by the [NVIDIA Evaluation Dataset License Agreement](License.pdf). 
+
+ADDITIONAL INFORMATION: MIT for bigcode/humanevalpack, RUCAIBox/MMATH, RUCAIBox/BAMBOO and EQ-Bench. Apache 2.0 for Writing Bench and Spec-Bench. CC BY 4.0 for FBK-MT/MCIF. MIT and Apache 2.0 for tianyang/repobench_python_v1.1, JetBrains-Research/lca-project-level-code-completion and tianyang/repobench_java_v1.1.
+
+NOTICE: The `prepare_data.py` script which is part of the measurement framework hosted in [nvidia/Model-Optimizer GitHub repository](https://github.com/NVIDIA/Model-Optimizer/tree/main/examples/specdec_bench) automatically fetches and constructs the data from all the source datasets. For each dataset a user elects to use, the user is responsible for checking if the dataset license is fit for the intended purpose.
+
+## Intended Usage:
+This dataset is designed for LLM engineers and researchers working on evaluating Speculative Decoding (SD) and LLM Inference latency measurements.
+
+## Dataset Format
+The dataset is distributed in parquet format with a hybrid delivery mechanism to ensure license compliance.
+
+Distribution Structure:
+* Part of the samples are directly stored in the parquet files.
+* Part of the samples contain a placeholder notice, and a reference to a data source. We provide a dataset building script that fetches data directly from the original host locations. By using the script, the user acknowledges that they are downloading data from third parties and assume responsibility for adhering to their specific license terms.
+
+## Dataset Quantification
+- Record Count: 880 samples in the qualitative split, 1538 samples in the throughput split.
+- Measurement of Total Data Storage ~95MB
+
+## Reference(s):
+Paper: https://research.nvidia.com/publication/2026-02_speed-bench-unified-and-diverse-benchmark-speculative-decoding .
+
+
+## Ethical Considerations:
+NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications.  When downloaded or used in accordance with our terms of service, developers should work with their internal team to ensure this dataset meets requirements for the relevant industry and use case and addresses unforeseen product misuse.   
+Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/). 
+
+## Dataset Card Contact
+
+Talor Abramovich - talora@nvidia.com
+
+Maor Ashkenazi - mashkenazi@nvidia.com

qualitative/test-00000-of-00001.parquet

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

throughput_16k/test-00000-of-00001.parquet

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

throughput_1k/test-00000-of-00001.parquet

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

throughput_2k/test-00000-of-00001.parquet

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

throughput_32k/test-00000-of-00001.parquet

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

throughput_8k/test-00000-of-00001.parquet

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