Nicknam/HPO-RL-Tiny

HPO-RL-Bench Minimal Subset (100 configs per pair of algorithm and environment)

⚠️ This is a derivative subset of the official HPO-RL-Bench benchmark. It contains 100 randomly sampled hyperparameter configurations for each of the three core algorithms (DQN, PPO, SAC) to enable rapid prototyping and testing of hyperparameter optimization methods.

For the full benchmark , see the original dataset.

📌 Attribution & License

This dataset is a derivative work of:

HPO-RL-Bench: A Zero-Cost Benchmark for Hyperparameter Optimization in Reinforcement Learning
Gresa Shala*, Andrei Nica*, Matthias Feurer, Frank Hutter (*equal contribution)
ICML 2024 Workshop on Automated Machine Learning (AutoML)
https://github.com/machinelearningnuremberg/HPO-RL-Bench

• Original authors: G. Shala, A. Nica, M. Feurer, F. Hutter (University of Freiburg / ML@Nuremberg)
• Original repository: https://github.com/machinelearningnuremberg/HPO-RL-Bench
• Original Hugging Face dataset: https://huggingface.co/datasets/gresashala/HPO-RL-Bench-data
• License: MIT License (full text preserved in LICENSE file)

This derivative subset is also released under the MIT License. You must retain the original copyright notice and license when redistributing.

💡 Usage Example

from datasets import load_dataset

# Load the minimal subset
ds = load_dataset("Nicknam/HPO-RL-Tiny")

Or you can simply download that and use this code :

import os
import json
import pandas as pd
from pathlib import Path
from typing import Dict, Any, List 
import re

def parse_filename_with_regex(filename: str) -> Dict[str, Any]:
    """
    Parse hyperparameters from filename using multiple regex patterns.
    Handles various filename formats including those with 'random' and missing parameters.
    """
    # Remove .json extension
    filename = filename.replace('.json', '')
    
    # Pattern 1: Standard DQN/PPO with layers and units
    pattern1 = r'([A-Za-z0-9\-]+)_(DQN|PPO)_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_epsilon_([0-9\.]+)_layers_([0-9]+)_units_([0-9]+)_seed([0-9]+)'
    
    # Pattern 2: DQN/PPO with random and no layers/units
    pattern2 = r'([A-Za-z0-9\-]+)_(DQN|PPO)_random_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_epsilon_([0-9\.]+)_seed([0-9]+)'
    
    # Pattern 3: DQN/PPO with random, layers and units
    pattern3 = r'([A-Za-z0-9\-]+)_(DQN|PPO)_random_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_epsilon_([0-9\.]+)_layers_([0-9]+)_units_([0-9]+)_seed([0-9]+)'
    
    # Pattern 4: SAC with layers and units
    pattern4 = r'([A-Za-z0-9\-]+)_(SAC)_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_tau_([0-9\.]+)_layers_([0-9]+)_units_([0-9]+)_seed([0-9]+)'
    
    # Pattern 5: SAC random without layers/units
    pattern5 = r'([A-Za-z0-9\-]+)_(SAC)_random_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_tau_([0-9\.]+)_seed([0-9]+)'
    
    # Pattern 6: DQN/PPO with eval suffix
    pattern6 = r'([A-Za-z0-9\-]+)_(DQN|PPO)_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_epsilon_([0-9\.]+)_layers_([0-9]+)_units_([0-9]+)_seed([0-9]+)_eval'
    
    # Pattern 7: DQN/PPO random with eval suffix
    pattern7 = r'([A-Za-z0-9\-]+)_(DQN|PPO)_random_lr_([\-0-9\.]+)_gamma_([0-9\.]+)_epsilon_([0-9\.]+)_seed([0-9]+)_eval'
    
    patterns = [
        (pattern1, 'standard'),
        (pattern2, 'random_no_layers'),
        (pattern3, 'random_with_layers'),
        (pattern4, 'sac_standard'),
        (pattern5, 'sac_random'),
        (pattern6, 'standard_eval'),
        (pattern7, 'random_eval')
    ]
    
    for pattern, pattern_type in patterns:
        match = re.match(pattern, filename)
        if match:
            result = {
                'environment': match.group(1),
                'algorithm': match.group(2),
                'pattern_type': pattern_type
            }
            
            # Extract parameters based on pattern type
            if pattern_type == 'standard' or pattern_type == 'standard_eval':
                result.update({
                    'lr': float(match.group(3)),
                    'gamma': float(match.group(4)),
                    'epsilon': float(match.group(5)),
                    'layers': int(match.group(6)),
                    'units': int(match.group(7)),
                    'seed': int(match.group(8))
                })
            elif pattern_type == 'random_no_layers' or pattern_type == 'random_eval':
                result.update({
                    'lr': float(match.group(3)),
                    'gamma': float(match.group(4)),
                    'epsilon': float(match.group(5)),
                    'seed': int(match.group(6)),
                    'layers': None,  # Missing
                    'units': None    # Missing
                })
            elif pattern_type == 'random_with_layers':
                result.update({
                    'lr': float(match.group(3)),
                    'gamma': float(match.group(4)),
                    'epsilon': float(match.group(5)),
                    'layers': int(match.group(6)),
                    'units': int(match.group(7)),
                    'seed': int(match.group(8))
                })
            elif pattern_type == 'sac_standard':
                result.update({
                    'lr': float(match.group(3)),
                    'gamma': float(match.group(4)),
                    'tau': float(match.group(5)),
                    'layers': int(match.group(6)),
                    'units': int(match.group(7)),
                    'seed': int(match.group(8)),
                    'epsilon': None  # Not applicable for SAC
                })
            elif pattern_type == 'sac_random':
                result.update({
                    'lr': float(match.group(3)),
                    'gamma': float(match.group(4)),
                    'tau': float(match.group(5)),
                    'seed': int(match.group(6)),
                    'layers': None,  # Missing
                    'units': None,   # Missing
                    'epsilon': None  # Not applicable for SAC
                })
            
            return result
    
    # If no pattern matches, try manual parsing as fallback
    return parse_filename_manually(filename)

def parse_filename_manually(filename: str) -> Dict[str, Any]:
    """
    Manual parsing as fallback when regex fails.
    """
    print(f"Manual parsing for: {filename}")

    # Split filename into parts
    parts = filename.replace('.json', '').split('_')
    
    result = {
        'environment': parts[0],
        'algorithm': parts[1],
        'pattern_type': 'manual',
        'layers': None,
        'units': None,
        'epsilon': None,
        'tau': None
    }
    
    # Try to extract parameters
    for i, part in enumerate(parts):
        if part == 'lr' and i + 1 < len(parts):
            try:
                result['lr'] = float(parts[i + 1])
            except:
                result['lr'] = None
        elif part == 'gamma' and i + 1 < len(parts):
            try:
                result['gamma'] = float(parts[i + 1])
            except:
                result['gamma'] = None
        elif part == 'epsilon' and i + 1 < len(parts):
            try:
                result['epsilon'] = float(parts[i + 1])
            except:
                result['epsilon'] = None
        elif part == 'tau' and i + 1 < len(parts):
            try:
                result['tau'] = float(parts[i + 1])
            except:
                result['tau'] = None
        elif part == 'layers' and i + 1 < len(parts):
            try:
                result['layers'] = int(parts[i + 1])
            except:
                result['layers'] = None
        elif part == 'units' and i + 1 < len(parts):
            try:
                result['units'] = int(parts[i + 1])
            except:
                result['units'] = None
        elif part == 'seed' and i + 1 < len(parts):
            try:
                # Remove any non-numeric suffix (like 'eval')
                seed_str = parts[i + 1]
                # Extract just the numeric part
                seed_num = ''.join(filter(str.isdigit, seed_str))
                result['seed'] = int(seed_num) if seed_num else 0
            except:
                result['seed'] = 0
    
    return result

def process_json_file_to_single_row(file_path: str) -> Dict[str, Any]:
    """
    Process a single JSON file and return ONE ROW (dictionary) for the DataFrame.
    Each file represents one experiment run.
    """
    try:
        with open(file_path, 'r') as f:
            data = json.load(f)
        
        # Parse hyperparameters from filename
        filename = os.path.basename(file_path)
        hyperparams = parse_filename_with_regex(filename)
        
        # Extract directory structure info for run_id
        path_parts = file_path.split(os.sep)
        run_id = 0
        for part in path_parts:
            if '_' in part:
                try:
                    run_id = int(part.split('_')[-1])
                    break
                except:
                    continue
        
        hyperparams['run_id'] = run_id
        hyperparams['file_path'] = file_path
        hyperparams['file_name'] = filename
        
        # Convert LR exponent to actual value if lr exists
        if 'lr' in hyperparams and hyperparams['lr'] is not None:
            hyperparams['learning_rate'] = 10 ** hyperparams['lr']
        else:
            hyperparams['learning_rate'] = None
        
        # Now, instead of creating multiple rows for each data point,
        # we'll extract summary statistics and store the data as lists/arrays
        
        if isinstance(data, dict):
            # Store evaluation returns as a list (if available)
            if 'returns_eval' in data:
                returns_eval = data['returns_eval']
                hyperparams['returns_eval'] = returns_eval  # Store as list
                hyperparams['num_eval_points'] = len(returns_eval)
                hyperparams['final_eval_return'] = returns_eval[-1] if returns_eval else None
                hyperparams['max_eval_return'] = max(returns_eval) if returns_eval else None
                hyperparams['mean_eval_return'] = sum(returns_eval) / len(returns_eval) if returns_eval else None
                
                # Also store std if available
                if 'std_returns_eval' in data:
                    hyperparams['std_returns_eval'] = data['std_returns_eval']
            
            # Store training returns as a list (if available)
            if 'returns_train' in data:
                returns_train = data['returns_train']
                hyperparams['returns_train'] = returns_train  # Store as list
                hyperparams['num_train_points'] = len(returns_train)
                hyperparams['final_train_return'] = returns_train[-1] if returns_train else None
                hyperparams['max_train_return'] = max(returns_train) if returns_train else None
                hyperparams['mean_train_return'] = sum(returns_train) / len(returns_train) if returns_train else None
            
            # Store any other scalar parameters from the JSON
            for key, value in data.items():
                # Skip the returns lists we already handled
                if key in ['returns_eval', 'std_returns_eval', 'returns_train']:
                    continue
                
                # Store scalar values directly
                if isinstance(value, (int, float, str, bool)) or value is None:
                    hyperparams[key] = value
                # Store other lists/arrays
                elif isinstance(value, list):
                    hyperparams[key] = value
        
        elif isinstance(data, list):
            # If data is just a list of returns, store it
            hyperparams['returns'] = data
            hyperparams['num_returns'] = len(data)
            hyperparams['final_return'] = data[-1] if data else None
            hyperparams['max_return'] = max(data) if data else None
            hyperparams['mean_return'] = sum(data) / len(data) if data else None
        
        else:
            # Single value
            hyperparams['value'] = data
        
        return hyperparams  # Return ONE dictionary/row
            
    except Exception as e:
        print(f"Error processing {file_path}: {e}")
        return None

def load_hpo_rl_data_as_one_row_per_file(base_path="/Users/niknam/Documents/Others/Code/HPO_RL/100_sample/HPO-RL-Bench-100-per-pair"):
    """
    Load all HPO RL benchmark data into a DataFrame with ONE ROW PER FILE.
    Each row represents one experiment run with all its data stored in lists/arrays.
    """
    data_dir = os.path.join(base_path, "data_hpo_rl_bench")
    
    # Get all JSON files
    json_files = []
    for root, dirs, files in os.walk(data_dir):
        for file in files:
            if file.endswith('.json'):
                json_files.append(os.path.join(root, file))
    
    print(f"Found {len(json_files)} JSON files")
    
    # Process each file to get ONE row per file
    rows = []
    for i, file_path in enumerate(json_files):
        if i % 500 == 0:
            print(f"Processing file {i+1}/{len(json_files)}")
        
        row = process_json_file_to_single_row(file_path)
        if row:
            rows.append(row)
    
    # Create DataFrame from the rows (one per file)
    df = pd.DataFrame(rows)
    
    # Post-processing
    if not df.empty:
        # Extract environment name and version
        def extract_env_parts(env_str):
            if '-' in env_str:
                parts = env_str.split('-')
                if len(parts) >= 2:
                    name = '-'.join(parts[:-1])
                    version = parts[-1].replace('v', '')
                    try:
                        version = int(version) if version.isdigit() else 0
                    except:
                        version = 0
                    return name, version
            return env_str, 0
        
        df[['env_name', 'env_version']] = df['environment'].apply(
            lambda x: pd.Series(extract_env_parts(x))
        )
        
        # Create a unique run identifier
        df['run_identifier'] = df.apply(
            lambda row: f"{row['algorithm']}_{row['environment']}_seed{row.get('seed', 0)}_run{row.get('run_id', 0)}", 
            axis=1
        )
        
        # Fill missing values for numeric columns only
        for col in ['layers', 'units', 'epsilon', 'tau', 'gamma', 'lr']:
            if col in df.columns:
                df[col] = df[col].fillna(-1)  # Use -1 for missing
    
    print(f"\nLoaded DataFrame with shape: {df.shape}")
    print(f"Expected: ~{len(json_files)} rows (one per file)")
    print(f"Actual: {len(df)} rows")
    print(f"Columns: {df.columns.tolist()}")
    
    return df

# Run test first
def test_parsing_single_row(base_path="/Users/niknam/Documents/Others/Code/HPO_RL/100_sample/HPO-RL-Bench-100-per-pair", sample_size=5):
    """Test parsing on a small sample of files."""
    data_dir = os.path.join(base_path, "data_hpo_rl_bench")
    
    # Find some files with different patterns
    test_files = []
    for root, dirs, files in os.walk(data_dir):
        for file in files:
            if file.endswith('.json'):
                test_files.append(os.path.join(root, file))
                if len(test_files) >= sample_size:
                    break
        if len(test_files) >= sample_size:
            break
    
    print(f"Testing single-row parsing on {len(test_files)} files:")
    print("-" * 80)
    
    for file_path in test_files:
        filename = os.path.basename(file_path)
        print(f"\nFile: {filename}")
        row = process_json_file_to_single_row(file_path)
        if row:
            print(f"Row keys: {list(row.keys())[:10]}...")  # Show first 10 keys
            # Show some important fields
            for key in ['environment', 'algorithm', 'lr', 'gamma', 'epsilon', 'tau', 'seed']:
                if key in row:
                    print(f"  {key}: {row[key]}")
            if 'returns_eval' in row:
                print(f"  returns_eval: list of {len(row['returns_eval'])} values")
                print(f"  final_eval_return: {row.get('final_eval_return')}")
    
    print("\n" + "=" * 80)
    print("Now loading all data...")
    print("=" * 80)

# Run test first
test_parsing_single_row()

# Then load all data
df = load_hpo_rl_data_as_one_row_per_file()

# Display summary with error handling for list columns
if not df.empty:
    print("\n" + "=" * 80)
    print("DATA SUMMARY - ONE ROW PER FILE")
    print("=" * 80)
    
    print(f"\nTotal rows: {len(df):,} (should be ~4,197)")
    print(f"Unique algorithms: {df['algorithm'].unique()}")
    print(f"Unique environments: {df['environment'].nunique()}")
    
    # Safely check unique seeds
    if 'seed' in df.columns:
        try:
            unique_seeds = df['seed'].unique()
            print(f"Unique seeds: {len(unique_seeds)}")
        except:
            print("Unique seeds: Cannot compute (list column)")
    
    print(f"\nSample of columns containing data:")
    data_columns = []
    for col in df.columns:
        # Check if column contains list data
        if col in ['returns_eval', 'returns_train', 'returns', 'std_returns_eval']:
            data_columns.append(col)
        # Check if it's a summary statistic
        elif 'return' in col.lower() or 'mean' in col.lower() or 'max' in col.lower() or 'final' in col.lower():
            data_columns.append(col)
    
    print(f"  Data columns: {data_columns[:10]}...")  # Show first 10
    
    # Show sample rows
    print(f"\nSample rows (first 3):")
    for i in range(min(3, len(df))):
        print(f"\nRow {i+1}:")
        row = df.iloc[i]
        print(f"  {row['algorithm']} on {row['environment']} (seed {row.get('seed', 'N/A')})")
        if 'returns_eval' in row and isinstance(row['returns_eval'], list):
            print(f"  Eval returns: {len(row['returns_eval'])} steps, final: {row.get('final_eval_return', 'N/A')}")
        if 'returns_train' in row and isinstance(row['returns_train'], list):
            print(f"  Train returns: {len(row['returns_train'])} steps, final: {row.get('final_train_return', 'N/A')}")

# Now you can analyze the data easily - FIXED VERSION:
print("\n" + "=" * 80)
print("DATA ANALYSIS EXAMPLES (SAFE VERSION)")
print("=" * 80)

if not df.empty:
    # Example 1: Count experiments by algorithm
    print("\n1. Experiments by algorithm:")
    print(df['algorithm'].value_counts())
    
    # Example 2: Average final evaluation return by algorithm (if column exists and is numeric)
    if 'final_eval_return' in df.columns:
        print("\n2. Average final evaluation return by algorithm:")
        try:
            avg_final_by_algo = df.groupby('algorithm')['final_eval_return'].mean()
            print(avg_final_by_algo)
        except Exception as e:
            print(f"  Could not compute: {e}")
    
    # Example 3: Check hyperparameter ranges - FIXED to handle list columns
    print("\n3. Hyperparameter ranges (numeric columns only):")
    hyperparam_cols = ['lr', 'gamma', 'epsilon', 'tau', 'layers', 'units', 'seed']
    
    for col in hyperparam_cols:
        if col in df.columns:
            try:
                # Check if column contains lists by sampling first non-null value
                sample_value = df[col].dropna().iloc[0] if not df[col].dropna().empty else None
                if isinstance(sample_value, list):
                    print(f"  {col}: Contains lists (cannot compute unique values)")
                    continue
                
                # Get unique values for scalar columns
                unique_vals = df[col].dropna().unique()
                # Filter out -1 (which we used for missing)
                unique_vals = [v for v in unique_vals if v != -1]
                
                if len(unique_vals) < 20:  # Don't print too many values
                    # Try to sort if values are comparable
                    try:
                        print(f"  {col}: {sorted(unique_vals)}")
                    except:
                        print(f"  {col}: {unique_vals}")
                else:
                    print(f"  {col}: {len(unique_vals)} unique values")
                    
            except Exception as e:
                print(f"  {col}: Error - {e}")

# Save to a more manageable format
output_file = "hpo_rl_one_row_per_file.parquet"
df.to_parquet(output_file, index=False)
print(f"\n✅ Data saved to {output_file} ({len(df)} rows)")

# Additional analysis functions that work with the DataFrame
def analyze_dataframe_safely(df):
    """Safe analysis functions that handle list columns."""
    print("\n" + "=" * 80)
    print("SAFE DATA ANALYSIS")
    print("=" * 80)
    
    # Basic info
    print(f"DataFrame shape: {df.shape}")
    print(f"Total experiments: {len(df)}")
    
    # Get numeric columns (excluding list columns)
    numeric_cols = []
    object_cols = []
    list_cols = []
    
    for col in df.columns:
        if df[col].dtype in ['int64', 'float64']:
            numeric_cols.append(col)
        elif df[col].dtype == 'object':
            # Check if it contains lists
            sample = df[col].dropna()
            if not sample.empty and isinstance(sample.iloc[0], list):
                list_cols.append(col)
            else:
                object_cols.append(col)
    
    print(f"\nNumeric columns ({len(numeric_cols)}): {numeric_cols}")
    print(f"Object columns ({len(object_cols)}): {object_cols}")
    print(f"List columns ({len(list_cols)}): {list_cols}")
    
    # Summary statistics for numeric columns
    if numeric_cols:
        print("\nSummary statistics for numeric columns:")
        print(df[numeric_cols].describe())
    
    # Count by algorithm and environment
    print("\nExperiments by algorithm and environment:")
    algo_env_counts = df.groupby(['algorithm', 'environment']).size().reset_index(name='count')
    print(algo_env_counts.sort_values('count', ascending=False).head(10))
    
    return {
        'numeric_cols': numeric_cols,
        'object_cols': object_cols,
        'list_cols': list_cols
    }

# Run safe analysis
analysis_results = analyze_dataframe_safely(df)

# Function to access list data safely
def get_experiment_data(df, experiment_id=None, algorithm=None, environment=None, seed=None):
    """Get detailed data for specific experiments."""
    filtered_df = df.copy()
    
    if experiment_id is not None:
        filtered_df = filtered_df[filtered_df['run_identifier'] == experiment_id]
    
    if algorithm is not None:
        filtered_df = filtered_df[filtered_df['algorithm'] == algorithm]
    
    if environment is not None:
        filtered_df = filtered_df[filtered_df['environment'] == environment]
    
    if seed is not None:
        filtered_df = filtered_df[filtered_df['seed'] == seed]
    
    if filtered_df.empty:
        print("No experiments match the criteria")
        return
    
    for idx, row in filtered_df.iterrows():
        print(f"\nExperiment: {row['run_identifier']}")
        print(f"  Algorithm: {row['algorithm']}, Environment: {row['environment']}")
        print(f"  Seed: {row.get('seed', 'N/A')}")
        
        if 'returns_eval' in row and isinstance(row['returns_eval'], list):
            print(f"  Evaluation returns: {len(row['returns_eval'])} steps")
            print(f"    First 5: {row['returns_eval'][:5]}")
            print(f"    Last 5: {row['returns_eval'][-5:]}")
        
        if 'final_eval_return' in row:
            print(f"  Final eval return: {row['final_eval_return']}")
        
        print(f"  Hyperparameters:")
        for param in ['lr', 'gamma', 'epsilon', 'tau', 'layers', 'units']:
            if param in row and pd.notna(row[param]) and row[param] != -1:
                print(f"    {param}: {row[param]}")

# Example usage:
print("\n" + "=" * 80)
print("GETTING SPECIFIC EXPERIMENT DATA")
print("=" * 80)

# Get first DQN experiment
dqn_experiments = df[df['algorithm'] == 'DQN']
if not dqn_experiments.empty:
    get_experiment_data(df, algorithm='DQN', environment='CartPole-v1', seed=0)