---
dataset_info:
  features:
  - name: data_source
    dtype: string
  - name: prompt
    list:
    - name: role
      dtype: string
    - name: content
      dtype: string
  - name: ability
    dtype: string
  - name: reward_model
    struct:
    - name: style
      dtype: string
    - name: ground_truth
      dtype: string
  - name: extra_info
    struct:
    - name: split
      dtype: string
    - name: index
      dtype: int64
  splits:
  - name: train
    num_bytes: 1540000000
    num_examples: 25276
  download_size: 1540000000
  dataset_size: 1540000000
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
license: mit
---

# Eurus-2-Code-RL (VERL Format)

This dataset contains **25,276** competitive programming problems from the Eurus-2-RL-Data dataset, filtered and converted to VERL format for reinforcement learning training workflows.

**Source**: [PRIME-RL/Eurus-2-RL-Data](https://huggingface.co/datasets/PRIME-RL/Eurus-2-RL-Data)

**License**: MIT

## Dataset Description

Eurus-2-Code-RL is a curated collection of competitive programming problems specifically designed for training language models using reinforcement learning. The problems are sourced from various high-quality coding challenge platforms and include:
- CodeContests problems
- TACO (Text-Assisted Coding with Objectives) problems
- APPS (Automated Programming Progress Standard) problems
- Codeforces problems

The dataset includes a comprehensive system prompt with structured reasoning actions (ASSESS, ADVANCE, VERIFY, SIMPLIFY, SYNTHESIZE, PIVOT, OUTPUT) to guide model training.

## Dataset Structure

The dataset follows the VERL format with the following fields:

- `data_source` (string): Original source identifier (e.g., "taco", "codecontests", "apps", "codeforces")
- `prompt` (list): Chat template format with role/content structure
  - System prompt with reasoning actions
  - User message with the coding problem
- `ability` (string): Task category ("code")
- `reward_model` (dict): Evaluation information
  - `style`: Evaluation method
  - `ground_truth`: Expected solution or test cases
- `extra_info` (dict): Additional metadata
  - `split`: Data split ("train" or "dummy")
  - `index`: Example index

## Data Quality

**High-Quality Problems**:
- ✅ **Diverse sources** - Problems from competitive programming platforms
- ✅ **Structured reasoning** - System prompts with explicit reasoning actions
- ✅ **RL-focused** - Specifically designed for reinforcement learning training
- ✅ **Verified solutions** - Ground truth solutions for reward model evaluation

### Sample Problem

```python
{
  "data_source": "taco",
  "prompt": [
    {
      "role": "system",
      "content": "\nWhen tackling complex reasoning tasks, you have access to the following actions. Use them as needed to progress through your thought process.\n\n[ASSESS]\n\n[ADVANCE]\n\n[VERIFY]\n\n[SIMPLIFY]\n\n[SYNTHESIZE]\n\n[PIVOT]\n\n[OUTPUT]\n\nYou should strictly follow the format below:\n\n[ACTION NAME]\n\n# Your action step 1\n\n# Your action step 2\n\n# Your action step 3\n\n...\n\nNext action: [NEXT ACTION NAME]\n\n"
    },
    {
      "role": "user",
      "content": "One tradition of ACM-ICPC contests is that a team gets a balloon for every solved problem. We assume that the submission time doesn't matter and teams are sorted only by the number of balloons they have..."
    }
  ],
  "ability": "code",
  "reward_model": {
    "style": "rule",
    "ground_truth": "[expected solution or test cases]"
  },
  "extra_info": {
    "split": "train",
    "index": 0
  }
}
```

## Usage

```python
from datasets import load_dataset

# Load the dataset
dataset = load_dataset("sungyub/eurus-2-code-verl")

# Access an example
example = dataset['train'][0]
print(example['prompt'][0]['content'])  # System prompt with reasoning actions
print(example['prompt'][1]['content'])  # Coding problem
print(example['reward_model']['ground_truth'])  # Expected solution
print(example['data_source'])  # Source dataset

# Stream the dataset for memory efficiency
dataset = load_dataset("sungyub/eurus-2-code-verl", streaming=True)
for example in dataset['train']:
    # Process examples one at a time
    pass
```

## Statistics

- **Total examples**: 25,276
- **Format**: 1 Parquet file with Git LFS
- **File size**: ~1.54 GB
- **File**: train-00000-of-00001.parquet
- **Filter rate**: 5.3% of total Eurus-2 dataset

## Source Datasets

The problems are sourced from multiple high-quality competitive programming datasets:
- **codecontests**: CodeContests problems (9,639 problems)
- **taco**: Text-Assisted Coding with Objectives (9,579 problems)
- **apps**: Automated Programming Progress Standard (3,462 problems)
- **codeforces**: Codeforces problems (2,596 problems)

## Problem Types

The dataset covers a wide range of programming challenges including:
- Algorithm design and implementation
- Data structures
- Dynamic programming
- Graph algorithms
- String processing
- Mathematical problems
- And more...

## Reasoning Framework

Each problem includes a system prompt with structured reasoning actions:
- **[ASSESS]**: Evaluate the current state and identify what needs to be done
- **[ADVANCE]**: Take a concrete step forward in solving the problem
- **[VERIFY]**: Check the validity of recent steps or intermediate results
- **[SIMPLIFY]**: Break down complex parts into simpler components
- **[SYNTHESIZE]**: Combine insights from different parts of the solution
- **[PIVOT]**: Change approach if current strategy isn't working
- **[OUTPUT]**: Present the final answer

## File Structure

The dataset is contained in a single parquet file:
- File name: `train-00000-of-00001.parquet`
- Contains all 25,276 examples
- HuggingFace datasets library automatically handles file loading

## Conversion

The dataset was converted using a streaming approach:

```bash
# Install dependencies
pip install datasets pyarrow

# Run conversion
python convert_to_verl.py

# Features:
# - Streaming processing for memory efficiency
# - ParquetWriter for efficient output
# - Progress tracking and resume capability
# - Filters only code problems (ability='code')
```

## Use Cases

This dataset is ideal for:
- **Reinforcement Learning**: Training code generation with structured reasoning actions
- **Fine-tuning**: Improving competitive programming capabilities
- **Reasoning Training**: Learning structured reasoning patterns for coding
- **Code Generation**: Training models to solve algorithmic problems

## Technical Details

### Conversion Process
1. Loaded source dataset from HuggingFace in streaming mode
2. Filtered examples where ability='code'
3. Output to single parquet file
4. Total conversion time: ~2.4 minutes
5. Filter rate: 5.3% (25,276 code problems from 480,537 total)

### VERL Format Benefits
- **Standardized structure**: Consistent across all VERL datasets
- **Rich metadata**: Includes source and split information
- **Chat template**: Ready for instruction-tuned models
- **Reward model integration**: Ground truth solutions for RL training
- **Reasoning framework**: Structured reasoning actions for guided training

## Additional Information

For more information about VERL format, see the [VERL documentation](https://verl.readthedocs.io/en/latest/preparation/prepare_data.html).

## Citation

If you use this dataset, please cite the original Eurus-2-RL-Data:

```bibtex
@misc{eurus-2-rl-data,
  title={Eurus-2-RL-Data},
  author={PRIME-RL},
  year={2024},
  publisher={HuggingFace},
  url={https://huggingface.co/datasets/PRIME-RL/Eurus-2-RL-Data}
}
```

## Changelog

### 2025-10-14 - Initial Release
- Filtered and converted 25,276 code problems from Eurus-2-RL-Data
- Single file for efficient loading
- Preserved original source information and metadata
- Total size: 1.54GB