Struct tpe::TpeOptimizer

pub struct TpeOptimizer<T = DefaultEstimatorBuilder> { /* fields omitted */ }

Optimizer using TPE.

This try to search out the parameter value which could minimize the evaluation result.

Note that an instance of TpeOptimizer can handle only one hyperparameter. So if you want to optimize multiple hyperparameters simultaneously, please create an optimizer for each hyperparameter.

Implementations

impl<T: BuildDensityEstimator> TpeOptimizer<T>

pub fn new(estimator_builder: T, param_range: Range) -> Self

Makes a new TpeOptimizer with the default settings.

If you want to customize the settings, please use TpeOptimizerBuilder instead.

pub fn ask<R: Rng + ?Sized>(&mut self, rng: &mut R) -> Result<f64, T::Error>

Returns the next value of the optimization target parameter to be evaluated.

Note that, before the first asking, it might be worth to give some evaluation results of randomly sampled observations to TpeOptimizer (via the tell method) to reduce bias due to too few samples.

pub fn tell(&mut self, param: f64, value: f64) -> Result<(), TellError>

Tells the evaluation result of a hyperparameter value to the optimizer.

Note that the param should be NaN if the hyperparameter was not used in the evaluation (this could be happen when the entire search space is conditional).

pub fn trials(&self) -> impl '_ + Iterator<Item = (f64, f64)>

Retruns all told parameter and objective values.

Note that the order of items in the returned iterator doesn’t reflect the order TpeOptimizer::tell called.

Examples

You can this method to store and load the state of a TpeOptimizer.

let temp_file = tempfile::NamedTempFile::new()?;
let mut rng = rand::thread_rng();

fn objective(x: f64) -> f64 {
    x.powi(2)
}

{
    let mut optim =
        tpe::TpeOptimizer::new(tpe::parzen_estimator(), tpe::range(-5.0, 5.0)?);

    // Runs 100 trials.
    for _ in 0..100 {
        let x = optim.ask(&mut rng)?;
        let v = objective(x);
        optim.tell(x, v)?;
    }

    // Stores the trials.
    let mut file = std::fs::OpenOptions::new()
        .write(true)
        .open(temp_file.path())?;
    serde_json::to_writer(&mut file, &optim.trials().collect::<Vec<_>>())?;
}

{
    let mut optim =
        tpe::TpeOptimizer::new(tpe::parzen_estimator(), tpe::range(-5.0, 5.0)?);

    // Loads the previous trials.
    let mut file = std::fs::File::open(temp_file.path())?;
    let trials: Vec<(f64, f64)> = serde_json::from_reader(&mut file)?;
    for (x, v) in trials {
        optim.tell(x, v)?;
    }

    // Runs additional 100 trials.
    for _ in 0..100 {
        let x = optim.ask(&mut rng)?;
        let v = objective(x);
        optim.tell(x, v)?;
    }
    assert_eq!(optim.trials().count(), 200);
}

Trait Implementations

impl<T: Debug> Debug for TpeOptimizer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.