itkSPSAOptimizer.h

Go to the documentation of this file.

#ifndef __itkSPSAOptimizer_h
#define __itkSPSAOptimizer_h

#include "itkSingleValuedNonLinearOptimizer.h"
#include "itkMersenneTwisterRandomVariateGenerator.h"


namespace itk
{
  
  class SPSAOptimizer
    : public SingleValuedNonLinearOptimizer
  {
   public:
    
    typedef SPSAOptimizer                       Self;
    typedef SingleValuedNonLinearOptimizer      Superclass;
    typedef SmartPointer<Self>                  Pointer;
    typedef SmartPointer<const Self>             ConstPointer;

    itkNewMacro( Self );

    itkTypeMacro( SPSAOptimizer, SingleValuedNonLinearOptimizer );

    typedef enum {
      Unknown,
      MaximumNumberOfIterations,
      BelowTolerance,
      MetricError  } StopConditionType;

    virtual void AdvanceOneStep( void );

    void StartOptimization( void );

    void ResumeOptimization( void );

    void StopOptimization( void );

    virtual MeasureType GetValue( void ) const;

    virtual MeasureType GetValue( const ParametersType & parameters ) const;

    virtual void GuessParameters(
                                 unsigned long numberOfGradientEstimates,
                                 double initialStepSize);

    itkGetConstMacro( CurrentIteration, unsigned long );

    itkGetConstMacro( StopCondition, StopConditionType );

    itkGetConstMacro( LearningRate, double);

    itkGetConstMacro( GradientMagnitude, double);

    itkGetConstReferenceMacro( Gradient, DerivativeType);

    itkSetMacro( a, double );
    itkGetConstMacro( a, double );

    itkSetMacro( c, double );
    itkGetConstMacro( c, double );

    itkSetMacro( A, double );
    itkGetConstMacro( A, double );

    itkSetMacro( Alpha, double );
    itkGetConstMacro( Alpha, double );

    itkSetMacro( Gamma, double );
    itkGetConstMacro( Gamma, double );

    itkGetConstMacro( Maximize, bool );
    itkSetMacro( Maximize, bool );
    itkBooleanMacro( Maximize );
    bool GetMinimize( ) const
    { return !m_Maximize; }
    void SetMinimize(bool v)
    { this->SetMaximize(!v); }
    void MinimizeOn()
    { this->MaximizeOff(); }
    void MinimizeOff()
    { this->MaximizeOn(); }

    itkSetMacro( NumberOfPerturbations, unsigned long );
    itkGetConstMacro( NumberOfPerturbations, unsigned long );


    itkGetConstMacro( StateOfConvergence, double );

    itkSetMacro( StateOfConvergenceDecayRate, double );
    itkGetConstMacro( StateOfConvergenceDecayRate, double );

    itkSetMacro( MinimumNumberOfIterations, unsigned long);
    itkGetConstMacro( MinimumNumberOfIterations, unsigned long);

    itkSetMacro( MaximumNumberOfIterations, unsigned long );
    itkGetConstMacro( MaximumNumberOfIterations, unsigned long );

    itkSetMacro(Tolerance, double);
    itkGetConstMacro(Tolerance, double);

   protected:

    SPSAOptimizer();
    virtual ~SPSAOptimizer() {};

    void PrintSelf( std::ostream& os, Indent indent ) const;

    DerivativeType               m_Gradient; 
    double                       m_LearningRate;
    DerivativeType               m_Delta;
    bool                         m_Stop;
    StopConditionType            m_StopCondition;
    double                       m_StateOfConvergence;
    unsigned long                m_CurrentIteration;

    Statistics::MersenneTwisterRandomVariateGenerator::Pointer m_Generator;

    virtual double Compute_a( unsigned long k ) const;

    virtual double Compute_c( unsigned long k ) const;

    virtual void GenerateDelta( const unsigned int spaceDimension );

    virtual void ComputeGradient(
                                 const ParametersType & parameters,
                                 DerivativeType & gradient);

   private:

    SPSAOptimizer( const Self& );    // purposely not implemented
    void operator=( const Self& );  // purposely not implemented
    
    unsigned long                 m_MinimumNumberOfIterations;
    unsigned long                 m_MaximumNumberOfIterations;
    double                        m_StateOfConvergenceDecayRate;
    double                        m_Tolerance;
    bool                          m_Maximize;
    double                        m_GradientMagnitude;
    unsigned long                 m_NumberOfPerturbations;

    double                        m_a;
    double                        m_c;
    double                        m_A;
    double                        m_Alpha;
    double                        m_Gamma;

  }; // end class SPSAOptimizer

} // end namespace itk

#endif // end #ifndef __itkSPSAOptimizer_h

---