itkCMAEvolutionStrategyOptimizer.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
 
#ifndef __itkCMAEvolutionStrategyOptimizer_h
#define __itkCMAEvolutionStrategyOptimizer_h
 
#include "itkScaledSingleValuedNonLinearOptimizer.h"
#include <vector>
#include <utility>
#include <deque>
 
#include "itkArray.h"
#include "itkArray2D.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"
#include "vnl/vnl_diag_matrix.h"
 
namespace itk
{
class CMAEvolutionStrategyOptimizer :
  public ScaledSingleValuedNonLinearOptimizer
{
public:
 
  typedef CMAEvolutionStrategyOptimizer        Self;
  typedef ScaledSingleValuedNonLinearOptimizer Superclass;
  typedef SmartPointer< Self >                 Pointer;
  typedef SmartPointer< const Self >           ConstPointer;
 
  itkNewMacro( Self );
  itkTypeMacro( CMAEvolutionStrategyOptimizer,
    ScaledSingleValuedNonLinearOptimizer );
 
  typedef Superclass::ParametersType         ParametersType;
  typedef Superclass::DerivativeType         DerivativeType;
  typedef Superclass::CostFunctionType       CostFunctionType;
  typedef Superclass::ScaledCostFunctionType ScaledCostFunctionType;
  typedef Superclass::MeasureType            MeasureType;
  typedef Superclass::ScalesType             ScalesType;
 
  typedef enum {
    MetricError,
    MaximumNumberOfIterations,
    PositionToleranceMin,
    PositionToleranceMax,
    ValueTolerance,
    ZeroStepLength,
    Unknown
  }                                   StopConditionType;
 
  void StartOptimization( void ) override;
 
  virtual void ResumeOptimization( void );
 
  virtual void StopOptimization( void );
 
  itkGetConstMacro( CurrentIteration, unsigned long );
 
  itkGetConstMacro( CurrentValue, MeasureType );
 
  itkGetConstReferenceMacro( StopCondition, StopConditionType );
 
  itkGetConstMacro( CurrentSigma, double );
 
  itkGetConstMacro( CurrentMinimumD, double );
 
  itkGetConstMacro( CurrentMaximumD, double );
 
  virtual double GetCurrentStepLength( void ) const
  { return this->GetCurrentSigma() * this->GetCurrentMaximumD();  }
 
  itkGetConstReferenceMacro( CurrentScaledStep, ParametersType );
 
  itkGetConstMacro( MaximumNumberOfIterations, unsigned long );
  itkSetClampMacro( MaximumNumberOfIterations, unsigned long,
    1, NumericTraits< unsigned long >::max() );
 
  itkSetMacro( PopulationSize, unsigned int );
  itkGetConstMacro( PopulationSize, unsigned int );
 
  itkSetMacro( NumberOfParents, unsigned int );
  itkGetConstMacro( NumberOfParents, unsigned int );
 
  itkSetClampMacro( InitialSigma, double, NumericTraits< double >::min(), NumericTraits< double >::max() );
  itkGetConstMacro( InitialSigma, double );
 
  itkSetClampMacro( MaximumDeviation, double, 0.0, NumericTraits< double >::max() );
  itkGetConstMacro( MaximumDeviation, double );
 
  itkSetClampMacro( MinimumDeviation, double, 0.0, NumericTraits< double >::max() );
  itkGetConstMacro( MinimumDeviation, double );
 
  itkSetMacro( UseDecayingSigma, bool );
  itkGetConstMacro( UseDecayingSigma, bool );
 
  itkSetClampMacro( SigmaDecayA, double, 0.0, NumericTraits< double >::max() );
  itkGetConstMacro( SigmaDecayA, double );
 
  itkSetClampMacro( SigmaDecayAlpha, double, 0.0, 1.0 );
  itkGetConstMacro( SigmaDecayAlpha, double );
 
  itkSetMacro( UseCovarianceMatrixAdaptation, bool );
  itkGetConstMacro( UseCovarianceMatrixAdaptation, bool );
 
  itkSetStringMacro( RecombinationWeightsPreset );
  itkGetStringMacro( RecombinationWeightsPreset );
 
  itkSetMacro( UpdateBDPeriod, unsigned int );
  itkGetConstMacro( UpdateBDPeriod, unsigned int );
 
  itkSetMacro( PositionToleranceMin, double );
  itkGetConstMacro( PositionToleranceMin, double );
 
  itkSetMacro( PositionToleranceMax, double );
  itkGetConstMacro( PositionToleranceMax, double );
 
  itkSetMacro( ValueTolerance, double );
  itkGetConstMacro( ValueTolerance, double );
 
protected:
 
  typedef Array< double >               RecombinationWeightsType;
  typedef vnl_diag_matrix< double >     EigenValueMatrixType;
  typedef Array2D< double >             CovarianceMatrixType;
  typedef std::vector< ParametersType > ParameterContainerType;
  typedef std::deque< MeasureType >     MeasureHistoryType;
 
  typedef
    std::pair< MeasureType, unsigned int >  MeasureIndexPairType;
  typedef std::vector< MeasureIndexPairType > MeasureContainerType;
 
  typedef itk::Statistics::MersenneTwisterRandomVariateGenerator RandomGeneratorType;
 
  RandomGeneratorType::Pointer m_RandomGenerator;
 
  MeasureType m_CurrentValue;
 
  unsigned long m_CurrentIteration;
 
  StopConditionType m_StopCondition;
 
  bool m_Stop;
 
  bool         m_UseCovarianceMatrixAdaptation;
  unsigned int m_PopulationSize;
  unsigned int m_NumberOfParents;
  unsigned int m_UpdateBDPeriod;
 
  double m_EffectiveMu;
  double m_ConjugateEvolutionPathConstant;
  double m_SigmaDampingConstant;
  double m_CovarianceMatrixAdaptationConstant;
  double m_EvolutionPathConstant;
  double m_CovarianceMatrixAdaptationWeight;
  double m_ExpectationNormNormalDistribution;
  RecombinationWeightsType m_RecombinationWeights;
  unsigned long m_HistoryLength;
 
  double m_CurrentSigma;
 
  double m_CurrentMinimumD;
  double m_CurrentMaximumD;
 
  bool m_Heaviside;
 
  ParameterContainerType m_SearchDirs;
  ParameterContainerType m_NormalizedSearchDirs;
  MeasureContainerType m_CostFunctionValues;
  ParametersType m_CurrentScaledStep;
  ParametersType m_CurrentNormalizedStep;
  ParametersType m_EvolutionPath;
  ParametersType m_ConjugateEvolutionPath;
 
  MeasureHistoryType m_MeasureHistory;
 
  CovarianceMatrixType m_C;
  CovarianceMatrixType m_B;
  EigenValueMatrixType m_D;
 
  CMAEvolutionStrategyOptimizer();
 
  ~CMAEvolutionStrategyOptimizer() override{}
 
  void PrintSelf( std::ostream & os, Indent indent ) const override;
 
  virtual void InitializeConstants( void );
 
  virtual void InitializeProgressVariables( void );
 
  virtual void InitializeBCD( void );
 
  virtual void GenerateOffspring( void );
 
  virtual void SortCostFunctionValues( void );
 
  virtual void AdvanceOneStep( void );
 
  virtual void UpdateConjugateEvolutionPath( void );
 
  virtual void UpdateHeaviside( void );
 
  virtual void UpdateEvolutionPath( void );
 
  virtual void UpdateC( void );
 
  virtual void UpdateSigma( void );
 
  virtual void UpdateBD( void );
 
  virtual void FixNumericalErrors( void );
 
  virtual bool TestConvergence( bool firstCheck );
 
private:
 
  CMAEvolutionStrategyOptimizer( const Self & ); // purposely not implemented
  void operator=( const Self & );                // purposely not implemented
 
  unsigned long m_MaximumNumberOfIterations;
  bool          m_UseDecayingSigma;
  double        m_InitialSigma;
  double        m_SigmaDecayA;
  double        m_SigmaDecayAlpha;
  std::string   m_RecombinationWeightsPreset;
  double        m_MaximumDeviation;
  double        m_MinimumDeviation;
  double        m_PositionToleranceMax;
  double        m_PositionToleranceMin;
  double        m_ValueTolerance;
 
};
 
} // end namespace itk
 
#endif //#ifndef __itkCMAEvolutionStrategyOptimizer_h