Skip to main content

ctrl_freeq/optim/
derivative_free.rs

1//! Derivative-free optimisers: COBYLA and BOBYQA.
2//!
3//! Both run to completion inside a single call, so the stop checks live in the objective wrapper: once a stop is
4//! due, COBYLA's force-stop flag is raised, and BOBYQA is handed a value below its target, which it treats as
5//! success.  One iteration is one function evaluation, as in the Python package.
6
7use std::cell::{Cell, RefCell};
8
9use super::{Derivatives, Exit, Monitor, Objective, OptimResult, Optimizer, RunControl};
10use crate::error::{Error, Result};
11
12/// Half-width of the box the parameters are kept in.  Basis coefficients stay far inside it; derivative-free
13/// solvers need a finite box.
14const BOX: f64 = 100.0;
15
16fn bounds(x0: &[f64]) -> (Vec<f64>, Vec<f64>) {
17    let half = x0.iter().fold(BOX, |m, v| m.max(2.0 * v.abs()));
18    (vec![-half; x0.len()], vec![half; x0.len()])
19}
20
21/// Evaluate, record and report one point; `Err` is remembered and ends the run.
22fn step(monitor: &mut Monitor, error: &mut Option<Error>, obj: &dyn Objective, x: &[f64]) -> Option<f64> {
23    match obj.value(x) {
24        Ok(e) => {
25            monitor.evaluated(x, e);
26            let n = monitor.evaluations;
27            monitor.report(n, e, None);
28            Some(e.cost)
29        }
30        Err(err) => {
31            *error = Some(err);
32            None
33        }
34    }
35}
36
37fn failed(monitor: Monitor, error: Error) -> Result<OptimResult> {
38    let n = monitor.evaluations;
39    if monitor.best.is_some() {
40        monitor.finish(n, Exit::Failed(error.to_string()))
41    } else {
42        Err(error)
43    }
44}
45
46/// COBYLA, Powell's linear-approximation trust-region method.  Initial trust radius 1.0, as in scipy.
47#[derive(Clone, Copy, Debug, Default)]
48pub struct Cobyla;
49
50impl Optimizer for Cobyla {
51    fn name(&self) -> &'static str {
52        "cobyla"
53    }
54
55    fn derivatives(&self) -> Derivatives {
56        Derivatives::None
57    }
58
59    fn minimize(&self, obj: &dyn Objective, x0: &[f64], ctl: &mut RunControl) -> Result<OptimResult> {
60        let (lower, upper) = bounds(x0);
61        let stop = Cell::new(0);
62        let state = RefCell::new((Monitor::new(ctl), None::<Error>));
63        let (status, _, _) = super::cobyla::minimize(
64            |x| {
65                let mut guard = state.borrow_mut();
66                let (monitor, error) = &mut *guard;
67                let value = step(monitor, error, obj, x);
68                if monitor.exit.is_some() || error.is_some() {
69                    stop.set(1);
70                }
71                value.unwrap_or(f64::MAX)
72            },
73            x0,
74            &lower,
75            &upper,
76            1.0,
77            usize::MAX,
78            &stop,
79        );
80        let (monitor, error) = state.into_inner();
81        if let Some(e) = error {
82            return failed(monitor, e);
83        }
84        let n = monitor.evaluations;
85        let exit = match status {
86            super::cobyla::Status::Failed(m) => Exit::Failed(m.into()),
87            super::cobyla::Status::MaxEvalReached => Exit::MaxIterations,
88            _ => Exit::Converged,
89        };
90        monitor.finish(n, exit)
91    }
92}
93
94/// BOBYQA, Powell's bound-constrained quadratic-model trust-region method.  Initial trust radius 0.5.
95#[derive(Clone, Copy, Debug, Default)]
96pub struct Bobyqa;
97
98impl Optimizer for Bobyqa {
99    fn name(&self) -> &'static str {
100        "bobyqa"
101    }
102
103    fn derivatives(&self) -> Derivatives {
104        Derivatives::None
105    }
106
107    fn minimize(&self, obj: &dyn Objective, x0: &[f64], ctl: &mut RunControl) -> Result<OptimResult> {
108        let n = x0.len();
109        if n < 2 {
110            return Err(Error::NotSupported("BOBYQA needs at least two parameters".into()));
111        }
112        let (lower, upper) = bounds(x0);
113        let f_target = -ctl.target_fidelity;
114        let mut config = bobyqa::Config::new(n);
115        config.rho_begin = 0.5;
116        config.rho_end = 1e-8;
117        config.f_target = f_target;
118        // The monitor ends the run at `max_iter` evaluations; BOBYQA only needs a budget above its `npt`
119        // initial points, and sizes its history by it.
120        config.max_fun = (ctl.max_iter + 1).max(config.npt + 1);
121        let mut solver = bobyqa::Bobyqa::new(n, config)
122            .map_err(|s| Error::Numerical(format!("BOBYQA refused its settings: {s}")))?;
123        let mut monitor = Monitor::new(ctl);
124        let mut error = None;
125        let mut x = x0.to_vec();
126        let outcome = solver.minimize(
127            |x| {
128                if monitor.exit.is_some() || error.is_some() {
129                    return f_target - 1.0;
130                }
131                let value = step(&mut monitor, &mut error, obj, x);
132                if monitor.exit.is_some() || error.is_some() {
133                    f_target - 1.0
134                } else {
135                    value.unwrap_or(f64::MAX)
136                }
137            },
138            &mut x,
139            &lower,
140            &upper,
141        );
142        if let Some(e) = error {
143            return failed(monitor, e);
144        }
145        let iterations = monitor.evaluations;
146        let exit = match outcome.status {
147            bobyqa::Status::MaxFunReached => Exit::MaxIterations,
148            bobyqa::Status::InvalidArgs | bobyqa::Status::AllocationFailed => {
149                Exit::Failed(format!("BOBYQA: {}", outcome.status))
150            }
151            _ => Exit::Converged,
152        };
153        monitor.finish(iterations, exit)
154    }
155}