Upload convert_to_verl.py with huggingface_hub

convert_to_verl.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+Eurus-2-RL-Data (Code) to VERL converter
+Filters code problems from PRIME-RL/Eurus-2-RL-Data
+Applies best practices from Big-Math-RL-Verified conversion:
+- Multi-file output for memory efficiency
+- Streaming with ParquetWriter
+- Aggressive cache cleanup
+- Progress tracking and resume capability
+"""
+
+import pyarrow.parquet as pq
+import pyarrow as pa
+from datasets import load_dataset
+from pathlib import Path
+import json
+import shutil
+import time
+from datetime import datetime
+
+# Configuration
+REPO_ID = "PRIME-RL/Eurus-2-RL-Data"
+OUTPUT_DIR = "data"
+PROGRESS_FILE = "progress.json"
+DATA_SOURCE_PREFIX = "Eurus-2-Code"
+ABILITY_FILTER = "code"  # Filter for code problems only
+BATCH_SIZE = 10000
+ROWS_PER_OUTPUT_FILE = 100000  # 100K rows per file
+CHECKPOINT_INTERVAL = 1  # Save progress after each file
+
+# Global state
+current_output_file_idx = 0
+current_output_rows = 0
+current_writer = None
+current_output_path = None
+
+def load_progress():
+    """Load progress from checkpoint"""
+    if Path(PROGRESS_FILE).exists():
+        with open(PROGRESS_FILE, 'r') as f:
+            return json.load(f)
+    return {
+        "rows_processed": 0,
+        "total_rows": 0,
+        "current_output_file_idx": 0,
+        "current_output_rows": 0,
+        "completed": False
+    }
+
+def save_progress(progress):
+    """Save progress checkpoint"""
+    progress["timestamp"] = datetime.now().isoformat()
+    with open(PROGRESS_FILE, 'w') as f:
+        json.dump(progress, f, indent=2)
+
+def check_disk_space():
+    """Monitor disk space"""
+    usage = shutil.disk_usage("/Users/sungyubkim")
+    free_gb = usage.free / (1024**3)
+    if free_gb < 5:
+        print(f"⚠️  WARNING: Low disk space: {free_gb:.1f} GB remaining")
+    return free_gb
+
+def get_output_filename(file_idx, total_files=None):
+    """Generate output filename with proper padding"""
+    if total_files is None:
+        # Estimate: 25K rows / 100K per file = ~1 file
+        total_files = 5
+    return f"{OUTPUT_DIR}/train-{file_idx:05d}-of-{total_files:05d}.parquet"
+
+def get_verl_schema():
+    """Define the VERL schema (same as source, already in VERL format)"""
+    return pa.schema([
+        ('data_source', pa.string()),
+        ('prompt', pa.list_(pa.struct([
+            ('role', pa.string()),
+            ('content', pa.string())
+        ]))),
+        ('ability', pa.string()),
+        ('reward_model', pa.struct([
+            ('style', pa.string()),
+            ('ground_truth', pa.string())
+        ])),
+        ('extra_info', pa.struct([
+            ('split', pa.string()),
+            ('index', pa.int64())
+        ]))
+    ])
+
+def init_new_output_file(file_idx):
+    """Initialize a new output file with ParquetWriter"""
+    global current_writer, current_output_path
+
+    # Close previous writer if exists
+    if current_writer is not None:
+        current_writer.close()
+        print(f"   ✅ Closed output file: {current_output_path}")
+
+    # Create new output file
+    current_output_path = get_output_filename(file_idx)
+    schema = get_verl_schema()
+    current_writer = pq.ParquetWriter(current_output_path, schema)
+    print(f"   📝 Created new output file: {current_output_path}")
+
+    return current_writer
+
+def convert_example_to_verl(example, global_index):
+    """Convert a single example to VERL format (minimal changes needed)"""
+    # The data is already in VERL format, just ensure consistency
+    return {
+        'data_source': example['data_source'],
+        'prompt': example['prompt'],
+        'ability': example['ability'],
+        'reward_model': example['reward_model'],
+        'extra_info': {
+            'split': example['extra_info'].get('split', 'train'),
+            'index': global_index
+        }
+    }
+
+def write_batch_to_output(batch_data):
+    """Write a batch to the current output file"""
+    global current_writer, current_output_rows, current_output_file_idx
+
+    # Check if we need to start a new output file
+    if current_output_rows >= ROWS_PER_OUTPUT_FILE or current_writer is None:
+        init_new_output_file(current_output_file_idx)
+        current_output_file_idx += 1
+        current_output_rows = 0
+
+    # Convert batch to PyArrow table
+    table = pa.table({
+        'data_source': [x['data_source'] for x in batch_data],
+        'prompt': [x['prompt'] for x in batch_data],
+        'ability': [x['ability'] for x in batch_data],
+        'reward_model': [x['reward_model'] for x in batch_data],
+        'extra_info': [x['extra_info'] for x in batch_data]
+    }, schema=get_verl_schema())
+
+    # Write to current file
+    current_writer.write_table(table)
+    current_output_rows += len(table)
+
+def process_dataset(start_index=0):
+    """Process the Eurus-2 dataset and filter code problems"""
+    print(f"\n📂 Loading dataset from HuggingFace...")
+
+    # Load dataset in streaming mode
+    dataset = load_dataset(REPO_ID, split='train', streaming=True)
+
+    print(f"   ✅ Dataset loaded in streaming mode")
+    print(f"   🔍 Filtering for ability='{ABILITY_FILTER}'")
+
+    batch = []
+    global_index = start_index
+    rows_processed = 0
+    rows_written = 0
+
+    print(f"\n   🔄 Processing and filtering...")
+
+    for example in dataset:
+        rows_processed += 1
+
+        # Filter for code problems only
+        if example['ability'] == ABILITY_FILTER:
+            verl_example = convert_example_to_verl(example, global_index)
+            batch.append(verl_example)
+            global_index += 1
+
+            # Write batch when it reaches BATCH_SIZE
+            if len(batch) >= BATCH_SIZE:
+                write_batch_to_output(batch)
+                rows_written += len(batch)
+                batch = []
+
+                if rows_written % 10000 == 0:
+                    print(f"      ... {rows_written:,} code rows written ({rows_processed:,} total processed)")
+
+    # Write remaining batch
+    if batch:
+        write_batch_to_output(batch)
+        rows_written += len(batch)
+
+    print(f"   ✅ Complete: {rows_written:,} code rows written from {rows_processed:,} total rows")
+
+    return rows_written, rows_processed
+
+def finalize_output_files():
+    """Close all writers and rename files with correct total count"""
+    global current_writer, current_output_file_idx
+
+    # Close final writer
+    if current_writer is not None:
+        current_writer.close()
+        print(f"\n   ✅ Closed final output file")
+
+    # Get actual number of output files
+    output_files = sorted(Path(OUTPUT_DIR).glob("train-*-of-*.parquet"))
+    actual_count = len(output_files)
+
+    print(f"\n📝 Finalizing {actual_count} output files...")
+
+    # Rename files with correct total count
+    for idx, old_path in enumerate(output_files):
+        new_name = f"train-{idx:05d}-of-{actual_count:05d}.parquet"
+        new_path = old_path.parent / new_name
+        if old_path != new_path:
+            old_path.rename(new_path)
+            print(f"   Renamed: {old_path.name} -> {new_name}")
+
+def main():
+    global current_output_file_idx, current_output_rows
+
+    print("=" * 80)
+    print("Eurus-2-RL-Data (Code) Conversion to VERL Format")
+    print("=" * 80)
+
+    # Load progress
+    progress = load_progress()
+
+    if progress.get("completed", False):
+        print(f"\n📥 Already processed! Skipping conversion.")
+        print(f"   Total code rows: {progress.get('total_rows', 0):,}")
+        return
+
+    # Ensure output directory exists
+    Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
+
+    # Check disk space
+    free_gb = check_disk_space()
+    print(f"\n💾 Disk space: {free_gb:.1f} GB free")
+
+    # Process dataset
+    start_time = time.time()
+
+    print(f"\n🚀 Starting conversion...")
+    print(f"   Source: {REPO_ID}")
+    print(f"   Filter: ability='{ABILITY_FILTER}'")
+    print(f"   Output: Multiple files, {ROWS_PER_OUTPUT_FILE:,} rows each")
+    print()
+
+    start_index = progress.get("total_rows", 0)
+    rows_written, rows_processed = process_dataset(start_index)
+
+    if rows_written > 0:
+        # Finalize output files
+        finalize_output_files()
+
+        # Final save
+        progress = {
+            "rows_processed": rows_processed,
+            "total_rows": rows_written,
+            "current_output_file_idx": current_output_file_idx,
+            "completed": True,
+            "status": "complete"
+        }
+        save_progress(progress)
+
+    # Final statistics
+    elapsed = time.time() - start_time
+    print("\n" + "=" * 80)
+    print("✅ CONVERSION COMPLETE!")
+    print("=" * 80)
+    print(f"📊 Statistics:")
+    print(f"   Total input rows processed: {rows_processed:,}")
+    print(f"   Total code rows written: {rows_written:,}")
+    print(f"   Filter rate: {rows_written/rows_processed*100:.1f}%")
+    print(f"   Time elapsed: {elapsed/60:.1f} minutes ({elapsed/3600:.2f} hours)")
+    print(f"   Output directory: {OUTPUT_DIR}")
+
+    # Check output files
+    output_files = sorted(Path(OUTPUT_DIR).glob("train-*-of-*.parquet"))
+    if output_files:
+        total_size = sum(f.stat().st_size for f in output_files) / (1024**3)
+        print(f"   Output files: {len(output_files)}")
+        print(f"   Total size: {total_size:.2f} GB")
+
+        # Validate first file
+        print(f"\n🔍 Validation (first file):")
+        table = pq.read_table(output_files[0])
+        print(f"   Rows in first file: {len(table):,}")
+        print(f"   Columns: {table.column_names}")
+
+        # Check sample
+        if len(table) > 0:
+            print(f"   Sample data_source: {table['data_source'][0].as_py()}")
+            print(f"   Sample ability: {table['ability'][0].as_py()}")
+
+    print("\n" + "=" * 80)
+
+if __name__ == "__main__":
+    main()