Struct Optimizer 

pub struct Optimizer<KInit, P, M> {
    pub cutoff: f64,
    pub n_candidates: usize,
    pub bandwidth: P,
    /* 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

Fields

cutoff: f64

n_candidates: usize

bandwidth: P

Implementations

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

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

where P: One,

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 fn cutoff(self, cutoff: impl Into<f64>) -> Self

Set the ratio of «good» trials.

pub fn n_candidates(self, n_candidates: impl Into<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 bandwidth(self, bandwidth: impl Into<P>) -> Self

Set the bandwidth multiplier for the estimator kernels.

Standard deviation of the kernel is the distance from the point to its furthest neighbour, multiplied by this coefficient.

The default multiplier is [P::one]. Lower bandwidth approximates the density better, however, is also prone to over-fitting. Higher bandwidth avoid over-fitting better, but is also smoother and less precise.

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: Copy + Ord + SelfSub + SelfMul,

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.