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 "elxDefaultConstruct.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);
  itkOverrideGetNameOfClassMacro(CMAEvolutionStrategyOptimizer);
 
  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);
 
  void
  SetRandomVariateGenerator(Statistics::MersenneTwisterRandomVariateGenerator & randomVariateGenerator)
  {
    m_RandomVariateGenerator = &randomVariateGenerator;
  }
 
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;

  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 };
 
  elx::DefaultConstruct<Statistics::MersenneTwisterRandomVariateGenerator> m_DefaultRandomVariateGenerator{};
  Statistics::MersenneTwisterRandomVariateGenerator * m_RandomVariateGenerator{ &m_DefaultRandomVariateGenerator };
};
 
} // end namespace itk
 
#endif // #ifndef itkCMAEvolutionStrategyOptimizer_h