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

#[allow(dead_code)]
mod test_functions;

use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
use optimizer::Study;
use optimizer::parameter::{FloatParam, Parameter};
use optimizer::sampler::random::RandomSampler;
use optimizer::sampler::tpe::TpeSampler;

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

fn bench_tpe_sphere(c: &mut Criterion) {
    let mut group = c.benchmark_group("tpe_sphere");
    group.sample_size(10);

    for dims in [2, 10, 50] {
        let params = make_params(dims);
        group.bench_with_input(BenchmarkId::new("dims", dims), &params, |b, params| {
            b.iter(|| {
                let study = Study::minimize(TpeSampler::builder().seed(42).build().unwrap());
                study
                    .optimize(100, |trial: &mut optimizer::Trial| {
                        let x: Vec<f64> = params
                            .iter()
                            .map(|p| p.suggest(trial))
                            .collect::<Result<_, _>>()
                            .unwrap();
                        Ok::<_, optimizer::Error>(test_functions::sphere(&x))
                    })
                    .unwrap();
            });
        });
    }
    group.finish();
}

fn bench_tpe_rosenbrock(c: &mut Criterion) {
    let mut group = c.benchmark_group("tpe_rosenbrock");
    group.sample_size(10);

    for dims in [2, 10] {
        let params = make_params(dims);
        group.bench_with_input(BenchmarkId::new("dims", dims), &params, |b, params| {
            b.iter(|| {
                let study = Study::minimize(TpeSampler::builder().seed(42).build().unwrap());
                study
                    .optimize(100, |trial: &mut optimizer::Trial| {
                        let x: Vec<f64> = params
                            .iter()
                            .map(|p| p.suggest(trial))
                            .collect::<Result<_, _>>()
                            .unwrap();
                        Ok::<_, optimizer::Error>(test_functions::rosenbrock(&x))
                    })
                    .unwrap();
            });
        });
    }
    group.finish();
}

fn bench_random_vs_tpe(c: &mut Criterion) {
    let mut group = c.benchmark_group("random_vs_tpe");
    group.sample_size(10);
    let params = make_params(5);

    group.bench_function("random_5d", |b| {
        b.iter(|| {
            let study = Study::minimize(RandomSampler::with_seed(42));
            study
                .optimize(100, |trial: &mut optimizer::Trial| {
                    let x: Vec<f64> = params
                        .iter()
                        .map(|p| p.suggest(trial))
                        .collect::<Result<_, _>>()
                        .unwrap();
                    Ok::<_, optimizer::Error>(test_functions::sphere(&x))
                })
                .unwrap();
        });
    });

    group.bench_function("tpe_5d", |b| {
        b.iter(|| {
            let study = Study::minimize(TpeSampler::builder().seed(42).build().unwrap());
            study
                .optimize(100, |trial: &mut optimizer::Trial| {
                    let x: Vec<f64> = params
                        .iter()
                        .map(|p| p.suggest(trial))
                        .collect::<Result<_, _>>()
                        .unwrap();
                    Ok::<_, optimizer::Error>(test_functions::sphere(&x))
                })
                .unwrap();
        });
    });

    group.finish();
}

criterion_group!(
    benches,
    bench_tpe_sphere,
    bench_tpe_rosenbrock,
    bench_random_vs_tpe
);
criterion_main!(benches);