foxhunt/ml/tests/ppo_hyperopt_param_integration_test.rs

//! PPO Hyperopt Parameter Integration Test
//!
//! Verifies that sampled hyperparameters from PPOParams are correctly
//! wired into PPOConfig during training. This test was created to catch
//! Bug #1 discovered by Wave 2 Agent 10: hardcoded `mini_batch_size: 512`
//! at line 376 of ml/src/hyperopt/adapters/ppo.rs.
//!
//! **Test Strategy**:
//! Since we cannot easily mock the PPO training loop, we verify parameter
//! integration via two methods:
//! 1. Unit tests for PPOParams → continuous → PPOParams roundtrip
//! 2. Integration test that verifies minibatch_size is correctly stored
//!    in the parameter space and can be extracted
//!
//! **Bug Context**:
//! - File: ml/src/hyperopt/adapters/ppo.rs line 385
//! - Issue: `mini_batch_size: 512` hardcoded (ignores `params.minibatch_size`)
//! - Impact: All hyperopt trials use same minibatch size (meaningless hyperopt)
//!
//! **Implementation Note**:
//! The minibatch_size parameter uses discrete sampling from valid divisors
//! of batch_size=2048: [64, 128, 256, 512, 1024, 2048]. This ensures numerical
//! stability and prevents invalid batch sizes during training.

use ml::hyperopt::adapters::ppo::PPOParams;
use ml::hyperopt::traits::ParameterSpace;

#[test]
fn test_minibatch_size_roundtrip_64() {
    // Test that minibatch_size=64 survives roundtrip conversion
    let params = PPOParams {
        policy_learning_rate: 1e-5,
        value_learning_rate: 1e-4,
        clip_epsilon: 0.2,
        value_loss_coeff: 1.0,
        entropy_coeff: 0.01,
        minibatch_size: 64,
    };

    let continuous = params.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).expect("Failed to recover params");

    assert_eq!(
        recovered.minibatch_size, 64,
        "minibatch_size should roundtrip correctly"
    );
}

#[test]
fn test_minibatch_size_roundtrip_128() {
    // Test that minibatch_size=128 survives roundtrip conversion
    let params = PPOParams {
        policy_learning_rate: 3e-5,
        value_learning_rate: 1e-4,
        clip_epsilon: 0.2,
        value_loss_coeff: 1.0,
        entropy_coeff: 0.05,
        minibatch_size: 128,
    };

    let continuous = params.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).expect("Failed to recover params");

    assert_eq!(
        recovered.minibatch_size, 128,
        "minibatch_size should roundtrip correctly"
    );
}

#[test]
fn test_minibatch_size_roundtrip_256() {
    // Test that minibatch_size=256 survives roundtrip conversion
    let params = PPOParams {
        policy_learning_rate: 5e-5,
        value_learning_rate: 5e-4,
        clip_epsilon: 0.25,
        value_loss_coeff: 1.5,
        entropy_coeff: 0.02,
        minibatch_size: 256,
    };

    let continuous = params.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).expect("Failed to recover params");

    assert_eq!(
        recovered.minibatch_size, 256,
        "minibatch_size should roundtrip correctly"
    );
}

#[test]
fn test_minibatch_size_roundtrip_512() {
    // Test that minibatch_size=512 survives roundtrip conversion
    let params = PPOParams {
        policy_learning_rate: 1e-4,
        value_learning_rate: 1e-3,
        clip_epsilon: 0.3,
        value_loss_coeff: 2.0,
        entropy_coeff: 0.1,
        minibatch_size: 512,
    };

    let continuous = params.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).expect("Failed to recover params");

    assert_eq!(
        recovered.minibatch_size, 512,
        "minibatch_size should roundtrip correctly"
    );
}

#[test]
fn test_minibatch_size_roundtrip_1024() {
    // Test that minibatch_size=1024 survives roundtrip conversion
    let params = PPOParams {
        policy_learning_rate: 1e-4,
        value_learning_rate: 1e-3,
        clip_epsilon: 0.3,
        value_loss_coeff: 2.0,
        entropy_coeff: 0.1,
        minibatch_size: 1024,
    };

    let continuous = params.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).expect("Failed to recover params");

    assert_eq!(
        recovered.minibatch_size, 1024,
        "minibatch_size should roundtrip correctly"
    );
}

#[test]
fn test_minibatch_size_roundtrip_2048() {
    // Test that minibatch_size=2048 (max) survives roundtrip conversion
    let params = PPOParams {
        policy_learning_rate: 1e-4,
        value_learning_rate: 1e-3,
        clip_epsilon: 0.3,
        value_loss_coeff: 2.0,
        entropy_coeff: 0.1,
        minibatch_size: 2048,
    };

    let continuous = params.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).expect("Failed to recover params");

    assert_eq!(
        recovered.minibatch_size, 2048,
        "minibatch_size should roundtrip correctly"
    );
}

#[test]
fn test_minibatch_size_discrete_sampling() {
    // Test that minibatch_size uses discrete sampling from valid divisors
    // Valid divisors of batch_size=2048: [64, 128, 256, 512, 1024, 2048]

    // Test index 0 -> 64
    let idx0 = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        0.0,           // minibatch_size index (0 -> 64)
    ];
    let params0 = PPOParams::from_continuous(&idx0).expect("Failed to parse params");
    assert_eq!(
        params0.minibatch_size, 64,
        "Index 0 should map to minibatch_size=64"
    );

    // Test index 3 -> 512
    let idx3 = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        3.0,           // minibatch_size index (3 -> 512)
    ];
    let params3 = PPOParams::from_continuous(&idx3).expect("Failed to parse params");
    assert_eq!(
        params3.minibatch_size, 512,
        "Index 3 should map to minibatch_size=512"
    );

    // Test index 5 -> 2048
    let idx5 = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        5.0,           // minibatch_size index (5 -> 2048)
    ];
    let params5 = PPOParams::from_continuous(&idx5).expect("Failed to parse params");
    assert_eq!(
        params5.minibatch_size, 2048,
        "Index 5 should map to minibatch_size=2048"
    );
}

#[test]
fn test_minibatch_size_index_bounds() {
    // Test that from_continuous clamps index to [0, 5]

    // Test below min (-1.0 should clamp to 0)
    let below_min = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        -1.0,          // minibatch_size index (below min)
    ];
    let params_below = PPOParams::from_continuous(&below_min).expect("Failed to parse params");
    assert_eq!(
        params_below.minibatch_size, 64,
        "Index below 0 should clamp to 0 (minibatch_size=64)"
    );

    // Test above max (6.0 should clamp to 5)
    let above_max = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        6.0,           // minibatch_size index (above max)
    ];
    let params_above = PPOParams::from_continuous(&above_max).expect("Failed to parse params");
    assert_eq!(
        params_above.minibatch_size, 2048,
        "Index above 5 should clamp to 5 (minibatch_size=2048)"
    );
}

#[test]
fn test_minibatch_size_index_rounding() {
    // Test that fractional index values are rounded correctly

    // Test 2.3 -> rounds to 2 -> 256
    let fractional_down = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        2.3,           // minibatch_size index (fractional)
    ];
    let params_down = PPOParams::from_continuous(&fractional_down).expect("Failed to parse params");
    assert_eq!(
        params_down.minibatch_size, 256,
        "Index 2.3 should round to 2 (minibatch_size=256)"
    );

    // Test 2.8 -> rounds to 3 -> 512
    let fractional_up = vec![
        1e-5_f64.ln(), // policy_learning_rate
        1e-4_f64.ln(), // value_learning_rate
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        2.8,           // minibatch_size index (fractional)
    ];
    let params_up = PPOParams::from_continuous(&fractional_up).expect("Failed to parse params");
    assert_eq!(
        params_up.minibatch_size, 512,
        "Index 2.8 should round to 3 (minibatch_size=512)"
    );
}

#[test]
fn test_parameter_space_includes_minibatch_size() {
    // Verify that continuous_bounds includes minibatch_size as 6th parameter
    let bounds = PPOParams::continuous_bounds();

    assert_eq!(
        bounds.len(),
        6,
        "Should have 6 parameters (including minibatch_size)"
    );
    assert_eq!(
        bounds[5],
        (0.0, 5.0),
        "6th parameter should be minibatch_size index with bounds [0, 5]"
    );
}

#[test]
fn test_param_names_includes_minibatch_size() {
    // Verify that param_names includes minibatch_size as 6th parameter
    let names = PPOParams::param_names();

    assert_eq!(names.len(), 6, "Should have 6 parameter names");
    assert_eq!(
        names[5], "minibatch_size",
        "6th parameter name should be 'minibatch_size'"
    );
}

#[test]
fn test_default_minibatch_size() {
    // Verify that default PPOParams has minibatch_size=128
    let params = PPOParams::default();
    assert_eq!(
        params.minibatch_size, 128,
        "Default minibatch_size should be 128"
    );
}

#[test]
fn test_serde_backward_compatibility() {
    // Test that old PPOParams JSON (without minibatch_size) deserializes correctly
    let old_json = r#"{
        "policy_learning_rate": 0.00003,
        "value_learning_rate": 0.0001,
        "clip_epsilon": 0.2,
        "value_loss_coeff": 1.0,
        "entropy_coeff": 0.05
    }"#;

    let params: PPOParams = serde_json::from_str(old_json)
        .expect("Should deserialize old format with default minibatch_size");

    assert_eq!(
        params.minibatch_size, 128,
        "Missing minibatch_size should default to 128 (backward compatibility)"
    );
}