itkGenericConjugateGradientOptimizer.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 itkGenericConjugateGradientOptimizer_h
#define itkGenericConjugateGradientOptimizer_h
 
#include "itkScaledSingleValuedNonLinearOptimizer.h"
#include "itkLineSearchOptimizer.h"
#include <vector>
#include <map>
 
namespace itk
{
class GenericConjugateGradientOptimizer : public ScaledSingleValuedNonLinearOptimizer
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(GenericConjugateGradientOptimizer);
 
  using Self = GenericConjugateGradientOptimizer;
  using Superclass = ScaledSingleValuedNonLinearOptimizer;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
  itkTypeMacro(GenericConjugateGradientOptimizer, ScaledSingleValuedNonLinearOptimizer);
 
  using Superclass::ParametersType;
  using Superclass::DerivativeType;
  using Superclass::CostFunctionType;
  using Superclass::ScaledCostFunctionType;
  using Superclass::MeasureType;
  using Superclass::ScalesType;
 
  using LineSearchOptimizerType = LineSearchOptimizer;
  using LineSearchOptimizerPointer = LineSearchOptimizerType::Pointer;
 
  using ComputeBetaFunctionType = double (Self::*)(const DerivativeType &,
                                                   const DerivativeType &,
                                                   const ParametersType &);
  using BetaDefinitionType = std::string;
  using BetaDefinitionMapType = std::map<BetaDefinitionType, ComputeBetaFunctionType>;
 
  enum class StopConditionType : unsigned int
  {
    MetricError,
    LineSearchError,
    MaximumNumberOfIterations,
    GradientMagnitudeTolerance,
    ValueTolerance,
    InfiniteBeta,
    Unknown
  };
 
  void
  StartOptimization() override;
 
  virtual void
  ResumeOptimization();
 
  virtual void
  StopOptimization();
 
  itkGetConstMacro(CurrentIteration, unsigned long);
  itkGetConstMacro(CurrentValue, MeasureType);
  itkGetConstReferenceMacro(CurrentGradient, DerivativeType);
  itkGetConstMacro(InLineSearch, bool);
  itkGetConstReferenceMacro(StopCondition, StopConditionType);
  itkGetConstMacro(CurrentStepLength, double);
 
  itkSetObjectMacro(LineSearchOptimizer, LineSearchOptimizerType);
  itkGetModifiableObjectMacro(LineSearchOptimizer, LineSearchOptimizerType);
 
  itkGetConstMacro(MaximumNumberOfIterations, unsigned long);
  itkSetClampMacro(MaximumNumberOfIterations, unsigned long, 1, NumericTraits<unsigned long>::max());
 
  itkGetConstMacro(GradientMagnitudeTolerance, double);
  itkSetMacro(GradientMagnitudeTolerance, double)
 
    
    itkGetConstMacro(ValueTolerance, double);
  itkSetMacro(ValueTolerance, double);
 
  virtual void
  SetMaxNrOfItWithoutImprovement(unsigned long arg);
 
  itkGetConstMacro(MaxNrOfItWithoutImprovement, unsigned long);
 
  void
  SetBetaDefinition(const BetaDefinitionType & arg);
 
  itkGetConstReferenceMacro(BetaDefinition, BetaDefinitionType);
 
protected:
  GenericConjugateGradientOptimizer();
  ~GenericConjugateGradientOptimizer() override = default;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  DerivativeType    m_CurrentGradient{};
  MeasureType       m_CurrentValue{ 0.0 };
  unsigned long     m_CurrentIteration{ 0 };
  StopConditionType m_StopCondition{ StopConditionType::Unknown };
  bool              m_Stop{ false };
  double            m_CurrentStepLength{ 0.0 };
 
  bool m_UseDefaultMaxNrOfItWithoutImprovement{ true };
 
  bool m_InLineSearch{ false };
  itkSetMacro(InLineSearch, bool);
 
  bool m_PreviousGradientAndSearchDirValid{ false };
 
  BetaDefinitionType m_BetaDefinition{};
 
  BetaDefinitionMapType m_BetaDefinitionMap{};
 
  void
  AddBetaDefinition(const BetaDefinitionType & name, ComputeBetaFunctionType function);
 
  virtual void
  ComputeSearchDirection(const DerivativeType & previousGradient,
                         const DerivativeType & gradient,
                         ParametersType &       searchDir);
 
  virtual void
  LineSearch(const ParametersType searchDir, double & step, ParametersType & x, MeasureType & f, DerivativeType & g);
 
  virtual bool
  TestConvergence(bool firstLineSearchDone);
 
  virtual double
  ComputeBeta(const DerivativeType & previousGradient,
              const DerivativeType & gradient,
              const ParametersType & previousSearchDir);
 
  double
  ComputeBetaSD(const DerivativeType & previousGradient,
                const DerivativeType & gradient,
                const ParametersType & previousSearchDir);
 
  double
  ComputeBetaFR(const DerivativeType & previousGradient,
                const DerivativeType & gradient,
                const ParametersType & previousSearchDir);
 
  double
  ComputeBetaPR(const DerivativeType & previousGradient,
                const DerivativeType & gradient,
                const ParametersType & previousSearchDir);
 
  double
  ComputeBetaDY(const DerivativeType & previousGradient,
                const DerivativeType & gradient,
                const ParametersType & previousSearchDir);
 
  double
  ComputeBetaHS(const DerivativeType & previousGradient,
                const DerivativeType & gradient,
                const ParametersType & previousSearchDir);
 
  double
  ComputeBetaDYHS(const DerivativeType & previousGradient,
                  const DerivativeType & gradient,
                  const ParametersType & previousSearchDir);
 
private:
  unsigned long m_MaximumNumberOfIterations{ 100 };
  double        m_ValueTolerance{ 1e-5 };
  double        m_GradientMagnitudeTolerance{ 1e-5 };
  unsigned long m_MaxNrOfItWithoutImprovement{ 10 };
 
  LineSearchOptimizerPointer m_LineSearchOptimizer{ nullptr };
};
 
} // end namespace itk
 
#endif //#ifndef itkGenericConjugateGradientOptimizer_h