Struct argmin::solver::trustregion::trustregion_method::TrustRegion

pub struct TrustRegion<'a, O> where
    O: 'a + ArgminOp<Output = f64>,
    <O as ArgminOp>::Param: ArgminMul<f64, <O as ArgminOp>::Param> + ArgminWeightedDot<<O as ArgminOp>::Param, f64, <O as ArgminOp>::Hessian> + ArgminNorm<f64> + ArgminDot<<O as ArgminOp>::Param, f64> + ArgminAdd<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminSub<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminZero + ArgminMul<f64, <O as ArgminOp>::Param>,
    <O as ArgminOp>::Hessian: ArgminDot<<O as ArgminOp>::Param, <O as ArgminOp>::Param>,  { /* fields omitted */ }

The trust region method approximates the cost function within a certain region around the current point in parameter space. Depending on the quality of this approximation, the region is either expanded or contracted.

The calculation of the actual step length and direction is done by one of the following methods:

• Cauchy point
• Dogleg method
• Steihaug method

This subproblem can be set via set_subproblem(...). If this is not provided, it will default to the Steihaug method.

Example

extern crate argmin;
extern crate ndarray;
use argmin::prelude::*;
use argmin::solver::trustregion::{CauchyPoint, Dogleg, Steihaug, TrustRegion};
use argmin::testfunctions::{rosenbrock_2d, rosenbrock_2d_derivative, rosenbrock_2d_hessian};
use ndarray::{Array, Array1, Array2};

// Define cost function
let cost = MyProblem {};

// Define inital parameter vector
// easy case
// let init_param: Array1<f64> = Array1::from_vec(vec![1.2, 1.2]);
// tough case
let init_param: Array1<f64> = Array1::from_vec(vec![-1.2, 1.0]);

// Set up solver
let mut solver = TrustRegion::new(cost.clone(), init_param);

// Set method for subproblem. Optional: If not provided, it will default to `Steihaug` method
// let subproblem = Box::new(CauchyPoint::new(cost));
let subproblem = Box::new(Dogleg::new(cost));
// let mut subproblem = Box::new(Steihaug::new(cost));
solver.set_subproblem(subproblem);

// Set the maximum number of iterations
solver.set_max_iters(2_000);

// Attach a logger
solver.add_logger(ArgminSlogLogger::term());

// Run solver
solver.run()?;

// Wait a second (lets the logger flush everything before printing again)
std::thread::sleep(std::time::Duration::from_secs(1));

// Print result
println!("{:?}", solver.result());

References:

[0] Jorge Nocedal and Stephen J. Wright (2006). Numerical Optimization. Springer. ISBN 0-387-30303-0.

Methods

impl<'a, O> TrustRegion<'a, O> where
    O: 'a + ArgminOp<Output = f64>,
    <O as ArgminOp>::Param: ArgminMul<f64, <O as ArgminOp>::Param> + ArgminWeightedDot<<O as ArgminOp>::Param, f64, <O as ArgminOp>::Hessian> + ArgminNorm<f64> + ArgminDot<<O as ArgminOp>::Param, f64> + ArgminAdd<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminSub<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminZero + ArgminMul<f64, <O as ArgminOp>::Param>,
    <O as ArgminOp>::Hessian: ArgminDot<<O as ArgminOp>::Param, <O as ArgminOp>::Param>, 

pub fn new(operator: O, param: <O as ArgminOp>::Param) -> Self

Constructor

Parameters:

operator: operator

pub fn set_radius(&mut self, radius: f64) -> &mut Self

set radius

pub fn set_max_radius(&mut self, max_radius: f64) -> &mut Self

Set maximum radius

pub fn set_eta(&mut self, eta: f64) -> Result<&mut Self, Error>

Set eta

pub fn set_subproblem(
    &mut self,
    subproblem: Box<dyn ArgminTrustRegion<Param = <O as ArgminOp>::Param, Output = f64, Hessian = <O as ArgminOp>::Hessian> + 'a>
) -> &mut Self

Set subproblem

Trait Implementations

impl<'a, O> ArgminSolver for TrustRegion<'a, O> where
    O: 'a + ArgminOp<Output = f64>,
    <O as ArgminOp>::Param: ArgminMul<f64, <O as ArgminOp>::Param> + ArgminWeightedDot<<O as ArgminOp>::Param, f64, <O as ArgminOp>::Hessian> + ArgminNorm<f64> + ArgminDot<<O as ArgminOp>::Param, f64> + ArgminAdd<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminSub<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminZero + ArgminMul<f64, <O as ArgminOp>::Param>,
    <O as ArgminOp>::Hessian: ArgminDot<<O as ArgminOp>::Param, <O as ArgminOp>::Param>, 

fn run(&mut self) -> Result<ArgminResult<Self::Param>, Error>

Run the optimization algorithm

fn run_fast(&mut self) -> Result<ArgminResult<Self::Param>, Error>

Run the essential parts of the optimization algorithm (no logging, no Ctrl-C handling)

fn apply(&mut self, param: &Self::Param) -> Result<Self::Output, Error>

Applies the cost function or operator to a parameter vector param. Returns an Err if apply of ArgminOperator is not implemented.

fn gradient(&mut self, param: &Self::Param) -> Result<Self::Param, Error>

Computes the gradient at parameter param. Returns an Err if gradient of ArgminOperator is not implemented.

fn hessian(&mut self, param: &Self::Param) -> Result<Self::Hessian, Error>

Computes the Hessian at parameter param. Returns an Err if hessian of ArgminOperator is not implemented.

fn cur_param(&self) -> Self::Param

Returns the current parameter vector.

fn cur_grad(&self) -> Self::Param

Returns the most recently stored gradient.

fn cur_hessian(&self) -> Self::Hessian

Returns the most recently stored Hessian.

fn set_cur_param(&mut self, param: Self::Param)

Sets the current parameter to param.

fn set_cur_grad(&mut self, grad: Self::Param)

Sets the current gradient to grad.

fn set_cur_hessian(&mut self, hessian: Self::Hessian)

Sets the current Hessian to hessian.

fn set_best_param(&mut self, param: Self::Param)

Sets the best parameter vector to param.

fn modify(&self, param: &Self::Param, factor: f64) -> Result<Self::Param, Error>

Modify the parameter vector by calling the modify method of the trait ArgminOperator. Will return an Err if modify is not implemented.

fn result(&self) -> ArgminResult<Self::Param>

Returns the result of the optimization.

fn set_max_iters(&mut self, iters: u64)

Sets the maximum number of iterations to iters.

fn max_iters(&self) -> u64

Returns the maximum number of iterations.

fn increment_iter(&mut self)

Increments the iteration counter.

fn cur_iter(&self) -> u64

Returns the current number of iterations.

fn cur_cost(&self) -> f64

Returns the most recently stored cost function value.

fn set_cur_cost(&mut self, cost: f64)

Sets the current cost function value to cost

fn best_cost(&self) -> f64

Returns the best cost function value obtained so far.

fn set_best_cost(&mut self, cost: f64)

Sets the best cost function value.

fn set_target_cost(&mut self, cost: f64)

Sets the target cost function value to cost. The optimization algorithm will be terminated when this limit is reached.

fn increment_cost_func_count(&mut self)

Increments the counter for the computations of the cost function by 1.

fn increase_cost_func_count(&mut self, count: u64)

Increases the counter for the computations of the cost function by count.

fn cost_func_count(&self) -> u64

Returns the current value of the counter for the computations of the cost function.

fn increment_grad_func_count(&mut self)

Increments the counter for the computations of the gradient by 1.

fn increase_grad_func_count(&mut self, count: u64)

Increases the counter for the computations of the gradient by count.

fn grad_func_count(&self) -> u64

Returns the current value of the counter for the computations of the gradient.

fn increment_hessian_func_count(&mut self)

Increments the counter for the computations of the Hessian by 1.

fn increase_hessian_func_count(&mut self, count: u64)

Increases the counter for the computations of the Hessian by count.

fn hessian_func_count(&self) -> u64

Returns the current value of the counter for the computations of the Hessian.

fn add_logger(&mut self, logger: Arc<dyn ArgminLog>)

Attaches a logger which implements ArgminLog to the solver.

fn add_writer(&mut self, writer: Arc<dyn ArgminWrite<Param = Self::Param>>)

Attaches a writer which implements ArgminWrite to the solver.

fn set_termination_reason(&mut self, reason: TerminationReason)

Sets the TerminationReason

fn terminate(&mut self) -> TerminationReason

Checks whether any of the conditions to terminate is true and terminates the algorithm.

fn base_reset(&mut self)

Resets the base field to it's initial conditions. This is helpful for implementing a solver which is initialized once, but called several times. It is recommended to only call this method inside the init function of ArgminNextIter.

impl<'a, O> ArgminIter for TrustRegion<'a, O> where
    O: 'a + ArgminOp<Output = f64>,
    <O as ArgminOp>::Param: ArgminMul<f64, <O as ArgminOp>::Param> + ArgminWeightedDot<<O as ArgminOp>::Param, f64, <O as ArgminOp>::Hessian> + ArgminNorm<f64> + ArgminDot<<O as ArgminOp>::Param, f64> + ArgminAdd<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminSub<<O as ArgminOp>::Param, <O as ArgminOp>::Param> + ArgminZero + ArgminMul<f64, <O as ArgminOp>::Param>,
    <O as ArgminOp>::Hessian: ArgminDot<<O as ArgminOp>::Param, <O as ArgminOp>::Param>, 

type Param = <O as ArgminOp>::Param

Parameter vectors

type Output = f64

Output of the operator

type Hessian = <O as ArgminOp>::Hessian

Hessian

fn init(&mut self) -> Result<(), Error>

Initializes the algorithm

fn next_iter(&mut self) -> Result<ArgminIterData<Self::Param>, Error>

Computes one iteration of the algorithm.