foxhunt/ml/tests/ppo_hyperopt_value_lr_test.rs

//! PPO Hyperopt Value LR Upper Bound Tests
//!
//! These tests verify the expanded value learning rate upper bound (5e-3)
//! based on DQN Trial #19 breakthrough findings.

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

#[test]
fn test_value_lr_upper_bound_expanded() {
    let bounds = PPOParams::continuous_bounds();
    let value_lr_bounds = bounds[1]; // value_learning_rate is 2nd parameter (index 1)

    // Upper bound should be ln(5e-3) = -5.298317366548036
    let expected_upper = 5e-3_f64.ln();
    let actual_upper = value_lr_bounds.1;

    assert!(
        (actual_upper - expected_upper).abs() < 1e-6,
        "Value LR upper bound should be ln(5e-3) = {:.6}, got {:.6}",
        expected_upper,
        actual_upper
    );
}

#[test]
fn test_value_lr_range_valid() {
    // Test that 5e-3 is correctly converted from continuous space
    let params = PPOParams::from_continuous(&[
        1e-6_f64.ln(), // policy_lr
        5e-3_f64.ln(), // value_lr (NEW UPPER BOUND)
        0.2,           // clip_epsilon
        1.0,           // value_loss_coeff
        0.01_f64.ln(), // entropy_coeff
        128.0,         // minibatch_size
    ])
    .unwrap();

    // Verify value_lr is correctly decoded as 0.005
    assert!(
        (params.value_learning_rate - 0.005).abs() < 1e-6,
        "Value LR should be 0.005, got {}",
        params.value_learning_rate
    );
}

#[test]
fn test_value_lr_bounds_log_scale() {
    let bounds = PPOParams::continuous_bounds();
    let value_lr_bounds = bounds[1];

    // Verify lower bound is ln(1e-5) = -11.512925
    let expected_lower = 1e-5_f64.ln();
    let actual_lower = value_lr_bounds.0;

    assert!(
        (actual_lower - expected_lower).abs() < 1e-6,
        "Value LR lower bound should be ln(1e-5) = {:.6}, got {:.6}",
        expected_lower,
        actual_lower
    );

    // Verify upper bound is ln(5e-3) = -5.298317
    let expected_upper = 5e-3_f64.ln();
    let actual_upper = value_lr_bounds.1;

    assert!(
        (actual_upper - expected_upper).abs() < 1e-6,
        "Value LR upper bound should be ln(5e-3) = {:.6}, got {:.6}",
        expected_upper,
        actual_upper
    );
}

#[test]
fn test_value_lr_range_expansion() {
    // Verify that new range (1e-5 to 5e-3) is 5x larger than old range (1e-5 to 1e-3)
    let bounds = PPOParams::continuous_bounds();
    let value_lr_bounds = bounds[1];

    let lower_exp = value_lr_bounds.0.exp();
    let upper_exp = value_lr_bounds.1.exp();

    assert!(
        (lower_exp - 1e-5).abs() < 1e-8,
        "Lower bound should be 1e-5, got {:.6e}",
        lower_exp
    );

    assert!(
        (upper_exp - 5e-3).abs() < 1e-6,
        "Upper bound should be 5e-3, got {:.6e}",
        upper_exp
    );

    // Range ratio: (5e-3 / 1e-5) / (1e-3 / 1e-5) = 500 / 100 = 5
    let new_range_ratio = upper_exp / lower_exp;
    let old_range_ratio = 1e-3 / 1e-5;
    let expansion_factor = new_range_ratio / old_range_ratio;

    assert!(
        (expansion_factor - 5.0).abs() < 1e-6,
        "Range expansion should be 5x, got {:.2}x",
        expansion_factor
    );
}

#[test]
fn test_roundtrip_with_new_upper_bound() {
    // Test full roundtrip conversion with new upper bound
    let original = PPOParams {
        policy_learning_rate: 1e-6,
        value_learning_rate: 5e-3, // NEW UPPER BOUND
        clip_epsilon: 0.2,
        value_loss_coeff: 1.0,
        entropy_coeff: 0.01,
        minibatch_size: 128,
    };

    let continuous = original.to_continuous();
    let recovered = PPOParams::from_continuous(&continuous).unwrap();

    assert!(
        (recovered.value_learning_rate - original.value_learning_rate).abs() < 1e-10,
        "Roundtrip should preserve value_lr: expected {:.6e}, got {:.6e}",
        original.value_learning_rate,
        recovered.value_learning_rate
    );
}

#[test]
fn test_policy_lr_narrowed() {
    // Verify that policy LR was narrowed from 1e-3 to 5e-5 (based on DQN findings)
    let bounds = PPOParams::continuous_bounds();
    let policy_lr_bounds = bounds[0];

    // Upper bound should be ln(5e-5) = -9.903488
    let expected_upper = 5e-5_f64.ln();
    let actual_upper = policy_lr_bounds.1;

    assert!(
        (actual_upper - expected_upper).abs() < 1e-6,
        "Policy LR upper bound should be ln(5e-5) = {:.6}, got {:.6}",
        expected_upper,
        actual_upper
    );
}

#[test]
fn test_minibatch_size_bounds() {
    // Verify minibatch_size bounds are correct (VRAM limited)
    let bounds = PPOParams::continuous_bounds();
    let minibatch_bounds = bounds[5];

    assert_eq!(
        minibatch_bounds.0, 64.0,
        "Minibatch lower bound should be 64"
    );
    assert_eq!(
        minibatch_bounds.1, 230.0,
        "Minibatch upper bound should be 230"
    );
}

#[test]
fn test_six_parameters() {
    // Verify we have exactly 6 parameters
    let bounds = PPOParams::continuous_bounds();
    assert_eq!(
        bounds.len(),
        6,
        "PPOParams should have 6 continuous parameters"
    );

    let names = PPOParams::param_names();
    assert_eq!(names.len(), 6, "PPOParams should have 6 parameter names");

    assert_eq!(names[0], "policy_learning_rate");
    assert_eq!(names[1], "value_learning_rate");
    assert_eq!(names[2], "clip_epsilon");
    assert_eq!(names[3], "value_loss_coeff");
    assert_eq!(names[4], "entropy_coeff");
    assert_eq!(names[5], "minibatch_size");
}