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

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

#[test]
fn test_builder_defaults() {
    let study: Study<f64> = Study::builder().build();
    assert_eq!(study.direction(), Direction::Minimize);
}

#[test]
fn test_builder_maximize() {
    let study: Study<f64> = Study::builder().maximize().build();
    assert_eq!(study.direction(), Direction::Maximize);
}

#[test]
fn test_builder_minimize() {
    let study: Study<f64> = Study::builder().minimize().build();
    assert_eq!(study.direction(), Direction::Minimize);
}

#[test]
fn test_builder_direction() {
    let study: Study<f64> = Study::builder().direction(Direction::Maximize).build();
    assert_eq!(study.direction(), Direction::Maximize);
}

#[test]
fn test_builder_with_sampler() {
    let x = FloatParam::new(-5.0, 5.0);
    let study: Study<f64> = Study::builder().sampler(TpeSampler::new()).build();

    study
        .optimize(10, |trial: &mut optimizer::Trial| {
            let val = x.suggest(trial)?;
            Ok::<_, Error>(val * val)
        })
        .unwrap();

    assert_eq!(study.trials().len(), 10);
}

#[test]
fn test_builder_with_pruner() {
    use optimizer::pruner::NopPruner;

    let study: Study<f64> = Study::builder().pruner(NopPruner).build();

    assert_eq!(study.direction(), Direction::Minimize);
}

#[test]
fn test_builder_chaining() {
    let study: Study<f64> = Study::builder()
        .maximize()
        .sampler(RandomSampler::with_seed(42))
        .pruner(optimizer::pruner::NopPruner)
        .build();

    assert_eq!(study.direction(), Direction::Maximize);
}

#[test]
fn test_builder_with_custom_value_type() {
    let study: Study<i32> = Study::builder().maximize().build();
    assert_eq!(study.direction(), Direction::Maximize);
}

#[test]
fn test_builder_optimizes_correctly() {
    let x = FloatParam::new(-10.0, 10.0);
    let study: Study<f64> = Study::builder()
        .minimize()
        .sampler(TpeSampler::builder().seed(42).build().unwrap())
        .build();

    study
        .optimize(100, |trial: &mut optimizer::Trial| {
            let val = x.suggest(trial)?;
            Ok::<_, Error>((val - 3.0) * (val - 3.0))
        })
        .unwrap();

    let best = study.best_trial().unwrap();
    assert!(
        best.value < 5.0,
        "best value should be < 5.0, got {}",
        best.value
    );
}