1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*=========================================================================
*
* 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 itkGradientDescentOptimizer2_h
#define itkGradientDescentOptimizer2_h
#include "itkScaledSingleValuedNonLinearOptimizer.h"
namespace itk
{
/** \class GradientDescentOptimizer2
* \brief Implement a gradient descent optimizer
*
* GradientDescentOptimizer2 implements a simple gradient descent optimizer.
* At each iteration the current position is updated according to
*
* \f[
* p_{n+1} = p_n
* + \mbox{learningRate}
\, \frac{\partial f(p_n) }{\partial p_n}
* \f]
*
* The learning rate is a fixed scalar defined via SetLearningRate().
* The optimizer steps through a user defined number of iterations;
* no convergence checking is done.
*
* Additionally, user can scale each component of the \f$\partial f / \partial p\f$
* but setting a scaling vector using method SetScale().
*
* The difference of this class with the itk::GradientDescentOptimizer
* is that it's based on the ScaledSingleValuedNonLinearOptimizer
*
* \sa ScaledSingleValuedNonLinearOptimizer
*
* \ingroup Numerics Optimizers
*/
class GradientDescentOptimizer2 : public ScaledSingleValuedNonLinearOptimizer
{
public:
ITK_DISALLOW_COPY_AND_MOVE(GradientDescentOptimizer2);
/** Standard class typedefs. */
using Self = GradientDescentOptimizer2;
using Superclass = ScaledSingleValuedNonLinearOptimizer;
using Pointer = SmartPointer<Self>;
using ConstPointer = SmartPointer<const Self>;
/** Method for creation through the object factory. */
itkNewMacro(Self);
/** Run-time type information (and related methods). */
itkTypeMacro(GradientDescentOptimizer2, ScaledSingleValuedNonLinearOptimizer);
/** Typedefs inherited from the superclass. */
using Superclass::MeasureType;
using Superclass::ParametersType;
using Superclass::DerivativeType;
using Superclass::CostFunctionType;
using Superclass::ScalesType;
using Superclass::ScaledCostFunctionType;
using Superclass::ScaledCostFunctionPointer;
/** Codes of stopping conditions
* The MinimumStepSize stopcondition never occurs, but may
* be implemented in inheriting classes */
enum StopConditionType
{
MaximumNumberOfIterations,
MetricError,
MinimumStepSize
};
/** Advance one step following the gradient direction. */
virtual void
AdvanceOneStep();
/** Start optimization. */
void
StartOptimization() override;
/** Resume previously stopped optimization with current parameters
* \sa StopOptimization. */
virtual void
ResumeOptimization();
/** Stop optimization and pass on exception. */
virtual void
MetricErrorResponse(ExceptionObject & err);
/** Stop optimization.
* \sa ResumeOptimization */
virtual void
StopOptimization();
/** Set the learning rate. */
itkSetMacro(LearningRate, double);
/** Get the learning rate. */
itkGetConstReferenceMacro(LearningRate, double);
/** Set the number of iterations. */
itkSetMacro(NumberOfIterations, unsigned long);
/** Get the number of iterations. */
itkGetConstReferenceMacro(NumberOfIterations, unsigned long);
/** Get the current iteration number. */
itkGetConstMacro(CurrentIteration, unsigned int);
/** Get the current value. */
itkGetConstReferenceMacro(Value, double);
/** Get Stop condition. */
itkGetConstReferenceMacro(StopCondition, StopConditionType);
/** Get current gradient. */
itkGetConstReferenceMacro(Gradient, DerivativeType);
/** Get current search direction */
itkGetConstReferenceMacro(SearchDirection, DerivativeType);
protected:
GradientDescentOptimizer2();
~GradientDescentOptimizer2() override = default;
void
PrintSelf(std::ostream & os, Indent indent) const override;
// made protected so subclass can access
DerivativeType m_Gradient{};
DerivativeType m_SearchDirection{};
StopConditionType m_StopCondition{ MaximumNumberOfIterations };
private:
double m_Value{ 0.0 };
double m_LearningRate{ 1.0 };
bool m_Stop{ false };
unsigned long m_NumberOfIterations{ 100 };
unsigned long m_CurrentIteration{ 0 };
};
} // end namespace itk
#endif
|
