Update dataset card

README.md

@@ -1,33 +1,273 @@
 ---
-dataset_info:
-  features:
-  - name: commit_hash
-    dtype: string
-  - name: pr_url
-    dtype: string
-  - name: has_lm_eval
-    dtype: bool
-  - name: has_performance
-    dtype: bool
-  - name: has_serving
-    dtype: bool
-  - name: has_general_test
-    dtype: bool
-  - name: test_details
-    dtype: string
-  - name: timeline_text
-    dtype: string
-  - name: extracted_at
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 2366151
-    num_examples: 99
-  download_size: 744933
-  dataset_size: 2366151
+license: mit
+task_categories:
+- text-classification
+- feature-extraction
+language:
+- en
+tags:
+- software-engineering
+- testing
+- performance
+- llm-serving
+- vllm
+- benchmarking
+- ml-evaluation
+pretty_name: vLLM PR Test Classification
+size_categories:
+- n<1K
 configs:
 - config_name: default
   data_files:
   - split: train
-    path: data/train-*
+    path: data/*
 ---
+
+# vLLM PR Test Classification Dataset
+
+## 🎯 Overview
+
+This dataset contains **98 vLLM project commits** with their corresponding Pull Request (PR) timeline data and comprehensive test type classifications. It provides insights into testing patterns in a major LLM serving infrastructure project.
+
+## 📊 Dataset Description
+
+### Purpose
+This dataset was created by analyzing vLLM project PR timelines to:
+- Identify different types of testing and benchmarking activities
+- Understand testing patterns in LLM infrastructure development
+- Provide labeled data for ML models to classify test types in software PRs
+- Enable research on performance optimization trends in LLM serving
+
+### Test Categories
+
+Each commit is classified across four test categories:
+
+| Category | Description | Keywords | Prevalence |
+|----------|-------------|----------|------------|
+| **LM Evaluation** | Language model evaluation tests | `lm_eval`, `gsm8k`, `mmlu`, `hellaswag`, `truthfulqa` | 25.5% |
+| **Performance** | Performance benchmarking tests | `TTFT`, `throughput`, `latency`, `ITL`, `TPOT`, `tok/s` | 81.6% |
+| **Serving** | Serving functionality tests | `vllm serve`, `API server`, `frontend`, `online serving` | 53.1% |
+| **General Test** | General testing activities | `CI`, `pytest`, `unittest`, `buildkite`, `fastcheck` | 96.9% |
+
+## 📈 Dataset Statistics
+
+### Overall Distribution
+- **Total commits**: 98
+- **Multi-category commits**: 76 (77.6%)
+- **Average test types per commit**: 2.57
+
+### Detailed Keyword Frequency
+
+#### Top Performance Keywords (80 commits)
+- `throughput`: 241 mentions
+- `latency`: 191 mentions
+- `profiling`: 114 mentions
+- `TTFT` (Time To First Token): 114 mentions
+- `ITL` (Inter-token Latency): 114 mentions
+- `TPOT` (Time Per Output Token): 108 mentions
+- `optimization`: 87 mentions
+- `tok/s` (tokens per second): 66 mentions
+
+#### Top LM Evaluation Keywords (25 commits)
+- `gsm8k`: 62 mentions
+- `lm_eval`: 33 mentions
+- `lm-eval`: 9 mentions
+- `mmlu`: 3 mentions
+- `humaneval`: 1 mention
+
+#### Top Serving Keywords (52 commits)
+- `frontend`: 181 mentions
+- `serving`: 74 mentions
+- `api server`: 42 mentions
+- `vllm serve`: 23 mentions
+- `online serving`: 19 mentions
+
+## 🗂️ Data Schema
+
+```python
+{
+    'commit_hash': str,           # Git commit SHA-1 hash (40 chars)
+    'pr_url': str,                # GitHub PR URL (e.g., https://github.com/vllm-project/vllm/pull/12601)
+    'has_lm_eval': bool,          # True if commit contains LM evaluation tests
+    'has_performance': bool,       # True if commit contains performance benchmarks
+    'has_serving': bool,          # True if commit contains serving tests
+    'has_general_test': bool,     # True if commit contains general tests
+    'test_details': str,          # Pipe-separated test keywords (e.g., "PERF: ttft, throughput | TEST: ci, pytest")
+    'timeline_text': str,         # Full PR timeline text with comments, reviews, and commit messages
+    'extracted_at': str           # ISO timestamp when data was extracted
+}
+```
+
+## 💻 Usage Examples
+
+### Basic Loading
+```python
+from datasets import load_dataset
+
+# Load the dataset
+dataset = load_dataset("your-username/vllm-pr-test-classification")
+
+# Explore the data
+print(f"Total examples: {len(dataset['train'])}")
+print(f"Features: {dataset['train'].features}")
+print(f"First example: {dataset['train'][0]}")
+```
+
+### Filtering Examples
+```python
+# Get commits with performance benchmarks
+perf_commits = dataset['train'].filter(lambda x: x['has_performance'])
+print(f"Performance commits: {len(perf_commits)}")
+
+# Get commits with LM evaluation
+lm_eval_commits = dataset['train'].filter(lambda x: x['has_lm_eval'])
+print(f"LM evaluation commits: {len(lm_eval_commits)}")
+
+# Get commits with multiple test types
+multi_test = dataset['train'].filter(
+    lambda x: sum([x['has_lm_eval'], x['has_performance'], 
+                   x['has_serving'], x['has_general_test']]) >= 3
+)
+print(f"Commits with 3+ test types: {len(multi_test)}")
+```
+
+### Analysis Example
+```python
+import pandas as pd
+
+# Convert to pandas for analysis
+df = dataset['train'].to_pandas()
+
+# Analyze test type combinations
+test_combinations = df[['has_lm_eval', 'has_performance', 'has_serving', 'has_general_test']]
+combination_counts = test_combinations.value_counts()
+print("Most common test combinations:")
+print(combination_counts.head())
+
+# Extract performance metrics mentioned
+perf_df = df[df['has_performance']]
+print(f"\nCommits mentioning specific metrics:")
+print(f"TTFT mentions: {perf_df['test_details'].str.contains('TTFT').sum()}")
+print(f"Throughput mentions: {perf_df['test_details'].str.contains('throughput', case=False).sum()}")
+```
+
+### Text Classification Training
+```python
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import TrainingArguments, Trainer
+
+# Prepare for multi-label classification
+def preprocess_function(examples):
+    # Create multi-label targets
+    labels = []
+    for i in range(len(examples['commit_hash'])):
+        label = [
+            int(examples['has_lm_eval'][i]),
+            int(examples['has_performance'][i]),
+            int(examples['has_serving'][i]),
+            int(examples['has_general_test'][i])
+        ]
+        labels.append(label)
+    
+    # Tokenize timeline text
+    tokenized = tokenizer(
+        examples['timeline_text'],
+        truncation=True,
+        padding='max_length',
+        max_length=512
+    )
+    tokenized['labels'] = labels
+    return tokenized
+
+# Train a classifier to identify test types from PR text
+tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+model = AutoModelForSequenceClassification.from_pretrained(
+    "bert-base-uncased",
+    num_labels=4,
+    problem_type="multi_label_classification"
+)
+```
+
+## 🔍 Sample Data
+
+### Example 1: Performance-focused commit
+```json
+{
+  "commit_hash": "fc542144c4477ffec1d3de6fa43e54f8fb5351e8",
+  "pr_url": "https://github.com/vllm-project/vllm/pull/12563",
+  "has_lm_eval": false,
+  "has_performance": true,
+  "has_serving": false,
+  "has_general_test": true,
+  "test_details": "PERF: tok/s, optimization | TEST: CI",
+  "timeline_text": "[Guided decoding performance optimization]..."
+}
+```
+
+### Example 2: Comprehensive testing commit
+```json
+{
+  "commit_hash": "aea94362c9bdd08ed2b346701bdc09d278e85f66",
+  "pr_url": "https://github.com/vllm-project/vllm/pull/12287",
+  "has_lm_eval": true,
+  "has_performance": true,
+  "has_serving": true,
+  "has_general_test": true,
+  "test_details": "LM_EVAL: lm_eval, gsm8k | PERF: TTFT, ITL | SERVING: vllm serve | TEST: test, CI",
+  "timeline_text": "[Frontend][V1] Online serving performance improvements..."
+}
+```
+
+## 🛠️ Potential Use Cases
+
+1. **Test Type Classification**: Train models to automatically classify test types in software PRs
+2. **Testing Pattern Analysis**: Study how different test types correlate in infrastructure projects
+3. **Performance Optimization Research**: Analyze performance testing trends in LLM serving systems
+4. **CI/CD Insights**: Understand continuous integration patterns in ML infrastructure projects
+5. **Documentation Generation**: Generate test documentation from PR timelines
+6. **Code Review Automation**: Build tools to automatically suggest relevant tests based on PR content
+
+## 📚 Source
+
+This dataset was extracted from the [vLLM project](https://github.com/vllm-project/vllm) GitHub repository PR timelines. vLLM is a high-throughput and memory-efficient inference and serving engine for LLMs.
+
+## 🔄 Updates
+
+- **v1.0.0** (2025-01): Initial release with 98 commits
+
+## 📜 License
+
+This dataset is released under the MIT License, consistent with the vLLM project's licensing.
+
+## 📖 Citation
+
+If you use this dataset in your research or applications, please cite:
+
+```bibtex
+@dataset{vllm_pr_test_classification_2025,
+  title={vLLM PR Test Classification Dataset},
+  author={vLLM Community Contributors},
+  year={2025},
+  publisher={Hugging Face},
+  url={https://huggingface.co/datasets/your-username/vllm-pr-test-classification},
+  note={A dataset of 98 vLLM commits with test type classifications extracted from GitHub PR timelines}
+}
+```
+
+## 🤝 Contributing
+
+If you'd like to contribute to this dataset or report issues:
+1. Open an issue on the Hugging Face dataset repository
+2. Submit improvements via pull requests
+3. Share your use cases and findings
+
+## ⚠️ Limitations
+
+- Dataset size is limited to 98 commits
+- Timeline text may be truncated for very long PR discussions
+- Classification is based on keyword matching, which may miss context-dependent references
+- Dataset represents a snapshot from specific time period of vLLM development
+
+## 🙏 Acknowledgments
+
+Thanks to the vLLM project maintainers and contributors for their open-source work that made this dataset possible.