Optimization algorithm: BarzilaiBorwein. More...

#include <optimizerBarzilaiBorwein.h>

Inheritance diagram for olb::opti::OptimizerBarzilaiBorwein< S, C >:

Collaboration diagram for olb::opti::OptimizerBarzilaiBorwein< S, C >:

Public Member Functions
	OptimizerBarzilaiBorwein (int dim, S eps, int maxIt, S lambda, int maxStepAttempts, std::string stepCondition, bool verboseOn=true, const std::string fname="", const std::string logFileName="", bool withUpperBound=false, S upperBound=S(), bool withLowerBound=false, S lowerBound=S(), bool vectorBounds=false, S controlEps=S(std::numeric_limits< double >::epsilon()), std::vector< OptimizerLogType > gplotAnalysis={})

void	checkDerivativeZero ()

virtual void	computeDirection ()

Public Member Functions inherited from olb::opti::OptimizerLineSearch< S, C >
	OptimizerLineSearch (int dimCtrl, S eps, int maxIt, S lambda, int maxStepAttempts, std::string stepCondition, bool verboseOn=true, const std::string fname="", const std::string logFileName="", bool withUpperBound=false, S upperBound=S(), bool withLowerBound=false, S lowerBound=S(), bool vectorBounds=false, S controlEps=S(std::numeric_limits< double >::epsilon()), bool failOnMaxIter=true, std::vector< OptimizerLogType > gplotAnalysis={})
	Construction of an OptimizerLineSearch.

virtual	~OptimizerLineSearch ()

void	checkBound ()

void	boundControl ()

bool	smallerValue (const S &tempValue)

bool	noCondition (const S &tempValue)

bool	armijoWolfeConditions (const S &tempValue)

void	quadraticInterpolationStep (const S &tempValue)

void	backtrackingLineSearch (S &tempValue, S lambda, bool(OptimizerLineSearch::*condition)(const S &))

virtual void	optimizationStep ()
	Optimization step: line search.

Public Member Functions inherited from olb::opti::Optimizer< S, C >
	Optimizer (int dimCtrl, S eps, int maxIt, bool verboseOn=true, const std::string fname="", const std::string logFileName="", bool withUpperBound=false, S upperBound=S(), bool withLowerBound=false, S lowerBound=S(), bool vectorBounds=false, S controlEps=S(std::numeric_limits< double >::epsilon()), bool failOnMaxIter=true, std::vector< OptimizerLogType > gplotAnalysis={})

virtual	~Optimizer ()

void	maxIterationReached ()

virtual void	optimize ()

virtual void	optimize (OptiCase< S, C > &optiCase)

void	simulate ()

void	simulate (OptiCase< S, C > &optiCase)

void	evaluateObjective (const C &control, S &result)

void	computeDerivatives (const C &control, C &derivatives)

void	print (int it)
	Prints information of the current optimization step it.

void	setControl (C &control)

const C &	getControl () const

const C &	getDerivative () const

const S &	getObjective () const

int	getIteration () const

void	writeControlToFile (const std::string fname="control.dat")
	Writes the current control variables linewise into file fname.

void	readControlFromFile (const std::string fname="control.dat")
	Reads the latest control variables from file fname.

void	setStartValue (S startValue)

OptiCase< S, C > *	getOptiCase ()

void	setOptiCase (OptiCase< S, C > *optiCase)

void	setGnuplotData ()

void	setReferenceControl (C result)
	set the reference value for the control vector (exact solution)

Additional Inherited Members
Public Attributes inherited from olb::opti::Optimizer< S, C >
Gnuplot< S >	gplot

std::vector< OptimizerLogType >	_gplotAnalysis
	For defining what kind of gnuplot analysis is wanted, if empty vector - no analysis, value, control and derivative are the possible options.

Protected Attributes inherited from olb::opti::OptimizerLineSearch< S, C >
S	_lambda
	Lambda start value.

C	_direction
	Search direction.

bool	_lowerBoundFlag

bool	_upperBoundFlag

int	_maxStepAttempts
	Maximal number of step attempts for conditioned line search.

C	_nextDerivative

bool	_nextDerivFlag

std::string	_stepCondition

bool(OptimizerLineSearch::*	_stepConditionFunction )(const S &)

void(OptimizerLineSearch::*	_stepLengthFunction )(const S &)

Protected Attributes inherited from olb::opti::Optimizer< S, C >
int	_dimCtrl
	Number of controlled variables.

C	_control
	Vector of controlled variables (size _dimCtrl)

S	_value
	Value of the objective functional evaluated for controlled variables saved in _control.

C	_derivative
	Vector of derivatives of the object functional with respect to the controlled variables.

int	_it
	Current iteration no.

int	_maxIt
	Maximal number of iteration.

bool	_failOnMaxIter
	Fail when max number of iteration reached.

S	_eps
	Optimizer stops if \|_derivatives\| < _eps.

bool	_verboseOn
	Verbose.

bool	_withUpperBound
	Bounded versions.

bool	_withLowerBound

bool	_vectorBounds

C	_boundedControl

C	_upperBound

C	_lowerBound

bool	_controlsConverged
	For setting tolerance of controls.

S	_controlEps

OptiCase< S, C > *	_optiCase
	Provides the Optimizer with methods to evaluate the value of an object functional and compute derivatives.

C	_referenceControl
	control vector to compare with (for numerical evaluation)

Detailed Description

template<typename S, typename C>
class olb::opti::OptimizerBarzilaiBorwein< S, C >

Optimization algorithm: BarzilaiBorwein.

OptimizerBarzilaiBorwein optimizes an optimization problem which is given in OptiCase. OptiCase provides therefore methods to evaluate an object functional and compute derivatives. BarzilaiBorwein searches along the direction of the derivative to find a lower value of the evaluated object functional. Thereby the steplength is adjusted to be an approximation of the Hessian. Barzilai-Borwein is therefore a "quasi" quasi Newton method.

This class is not intended to be derived from.

Definition at line 56 of file optimizerBarzilaiBorwein.h.

Constructor & Destructor Documentation

◆ OptimizerBarzilaiBorwein()

template<typename S , typename C >

olb::opti::OptimizerBarzilaiBorwein< S, C >::OptimizerBarzilaiBorwein	(	int	dim,
		S	eps,
		int	maxIt,
		S	lambda,
		int	maxStepAttempts,
		std::string	stepCondition,
		bool	verboseOn = true,
		const std::string	fname = "",
		const std::string	logFileName = "",
		bool	withUpperBound = false,
		S	upperBound = S(),
		bool	withLowerBound = false,
		S	lowerBound = S(),
		bool	vectorBounds = false,
		S	controlEps = S(std::numeric_limits<double>::epsilon() ),
		std::vector< OptimizerLogType >	gplotAnalysis = {} )

inline

Definition at line 71 of file optimizerBarzilaiBorwein.h.

                                                {})
    : OptimizerLineSearch<S,C>(dim, eps, maxIt, /*lambda*/ 1., maxStepAttempts, stepCondition,
      verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound,
      lowerBound, vectorBounds, controlEps, true, gplotAnalysis),
      clout(std::cout,"OptimizerBarzilaiBorwein")
  {
 
    // Starting lambda for iT==0: steepest descent
    // Line Search will be initialised with the natural lambda = 1
    _startLambda = lambda;
 
    _lastControl = util::ContainerCreator<C>::create(this->_dimCtrl);
    _lastDerivative = util::ContainerCreator<C>::create(this->_dimCtrl);
 
    _sStore = util::ContainerCreator<C>::create(this->_dimCtrl);
    _yStore = util::ContainerCreator<C>::create(this->_dimCtrl);
 
  };

Member Function Documentation

◆ checkDerivativeZero()

template<typename S , typename C >

void olb::opti::OptimizerBarzilaiBorwein< S, C >::checkDerivativeZero ( )

inline

Definition at line 95 of file optimizerBarzilaiBorwein.h.

  {
    S normDir = util::euklidN(this->_direction.data(), this->_dimCtrl);
    if (std::isnan(normDir)) {
      clout << "Warning: Derivative is null at first iteration. Check derivative calculations.\nProgram terminated" << std::endl;
      exit(1);
    }
  }

References olb::opti::OptimizerLineSearch< S, C >::_direction, and olb::util::euklidN().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ computeDirection()

template<typename S , typename C >

virtual void olb::opti::OptimizerBarzilaiBorwein< S, C >::computeDirection ( )

inlinevirtual

Implements olb::opti::OptimizerLineSearch< S, C >.

Definition at line 104 of file optimizerBarzilaiBorwein.h.

  {
    for (int i=0; i<this->_dimCtrl; i++) {
      _sStore[i] = 0.;
      _yStore[i] = 0.;
    }
    S sTy = 0.;
    S sTs = 0.;
    S yTy = 0.;
    // Alternating between lambda_1 and lambda_2, see:
    // http://www.math.ucla.edu/~wotaoyin/math273a/slides/Lec4a_Baizilai_Borwein_method_273a_2015_f.pdf, p.6
    bool alternate = false;
 
 
    // Compute Derivatives
    // computeDerivative only if not already done by wolfeCondition()
    if (!this->_nextDerivFlag) {
      this->computeDerivatives(this->_control, this->_derivative);
    }
    else {
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        this->_derivative[iDim] = this->_nextDerivative[iDim];
      }
    }
 
 
    if (this->_it == 0) {
      // On first step do normalised steepest descent
      S normDerivative = util::euklidN(this->_derivative.data(), this->_dimCtrl);
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        this->_direction[iDim] = _startLambda * this->_derivative[iDim] / normDerivative;
      }
      // terminate early if we recieve nan controls
      checkDerivativeZero();
      // Store control and derivative
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        _lastControl[iDim] = this->_control[iDim];
        _lastDerivative[iDim] = this->_derivative[iDim];
      }
 
    }
    else {
      // Calculate lambda as quasi Newton
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        _sStore[iDim] = this->_control[iDim] - _lastControl[iDim];
        _yStore[iDim] = this->_derivative[iDim] - _lastDerivative[iDim];
        sTs += _sStore[iDim]*_sStore[iDim];
        sTy += _sStore[iDim]*_yStore[iDim];
        if (alternate) {
          yTy += _yStore[iDim]*_yStore[iDim];
        }
      }
      // lambda_1 is minimizing || sD - y ||
      this->_lambda = sTs/sTy; //lambda_1
      // lambda_2 is minimizing || s - yD^-1 ||
      //this->_lambda = sTy/yTy; //lambda_2
 
      //Alternate lambda_1 and lambda_2
      if (alternate && this->_it%2 != 0) {
        this->_lambda = sTy/yTy;
      }
 
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        _lastControl[iDim] = this->_control[iDim];
        _lastDerivative[iDim] = this->_derivative[iDim];
      }
 
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        this->_direction[iDim] = this->_derivative[iDim];
      }
    }
  };

Here is the call graph for this function:

The documentation for this class was generated from the following file:

src/optimization/optimizerBarzilaiBorwein.h

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OptimizerBarzilaiBorwein()

Member Function Documentation

◆ checkDerivativeZero()

◆ computeDirection()