optimizer 1.0.1

Bayesian and population-based optimization library with an Optuna-like API for hyperparameter tuning and black-box optimization
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Stress and large-scale tests for the optimizer library.
//!
//! All tests are `#[ignore]`-gated so they don't run in normal CI.
//! Run with: `cargo test --features async -- --ignored`

#[cfg(feature = "async")]
use std::collections::HashSet;

use optimizer::parameter::{FloatParam, Parameter};
use optimizer::sampler::random::RandomSampler;
use optimizer::sampler::tpe::TpeSampler;
use optimizer::{Direction, Error, Study};

fn make_float_params(n: usize) -> Vec<FloatParam> {
    (0..n)
        .map(|i| FloatParam::new(-5.0, 5.0).name(format!("x{i}")))
        .collect()
}

fn sphere(trial: &mut optimizer::Trial, params: &[FloatParam]) -> Result<f64, Error> {
    let mut sum = 0.0;
    for p in params {
        let v = p.suggest(trial)?;
        sum += v * v;
    }
    Ok(sum)
}

#[test]
#[ignore]
fn stress_many_trials_random() {
    let sampler = RandomSampler::with_seed(42);
    let study: Study<f64> = Study::with_sampler(Direction::Minimize, sampler);
    let params = make_float_params(5);

    study
        .optimize(10_000, |trial: &mut optimizer::Trial| {
            sphere(trial, &params)
        })
        .expect("10k trials should complete");

    assert_eq!(study.n_trials(), 10_000);
    let best = study.best_value().expect("should have a best value");
    assert!(best.is_finite(), "best value should be finite");
    assert!(best >= 0.0, "sphere function is non-negative");
}

#[test]
#[ignore]
fn stress_many_params_tpe() {
    let sampler = TpeSampler::builder()
        .seed(42)
        .n_startup_trials(10)
        .build()
        .unwrap();
    let study: Study<f64> = Study::with_sampler(Direction::Minimize, sampler);
    let params = make_float_params(128);

    study
        .optimize(200, |trial: &mut optimizer::Trial| sphere(trial, &params))
        .expect("200 trials with 128 params should complete");

    assert_eq!(study.n_trials(), 200);

    let best = study.best_trial().expect("should have a best trial");
    assert_eq!(best.params.len(), 128, "best trial should have 128 params");
    assert!(best.value.is_finite(), "best value should be finite");
    for v in best.params.values() {
        let f = match v {
            optimizer::param::ParamValue::Float(f) => *f,
            other => panic!("expected Float param, got {other}"),
        };
        assert!(f.is_finite(), "all param values should be finite");
    }
}

#[cfg(feature = "async")]
#[tokio::test]
#[ignore]
async fn stress_high_concurrency_parallel() {
    let sampler = RandomSampler::with_seed(42);
    let study: Study<f64> = Study::with_sampler(Direction::Minimize, sampler);
    let params = make_float_params(10);

    study
        .optimize_parallel(1_000, 128, move |trial: &mut optimizer::Trial| {
            sphere(trial, &params)
        })
        .await
        .expect("1k trials with 128 workers should complete");

    assert_eq!(study.n_trials(), 1_000);

    let trials = study.trials();
    let ids: HashSet<u64> = trials.iter().map(|t| t.id).collect();
    assert_eq!(ids.len(), 1_000, "all trial IDs should be unique");

    let best = study.best_value().expect("should have a best value");
    assert!(best.is_finite(), "best value should be finite");
}

#[cfg(feature = "async")]
#[tokio::test]
#[ignore]
async fn stress_long_running_tpe_parallel() {
    let sampler = TpeSampler::builder()
        .seed(42)
        .n_startup_trials(20)
        .build()
        .unwrap();
    let study: Study<f64> = Study::with_sampler(Direction::Minimize, sampler);
    let params = make_float_params(20);

    study
        .optimize_parallel(5_000, 32, move |trial: &mut optimizer::Trial| {
            sphere(trial, &params)
        })
        .await
        .expect("5k trials with TPE and 32 workers should complete");

    assert_eq!(study.n_trials(), 5_000);

    let trials = study.trials();
    let ids: HashSet<u64> = trials.iter().map(|t| t.id).collect();
    assert_eq!(ids.len(), 5_000, "all trial IDs should be unique");

    let best = study.best_trial().expect("should have a best trial");
    assert!(best.value.is_finite(), "best value should be finite");
    assert_eq!(best.params.len(), 20, "best trial should have 20 params");
}