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:
  ITK_DISALLOW_COPY_AND_MOVE(CMAEvolutionStrategyOptimizer);
 
  using Self = CMAEvolutionStrategyOptimizer;
  using Superclass = ScaledSingleValuedNonLinearOptimizer;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
  itkTypeMacro(CMAEvolutionStrategyOptimizer, ScaledSingleValuedNonLinearOptimizer);
 
  using Superclass::ParametersType;
  using Superclass::DerivativeType;
  using Superclass::CostFunctionType;
  using Superclass::ScaledCostFunctionType;
  using Superclass::MeasureType;
  using Superclass::ScalesType;
 
  enum StopConditionType
  {
    MetricError,
    MaximumNumberOfIterations,
    PositionToleranceMin,
    PositionToleranceMax,
    ValueTolerance,
    ZeroStepLength,
    Unknown
  };
 
  void
  StartOptimization() override;
 
  virtual void
  ResumeOptimization();
 
  virtual void
  StopOptimization();
 
  itkGetConstMacro(CurrentIteration, unsigned long);
 
  itkGetConstMacro(CurrentValue, MeasureType);
 
  itkGetConstReferenceMacro(StopCondition, StopConditionType);
 
  itkGetConstMacro(CurrentSigma, double);
 
  itkGetConstMacro(CurrentMinimumD, double);
 
  itkGetConstMacro(CurrentMaximumD, double);
 
  virtual double
  GetCurrentStepLength() 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:
  using RecombinationWeightsType = Array<double>;
  using EigenValueMatrixType = vnl_diag_matrix<double>;
  using CovarianceMatrixType = vnl_matrix<double>;
  using ParameterContainerType = std::vector<ParametersType>;
  using MeasureHistoryType = std::deque<MeasureType>;
 
  using MeasureIndexPairType = std::pair<MeasureType, unsigned int>;
  using MeasureContainerType = std::vector<MeasureIndexPairType>;
 
  using RandomGeneratorType = itk::Statistics::MersenneTwisterRandomVariateGenerator;
 
  RandomGeneratorType::Pointer m_RandomGenerator{ RandomGeneratorType::GetInstance() };
 
  MeasureType m_CurrentValue{ 0.0 };
 
  unsigned long m_CurrentIteration{ 0 };
 
  StopConditionType m_StopCondition{ Unknown };
 
  bool m_Stop{ false };
 
  bool         m_UseCovarianceMatrixAdaptation{ true };
  unsigned int m_PopulationSize{ 0 };
  unsigned int m_NumberOfParents{ 0 };
  unsigned int m_UpdateBDPeriod{ 1 };
 
  double m_EffectiveMu{ 0.0 };
  double m_ConjugateEvolutionPathConstant{ 0.0 };
  double m_SigmaDampingConstant{ 0.0 };
  double m_CovarianceMatrixAdaptationConstant{ 0.0 };
  double m_EvolutionPathConstant{ 0.0 };
  double m_CovarianceMatrixAdaptationWeight{ 0.0 };
  double m_ExpectationNormNormalDistribution{ 0.0 };
  RecombinationWeightsType m_RecombinationWeights{};
  unsigned long m_HistoryLength{ 0 };
 
  double m_CurrentSigma{ 0.0 };
 
  double m_CurrentMinimumD{ 1.0 };
  double m_CurrentMaximumD{ 1.0 };
 
  bool m_Heaviside{ false };
 
  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 = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  virtual void
  InitializeConstants();
 
  virtual void
  InitializeProgressVariables();
 
  virtual void
  InitializeBCD();
 
  virtual void
  GenerateOffspring();
 
  virtual void
  SortCostFunctionValues();
 
  virtual void
  AdvanceOneStep();
 
  virtual void
  UpdateConjugateEvolutionPath();
 
  virtual void
  UpdateHeaviside();
 
  virtual void
  UpdateEvolutionPath();
 
  virtual void
  UpdateC();
 
  virtual void
  UpdateSigma();
 
  virtual void
  UpdateBD();
 
  virtual void
  FixNumericalErrors();
 
  virtual bool
  TestConvergence(bool firstCheck);
 
private:
  unsigned long m_MaximumNumberOfIterations{ 100 };
  bool          m_UseDecayingSigma{ false };
  double        m_InitialSigma{ 1.0 };
  double        m_SigmaDecayA{ 50 };
  double        m_SigmaDecayAlpha{ 0.602 };
  std::string   m_RecombinationWeightsPreset{ "superlinear" };
  double        m_MaximumDeviation{ std::numeric_limits<double>::max() };
  double        m_MinimumDeviation{ 0.0 };
  double        m_PositionToleranceMax{ 1e8 };
  double        m_PositionToleranceMin{ 1e-12 };
  double        m_ValueTolerance{ 1e-12 };
};
 
} // end namespace itk
 
#endif //#ifndef itkCMAEvolutionStrategyOptimizer_h