Optimization algorithm: LBFGS. More...

#include <optimizerLBFGS.h>

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

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

Public Member Functions
	OptimizerLBFGS (int dimCtrl, S eps, int maxIt, S lambda, int maxStepAttempts, std::string stepCondition, int l, S startCoefH, 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={})

	~OptimizerLBFGS ()

void	setL (int l)

void	setStartCoefH (S startCoefH)

void	checkDerivativeZero ()

void	storeHelpers ()

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::OptimizerLBFGS< S, C >

Optimization algorithm: LBFGS.

OptimizerSteepestDescent optimizes an optimization problem which is given in OptiCase. OptiCase provides therefore methods to evaluate an object functional and compute derivatives. LBFGS searches along the direction of the derivative to find a lower value of the evaluated object functional.

This class is not intended to be derived from.

Definition at line 54 of file optimizerLBFGS.h.

Constructor & Destructor Documentation

◆ OptimizerLBFGS()

template<typename S , typename C >

olb::opti::OptimizerLBFGS< S, C >::OptimizerLBFGS	(	int	dimCtrl,
		S	eps,
		int	maxIt,
		S	lambda,
		int	maxStepAttempts,
		std::string	stepCondition,
		int	l,
		S	startCoefH,
		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 = {} )

inline

Definition at line 77 of file optimizerLBFGS.h.

                                                {})
    : OptimizerLineSearch<S,C>(
      dimCtrl, eps, maxIt, /*lambda*/ 1., maxStepAttempts, stepCondition, verboseOn,
      fname, logFileName, withUpperBound, upperBound,
      withLowerBound, lowerBound, vectorBounds, controlEps, failOnMaxIter, gplotAnalysis),
      clout(std::cout,"OptimizerLBFGS")
  {
    // Starting lambda for iT==0: steepest descent
    // Line Search will be initialised with the natural lambda = 1
    _startLambda = lambda;
 
    _l=l;
    _startCoefH = startCoefH;
    _firstStore = 1;
    _lastStore = 1;
 
    _lastControl = util::ContainerCreator<C>::create(this->_dimCtrl);
    _lastDerivative = util::ContainerCreator<C>::create(this->_dimCtrl);
 
    _sStore = new S* [_l];
    _yStore = new S* [_l];
 
    _rhoStore = new S [_l];
    _alpha = new S [_l];
 
    for (int i=0; i<_l; i++) {
      _rhoStore[i] = S(0);
      _alpha[i] = S(0);
    }
 
    for (int i=0; i<_l; i++) {
      _sStore[i] = new S [this->_dimCtrl];
      _yStore[i] = new S [this->_dimCtrl];
      //for (int iDim=0; iDim<this->_dimCtrl; ++iDim) {
      //_sStore[i][iDim] = S(0);
      //_yStore[i][iDim] = S(0);
      //};
    }
  };

◆ ~OptimizerLBFGS()

template<typename S , typename C >

olb::opti::OptimizerLBFGS< S, C >::~OptimizerLBFGS ( )

inline

Definition at line 124 of file optimizerLBFGS.h.

  {
    for (int i=0; i<_l; i++) {
      delete[] _sStore[i];
      delete[] _yStore[i];
    }
    delete[] _sStore;
    delete[] _yStore;
    delete[] _rhoStore;
    delete[] _alpha;
  }

Member Function Documentation

◆ checkDerivativeZero()

template<typename S , typename C >

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

inline

Definition at line 147 of file optimizerLBFGS.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::OptimizerLBFGS< S, C >::computeDirection ( )

inlinevirtual

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

Definition at line 185 of file optimizerLBFGS.h.

  {
 
    // Update _derivative
    // 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 Helpers!
      storeHelpers();
 
    }
    else {
      storeHelpers();
 
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        this->_direction[iDim] = this->_derivative[iDim];
      }
 
      int iMax = _l;
      if (this->_it<_l) {
        iMax = this->_it;
      }
 
      int iStore;
      // first for loop
      for (int i=0; i<iMax; i++) {
        iStore = (_lastStore + _l - i) % _l;
 
        _alpha[iStore] = 0;
        for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
          _alpha[iStore] += _sStore[iStore][iDim]*this->_direction[iDim];
        }
        _alpha[iStore] *= _rhoStore[iStore];
 
        for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
          this->_direction[iDim] -= _alpha[iStore]*_yStore[iStore][iDim];
        }
      } // end first for loop
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        this->_direction[iDim] *= _startCoefH;
      }
 
      // second for loop
      for (int i=0; i<iMax; i++) {
        iStore = (_firstStore + _l + i) % _l;
 
        S beta = 0;
        for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
          beta += _yStore[iStore][iDim]*this->_direction[iDim];
        }
        beta *= _rhoStore[iStore];
 
        for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
          this->_direction[iDim] += _sStore[iStore][iDim]*(_alpha[iStore]-beta);
        }
      } // end second for loop
    }
  };

Here is the call graph for this function:

◆ setL()

template<typename S , typename C >

void olb::opti::OptimizerLBFGS< S, C >::setL ( int l )

inline

Definition at line 137 of file optimizerLBFGS.h.

  {
    _l=l;
  };

◆ setStartCoefH()

template<typename S , typename C >

void olb::opti::OptimizerLBFGS< S, C >::setStartCoefH ( S startCoefH )

inline

Definition at line 142 of file optimizerLBFGS.h.

  {
    _startCoefH = startCoefH;
  };

◆ storeHelpers()

template<typename S , typename C >

void olb::opti::OptimizerLBFGS< S, C >::storeHelpers ( )

inline

Definition at line 156 of file optimizerLBFGS.h.

  {
 
    if (this->_it!=0) {
      _rhoStore[(this->_it)%_l] = 0;
      S temp1 = S();
      S temp2 = S();
      for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
        _sStore[(this->_it)%_l][iDim] = this->_control[iDim]-_lastControl[iDim];
        _yStore[(this->_it)%_l][iDim] = this->_derivative[iDim]-_lastDerivative[iDim];
        _rhoStore[(this->_it)%_l] += _yStore[(this->_it)%_l][iDim]*_sStore[(this->_it)%_l][iDim];
        temp1 += _sStore[(this->_it)%_l][iDim]*_yStore[(this->_it)%_l][iDim];
        temp2 += _yStore[(this->_it)%_l][iDim]*_yStore[(this->_it)%_l][iDim];
      }
      _startCoefH = temp1/temp2;
 
      _rhoStore[(this->_it)%_l] = 1./_rhoStore[(this->_it)%_l];
      if (this->_it>_l) {
        _firstStore = (_firstStore+1)%_l;
      }
      _lastStore = (this->_it)%_l;
    }
 
    for (int iDim=0; iDim<this->_dimCtrl; iDim++) {
      _lastControl[iDim] = this->_control[iDim];
      _lastDerivative[iDim] = this->_derivative[iDim];
    }
  }

References olb::opti::Optimizer< S, C >::_control, olb::opti::Optimizer< S, C >::_derivative, olb::opti::Optimizer< S, C >::_dimCtrl, and olb::opti::Optimizer< S, C >::_it.

Here is the caller graph for this function:

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

src/optimization/optimizerLBFGS.h

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ OptimizerLBFGS()

◆ ~OptimizerLBFGS()

Member Function Documentation

◆ checkDerivativeZero()

◆ computeDirection()

◆ setL()

◆ setStartCoefH()

◆ storeHelpers()