---
license: mit
task_categories:
- text-generation
tags:
- code
- bug-fixing
- error-correction
- diffusion-models
- code-revision
size_categories:
- 10K<n<100K
---

# Code Revision Benchmark (CRB) Datasets

## Dataset Description

The Code Revision Benchmark (CRB) is a controlled and executable benchmark designed to evaluate corrective behavior in diffusion language models. This dataset contains buggy code samples with controlled token-level errors, enabling systematic evaluation of how well masked diffusion language models can localize and correct errors through self-revision mechanisms.

### Dataset Summary

This dataset is part of the research framework for **Corrective Diffusion Language Models (CDLM)**. It provides:

- **Controlled token-level corruption**: Operator, identifier, and literal substitutions
- **Error position annotations**: Precise token-level error locations relative to buggy body
- **Multiple model variants**: Samples generated using different tokenizers (LLaDA, Dream, Open-dLLM)
- **Executable benchmarks**: Based on HumanEval, HumanEval+, MBPP, and MBPP+ datasets

## Dataset Structure

### Data Splits

The dataset is organized by model (each split corresponds to one model):

- `LLaDA_8B_Base`: Samples generated using LLaDA-8B-Base tokenizer
- `Dream_v0_Base_7B`: Samples generated using Dream-v0-Base-7B tokenizer  
- `open_dcoder_0.5B`: Samples generated using open-dcoder-0.5B tokenizer

### Data Fields

Each sample contains the following fields:

- `task_id`: Task identifier from the original dataset (e.g., "HumanEval/0")
- `function_head`: Function signature and docstring (fixed context)
- `buggy_body`: Function body with injected errors (error_positions are relative to this)
- `error_positions`: List of token positions where errors occur (relative to buggy_body)
- `error_original_tokens`: List of original (correct) tokens at error positions
- `error_type`: Type of error injected (`operator`, `var`, or `literal`)
- `n_replace`: Number of tokens corrupted per sample
- `dataset`: Source dataset (`human-eval`, `human-eval+`, `mbpp`, `mbpp+`)
- `model`: Model name used for tokenization

### Important Notes

⚠️ **Critical**: `error_positions` are relative to `buggy_body`, NOT the full code.

- When using this dataset, you must:
  1. Tokenize `buggy_body` separately (not the full code)
  2. Use `error_positions` directly on the buggy_body tokens
  3. Use the corresponding model's tokenizer (specified in `model` field)

## Usage

### Loading the Dataset

```python
from datasets import load_dataset

# Load the entire dataset
dataset_dict = load_dataset("Shuibai12138/crb-datasets")

# Access a specific model split
llada_dataset = dataset_dict["LLaDA_8B_Base"]

# Get a sample
sample = llada_dataset[0]
print(sample.keys())
# dict_keys(['task_id', 'function_head', 'buggy_body', 'error_positions', 
#            'error_original_tokens', 'error_type', 'n_replace', 'dataset', 'model'])
```

### Extracting Error Tokens

```python
from transformers import AutoTokenizer

# Get sample
sample = llada_dataset[0]
buggy_body = sample['buggy_body']
error_positions = sample['error_positions']
error_original_tokens = sample['error_original_tokens']
model_name = sample['model']  # e.g., "LLaDA-8B-Base"

# Map to HuggingFace model name
model_mapping = {
    "LLaDA-8B-Base": "GSAI-ML/LLaDA-8B-Base",
    "Dream-v0-Base-7B": "Dream-org/Dream-v0-Base-7B",
    "open-dcoder-0.5B": "fredzzp/open-dcoder-0.5B",
}
hf_model_name = model_mapping[model_name]

# Load corresponding tokenizer
tokenizer = AutoTokenizer.from_pretrained(
    hf_model_name,
    trust_remote_code=True,
    use_fast=False
)

# Tokenize buggy_body (NOT the full code)
body_tokens = tokenizer(
    buggy_body,
    add_special_tokens=False,
    return_tensors="pt"
)["input_ids"][0].tolist()

# Extract error tokens using error_positions
error_token_ids = [body_tokens[pos] for pos in error_positions]
error_token_texts = [
    tokenizer.decode([body_tokens[pos]], skip_special_tokens=True)
    for pos in error_positions
]

# Compare with original tokens
for i, (error_tok, original_tok) in enumerate(zip(error_token_texts, error_original_tokens)):
    print(f"Error {i+1}: '{error_tok}' (original: '{original_tok}')")
```

## Dataset Statistics

| Split | Samples | Description |
|-------|---------|-------------|
| LLaDA_8B_Base | ~37,000 | Samples tokenized with LLaDA-8B-Base |
| Dream_v0_Base_7B | ~37,000 | Samples tokenized with Dream-v0-Base-7B |
| open_dcoder_0.5B | ~37,000 | Samples tokenized with open-dcoder-0.5B |

## Error Types and Dataset Creation

For detailed information about error types (operator, identifier, and literal substitutions) and the dataset creation process, please refer to the paper:

**Corrective Diffusion Language Models**  
[arXiv:2512.15596](https://arxiv.org/pdf/2512.15596)

The paper describes the Code Revision Benchmark (CRB) construction methodology, including:
- Type-preserving token-level corruption strategies
- Executable validation and instance construction
- Difficulty control via number of replacements

For implementation details, see the [CDLM repository](https://github.com/zhangshuibai/CDLM).

## Citation

If you use this dataset, please cite:

```bibtex
@misc{zhang2025correctivediffusionlanguagemodels,
    title={Corrective Diffusion Language Models}, 
    author={Shuibai Zhang and Fred Zhangzhi Peng and Yiheng Zhang and Jin Pan and Grigorios G. Chrysos},
    year={2025},
    eprint={2512.15596},
    archivePrefix={arXiv},
    primaryClass={cs.LG},
    url={https://arxiv.org/abs/2512.15596}, 
}
```

## License

This dataset is licensed under the MIT License.

## Contact

For questions and issues, please contact:
- **Shuibai Zhang** <shuibai@cs.wisc.edu>
- GitHub: [zhangshuibai/CDLM](https://github.com/zhangshuibai/CDLM)