Struct hyperopt::Optimizer

pub struct Optimizer<KInit, P, M> { /* private fields */ }

✨ Hyperparameter optimizer.

Generic parameters

• [KInit]: kernel type of the initial (prior) estimator component
• [P]: type of parameter that is optimized
• [M]: value of the target function, the less – the better

Implementations

impl<KInit, P, M> Optimizer<KInit, P, M>

pub const fn new(range: RangeInclusive<P>, init_kernel: KInit, rng: Rng) -> Self

Construct the new optimizer.

Here begins your adventure!

Parameters

• range: parameter search range, Optimizer will clamp random samples to this range
• init_kernel: your prior belief about which values of the searched parameter is more optimal
• kernel: kernel for the trial components

pub const fn cutoff(self, cutoff: f64) -> Self

Set the ratio of «good» trials.

pub const fn n_candidates(self, n_candidates: usize) -> Self

Set the number of candidates to choose the next trial from the acquisition function¹.

Sampling from the acquisition function is cheaper than evaluating the target cost function, so the more candidates – the more effective is the optimization step.

However, the acquisition function is an approximation of a potential gain, so the fewer candidates – the more precise is the optimization step.

The number of candidates is therefore a tradeoff.

---

1. Acquisition function is basically a ratio between the «good» KDE and «bad» KDE at the same point. ↩

pub fn feed_back(&mut self, parameter: P, metric: M)

where P: Copy + Debug + Ord, M: Debug + Ord,

Provide the information about the trial, or in other words, «fit» the optimizer on the sample.

Normally, you’ll call your target function on parameters supplied by Optimizer::new_trial, and feed back the results. But you also can feed it with any arbitrary parameters.

Parameters

• parameter: the target function parameter
• metric: the target function metric

pub fn new_trial<K>(&mut self) -> P

where KInit: Copy + Density<Param = P> + Sample<Param = P>, KInit::Output: Copy + Debug + Ord + Multiplicative + FromPrimitive + Zero, K: Copy + Kernel<Param = P> + Sample<Param = P> + Density<Param = P, Output = <KInit as Density>::Output>, P: Additive + Copy + Ord,

Generate a parameter value for a new trial.

After evaluating the target function with this parameter, you’d better feed the metric back with Optimizer::feed_back.

Type parameters

• [K]: kernel type
• [D]: kernel density type

Panics

This method may panic if a random or calculated number cannot be converted to the parameter or density type.

pub fn best_trial(&self) -> Option<&Trial<P, M>>

where P: Ord, M: Ord,

Get the best trial.

Trait Implementations

impl<KInit: Debug, P: Debug, M: Debug> Debug for Optimizer<KInit, P, M>

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

Formats the value using the given formatter.