itkStochasticGradientDescentOptimizer.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 __itkStochasticGradientDescentOptimizer_h
#define __itkStochasticGradientDescentOptimizer_h
 
#include "itkScaledSingleValuedNonLinearOptimizer.h"
#include "itkPlatformMultiThreader.h"
 
namespace itk
{
class StochasticGradientDescentOptimizer :
  public ScaledSingleValuedNonLinearOptimizer
{
public:
  typedef StochasticGradientDescentOptimizer    Self;
  typedef ScaledSingleValuedNonLinearOptimizer  Superclass;
  typedef SmartPointer<Self>                    Pointer;
  typedef SmartPointer<const Self>              ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( StochasticGradientDescentOptimizer, ScaledSingleValuedNonLinearOptimizer );
 
  typedef Superclass::MeasureType               MeasureType;
  typedef Superclass::ParametersType            ParametersType;
  typedef Superclass::DerivativeType            DerivativeType;
  typedef Superclass::CostFunctionType          CostFunctionType;
  typedef Superclass::ScalesType                ScalesType;
  typedef Superclass::ScaledCostFunctionType    ScaledCostFunctionType;
  typedef Superclass::ScaledCostFunctionPointer ScaledCostFunctionPointer;
 
  typedef enum {
    MaximumNumberOfIterations,
    MetricError,
    MinimumStepSize,
    InvalidDiagonalMatrix,
    GradientMagnitudeTolerance,
    LineSearchError,
  } StopConditionType;
 
  virtual void AdvanceOneStep( void );
 
  void StartOptimization( void ) override;
 
  virtual void ResumeOptimization( void );
 
  virtual void MetricErrorResponse( ExceptionObject & err );
 
  virtual void StopOptimization( void );
 
  itkSetMacro( LearningRate, double );
 
  itkGetConstReferenceMacro( LearningRate, double );
 
  itkSetMacro( NumberOfIterations, unsigned long );
 
  itkGetConstMacro( LBFGSMemory, unsigned int );
 
  itkGetConstReferenceMacro( NumberOfIterations, unsigned long );
 
  itkGetConstReferenceMacro( NumberOfInnerIterations, unsigned long );
 
  itkGetConstMacro( CurrentIteration, unsigned int );
 
  itkGetConstMacro( CurrentInnerIteration, unsigned int );
 
  itkGetConstReferenceMacro( Value, double );
 
  itkGetConstReferenceMacro( StopCondition, StopConditionType );
 
  itkGetConstReferenceMacro( Gradient, DerivativeType );
 
  itkGetConstReferenceMacro( SearchDir, DerivativeType );
 
  itkSetMacro( PreviousPosition, ParametersType );
 
  itkGetConstReferenceMacro( PreviousPosition, ParametersType );
 
  itkSetMacro( PreviousGradient, DerivativeType );
 
  itkGetConstReferenceMacro( PreviousGradient, DerivativeType );
 
  void SetNumberOfWorkUnits( ThreadIdType numberOfThreads )
  {
    this->m_Threader->SetNumberOfWorkUnits( numberOfThreads );
  }
  //itkGetConstReferenceMacro( NumberOfThreads, ThreadIdType );
  itkSetMacro( UseMultiThread, bool );
 
  itkSetMacro( UseOpenMP, bool );
  itkSetMacro( UseEigen, bool );
 
protected:
  StochasticGradientDescentOptimizer();
  ~StochasticGradientDescentOptimizer() override {};
  void PrintSelf( std::ostream& os, Indent indent ) const override;
 
  typedef itk::PlatformMultiThreader               ThreaderType;
  typedef ThreaderType::WorkUnitInfo   ThreadInfoType;
 
  // made protected so subclass can access
  double                        m_Value;
  DerivativeType                m_Gradient;
  ParametersType                m_SearchDir;
  ParametersType                m_PreviousSearchDir;
  ParametersType                m_PrePreviousSearchDir;
  ParametersType                m_MeanSearchDir;
  double                        m_LearningRate;
  StopConditionType             m_StopCondition;
  DerivativeType                m_PreviousGradient;
  DerivativeType                m_PrePreviousGradient;
  ParametersType                m_PreviousPosition;
  ThreaderType::Pointer         m_Threader;
 
  bool                          m_Stop;
  unsigned long                 m_NumberOfIterations;
  unsigned long                 m_NumberOfInnerIterations;
  unsigned long                 m_CurrentIteration;
  unsigned long                 m_CurrentInnerIteration;
  unsigned long                 m_LBFGSMemory;
 
private:
  StochasticGradientDescentOptimizer( const Self& ); //purposely not implemented
  void operator=( const Self& ); //purposely not implemented
 
  // multi-threaded AdvanceOneStep:
  bool m_UseMultiThread;
  struct MultiThreaderParameterType
  {
    ParametersType *  t_NewPosition;
    Self *            t_Optimizer;
  };
 
  bool m_UseOpenMP;
  bool m_UseEigen;
 
  static ITK_THREAD_RETURN_FUNCTION_CALL_CONVENTION AdvanceOneStepThreaderCallback( void * arg );
 
  inline void ThreadedAdvanceOneStep( ThreadIdType threadId, ParametersType & newPosition );
 
};
 
} // end namespace itk
 
 
#endif