itkSPSAOptimizer.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSPSAOptimizer.h,v $
  Language:  C++
  Date:      $Date: 2009-01-26 12:19:14 $
  Version:   $Revision: 1.8 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#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( Sa, double );
  itkGetConstMacro( Sa, double );
  // For backward compatibility
  void Seta (double a) { SetSa(a);}
  double Geta () {return GetSa();}

  itkSetMacro( Sc, double );
  itkGetConstMacro( Sc, double );
  // For backward compatibility
  void Setc (double c) {SetSc(c);}
  double Getc () {return GetSc();}

  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_Sa;
  double                        m_Sc;
  double                        m_A;
  double                        m_Alpha;
  double                        m_Gamma;

}; // end class SPSAOptimizer

} // end namespace itk

#endif // end #ifndef __itkSPSAOptimizer_h