optimizer.py 38.4 KB
Newer Older
1
#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
D
dzhwinter 已提交
2
#
D
dzhwinter 已提交
3 4 5
# 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
D
dzhwinter 已提交
6
#
D
dzhwinter 已提交
7
#     http://www.apache.org/licenses/LICENSE-2.0
D
dzhwinter 已提交
8
#
D
dzhwinter 已提交
9 10 11 12 13
# 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.
W
wanghaoshuang 已提交
14
import re
15
from collections import defaultdict
W
Wu Yi 已提交
16
from paddle.fluid.framework import Program, Variable
17
import framework
Q
Qiao Longfei 已提交
18
import layers
F
fengjiayi 已提交
19
from backward import append_backward
Y
Yu Yang 已提交
20 21
from framework import program_guard
import unique_name
22 23 24
from initializer import Constant
from layer_helper import LayerHelper
from regularizer import append_regularization_ops
F
fengjiayi 已提交
25
from clip import append_gradient_clip_ops, error_clip_callback
26
from contextlib import contextmanager
27

28 29
__all__ = [
    'SGD', 'Momentum', 'Adagrad', 'Adam', 'Adamax', 'DecayedAdagrad',
30
    'SGDOptimizer', 'MomentumOptimizer', 'AdagradOptimizer', 'AdamOptimizer',
Q
qiaolongfei 已提交
31 32
    'AdamaxOptimizer', 'DecayedAdagradOptimizer', 'AdadeltaOptimizer',
    'RMSPropOptimizer', 'Adadelta', 'ModelAverage', 'Optimizer'
33
]
Q
Qiao Longfei 已提交
34 35 36 37 38 39


class Optimizer(object):
    """Optimizer Base class.

    Define the common interface of an optimizer.
40 41
    User should not use this class directly,
    but need to use one of it's implementation.
Q
Qiao Longfei 已提交
42 43
    """

W
Wu Yi 已提交
44 45 46 47
    def __init__(self,
                 learning_rate,
                 regularization=None,
                 LARS_weight_decay=0.0):
48 49
        if not isinstance(learning_rate, float) and \
                not isinstance(learning_rate, framework.Variable):
Q
qiaolongfei 已提交
50
            raise TypeError("learning rate should be float or Variable")
D
dzhwinter 已提交
51
        self.regularization = regularization
52
        self._learning_rate = learning_rate
D
dzhwinter 已提交
53 54
        # the learning rate type should be inferenced from loss
        self._dtype = None
55 56
        # each program should have a independent learning rate
        # program -> Variable(learning_rate)
Q
qiaolongfei 已提交
57
        self._learning_rate_map = dict()
58 59 60
        if isinstance(self._learning_rate, framework.Variable):
            self._learning_rate_map[framework.default_main_program(
            )] = self._learning_rate
61 62 63 64 65
        # Dictionary of accumulators. Some optimizer subclasses need to
        # allocate and manage extra variables associated with the parameters
        # to train. These variables are called accumulators.
        # {accum_name : { paramter_name : accumulator_for_parameter, ...}, ...}
        self._accumulators = defaultdict(lambda: dict())
Q
Qiao Longfei 已提交
66
        self.helper = None
W
Wu Yi 已提交
67
        self._LARS_weight_decay = LARS_weight_decay
Q
Qiao Longfei 已提交
68

Q
Qiao Longfei 已提交
69
    def _create_global_learning_rate(self):
70
        lr = self.global_learning_rate()
Q
Qiao Longfei 已提交
71

72 73 74 75
        if isinstance(lr, framework.Variable):
            return
        else:
            if not isinstance(self._learning_rate, float):
Q
qiaolongfei 已提交
76
                raise TypeError(
77 78
                    "learning rate variable is create outside optimizer,"
                    "can not create new learning rate variable for new program")
Q
Qiao Longfei 已提交
79

80 81 82 83 84 85
        # create learning rate in the current main program
        self._learning_rate_map[framework.default_main_program(
        )] = layers.create_global_var(
            name=unique_name.generate("learning_rate"),
            shape=[1],
            value=float(self._learning_rate),
D
dzhwinter 已提交
86
            dtype='float32' if self._dtype == None else self._dtype,
87 88 89
            persistable=True)

    def global_learning_rate(self, program=None):
Q
Qiao Longfei 已提交
90 91 92 93
        """
        get global decayed learning rate
        :return:
        """
94 95
        if program is None:
            program = framework.default_main_program()
Q
qiaolongfei 已提交
96
        return self._learning_rate_map.get(program, None)
Q
Qiao Longfei 已提交
97

Q
Qiao Longfei 已提交
98 99 100 101 102
    def _append_optimize_op(self, block, param_and_grad):
        """ append optimize operator to block and return all the added optimize_op
        """
        raise NotImplementedError()

103 104 105 106
    def _create_param_lr(self, param_and_grad):
        # create learning rate variable for every parameter
        param = param_and_grad[0]
        param_lr = param.optimize_attr['learning_rate']
W
Wu Yi 已提交
107 108 109 110
        if type(param_lr) == Variable:
            # param learning rate has been updated (LARS)
            print("returns updated param lr ", param_lr)
            return param_lr
Q
qiaolongfei 已提交
111
        else:
W
Wu Yi 已提交
112 113 114 115
            if param_lr == 1.0:
                return self.global_learning_rate()
            else:
                return self.global_learning_rate() * param_lr
116 117 118 119 120 121 122

    def _create_accumulators(self, block, parameters):
        """Create all accumulators needed by the parameters

        Args:
            block: the block in which the loss variable is present
            parameters: list of parameter variables for the optimizer
Q
Qiao Longfei 已提交
123
        """
124 125
        pass

126 127 128 129 130 131 132 133 134 135 136 137 138
    def _finish_update(self, block):
        """Finish any custom updates needed
           before completing an optimization step

        Args:
            block: the block in which the loss variable is present
            parameters: list of parameter variables for the optimizer

        Returns:
            list of finish ops or None
        """
        pass

139 140 141 142 143 144
    def _add_accumulator(self,
                         name,
                         param,
                         dtype=None,
                         fill_value=0.0,
                         shape=None):
145 146 147 148 149 150 151 152 153 154 155
        """Utility function to add an accumulator for a parameter

        Args:
            block: the block in which the loss variable is present
            name: name of the accumulator
            param: parameter variable for which accumulator is to be added
            dtype: data type of the accumulator variable
            fill_value: value to initialize the accumulator variable
        """
        if (name in self._accumulators and
                param.name in self._accumulators[name]):
156
            raise Exception("Accumulator {} already exists for parameter {}".
157
                            format(name, param.name))
158 159
        if shape == None:
            shape = param.shape
Q
Qiao Longfei 已提交
160 161
        assert isinstance(self.helper, LayerHelper)
        var = self.helper.create_global_variable(
Y
Yu Yang 已提交
162
            name=unique_name.generate(name),
Q
Qiao Longfei 已提交
163
            persistable=True,
F
fengjiayi 已提交
164
            dtype=dtype or param.dtype,
Q
Qiao Longfei 已提交
165
            type=param.type,
166
            shape=shape)
Q
Qiao Longfei 已提交
167
        self.helper.set_variable_initializer(
168
            var, initializer=Constant(value=float(fill_value)))
Q
Qiao Longfei 已提交
169
        self._accumulators[name][param.name] = var
170
        return var
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187

    def _get_accumulator(self, name, param):
        """Utility function to fetch an accumulator for a parameter

        Args:
            name: name of the accumulator
            param: parameter variable for which accumulator is to be fetched

        Returns:
            accumulator variable for the parameter
        """
        if (name not in self._accumulators or
                param.name not in self._accumulators[name]):
            raise Exception("Accumulator {} does not exist for parameter {}".
                            format(name, param.name))
        return self._accumulators[name][param.name]

Q
Qiao Longfei 已提交
188 189 190
    def create_optimization_pass(self,
                                 parameters_and_grads,
                                 loss,
191
                                 startup_program=None):
Q
Qiao Longfei 已提交
192 193 194
        """Add optimization operators to update gradients to variables.

        Args:
Q
qiaolongfei 已提交
195 196 197
          loss(Variable): the target that this optimization is for.
          parameters_and_grads(list(tuple(Variable, Variable))):
          a list of (variable, gradient) pair to update.
Q
Qiao Longfei 已提交
198 199

        Returns:
200 201 202 203
          return_op_list: a list of operators that will complete one step of
          optimization. This will include parameter update ops, global step
          update ops and any other custom ops required by subclasses to manage
          their internal state.
Q
Qiao Longfei 已提交
204
        """
205 206 207 208 209
        # This is a default implementation of create_optimization_pass that
        # can be shared by most optimizers. This implementation assumes that
        # the subclass will implement the _append_optimize_op method and the
        #  _initialize_tensors method. The subclass can extend the
        # _create_accumulators method if it needs to create accumulators
210
        # for parameters and extend _finish_update method to add custom ops.
211 212

        # Create any accumulators
Q
Qiao Longfei 已提交
213
        program = loss.block.program
D
dzhwinter 已提交
214
        self._dtype = loss.dtype
215
        with program_guard(program, startup_program):
Y
Yancey1989 已提交
216 217
            global_block = framework.default_main_program().global_block()
            start = len(global_block.ops)
218 219 220
            self.helper = LayerHelper(self.__class__.__name__)
            self._create_accumulators(loss.block,
                                      [p[0] for p in parameters_and_grads])
Q
Qiao Longfei 已提交
221
            self._create_global_learning_rate()
W
Wu Yi 已提交
222 223 224 225
            if self._LARS_weight_decay > 0.0:
                layers.append_LARS(parameters_and_grads,
                                   self.global_learning_rate(),
                                   self._LARS_weight_decay)
226 227 228

            optimize_ops = []
            for param_and_grad in parameters_and_grads:
Y
yuyang18 已提交
229 230 231 232 233 234 235
                with param_and_grad[0].block.program.optimized_guard(
                        param_and_grad[0]):
                    if param_and_grad[0].trainable is True and param_and_grad[
                            1] is not None:
                        optimize_op = self._append_optimize_op(loss.block,
                                                               param_and_grad)
                        optimize_ops.append(optimize_op)
236 237 238

            # Get custom finish ops for subclasses
            # FIXME: Need to fix this once we figure out how to handle dependencies
Y
Yancey1989 已提交
239
            self._finish_update(loss.block)
240

Y
Yancey1989 已提交
241 242
            end = len(global_block.ops)
            return global_block.slice_ops(start, end)
Q
Qiao Longfei 已提交
243

Q
Qiao Longfei 已提交
244 245
    def minimize(self,
                 loss,
246
                 startup_program=None,
Q
Qiao Longfei 已提交
247 248
                 parameter_list=None,
                 no_grad_set=None):
Q
Qiao Longfei 已提交
249 250
        """Add operations to minimize `loss` by updating `parameter_list`.

F
fengjiayi 已提交
251
        This method combines interface `append_backward()` and
Q
Qiao Longfei 已提交
252 253
        `create_optimization_pass()` into one.
        """
F
fengjiayi 已提交
254
        params_grads = append_backward(loss, parameter_list, no_grad_set,
Y
Yang Yang 已提交
255
                                       [error_clip_callback])
Y
Yu Yang 已提交
256

Y
Yu Yang 已提交
257 258
        params_grads = sorted(params_grads, key=lambda x: x[0].name)

Y
Yu Yang 已提交
259 260
        params_grads = append_gradient_clip_ops(params_grads)

F
fengjiayi 已提交
261
        # Add regularization if any
D
dzhwinter 已提交
262 263
        params_grads = append_regularization_ops(params_grads,
                                                 self.regularization)
Y
Yu Yang 已提交
264

Q
Qiao Longfei 已提交
265
        optimize_ops = self.create_optimization_pass(params_grads, loss,
266
                                                     startup_program)
T
typhoonzero 已提交
267
        return optimize_ops, params_grads
Q
Qiao Longfei 已提交
268 269 270


class SGDOptimizer(Optimizer):
Q
qiaolongfei 已提交
271 272 273 274 275 276 277 278 279 280 281 282 283 284
    """
    Optimizer of the stochastic gradient descent algorithm.

    .. math::

        param\_out = param - learning\_rate * grad

    Args:
        learning_rate (float|Variable): the learning rate used to update parameters. \
        Can be a float value or a Variable with one float value as data element.

    Examples:
        .. code-block:: python

Q
qiaolongfei 已提交
285
            sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.2)
Q
qiaolongfei 已提交
286
            sgd_optimizer.minimize(cost)
Q
Qiao Longfei 已提交
287 288
    """

D
dzhwinter 已提交
289
    def __init__(self, learning_rate, **kwargs):
Q
Qiao Longfei 已提交
290
        assert learning_rate is not None
Q
Qiao Longfei 已提交
291 292
        super(SGDOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
Q
Qiao Longfei 已提交
293 294
        self.type = "sgd"

295 296
    def _append_optimize_op(self, block, param_and_grad):
        assert isinstance(block, framework.Block)
297

Q
Qiao Longfei 已提交
298 299 300 301 302 303
        # create the optimize op
        sgd_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
304
                "LearningRate": self._create_param_lr(param_and_grad)
Q
Qiao Longfei 已提交
305
            },
306
            outputs={"ParamOut": param_and_grad[0]})
Q
Qiao Longfei 已提交
307 308

        return sgd_op
309 310 311


class MomentumOptimizer(Optimizer):
Q
qiaolongfei 已提交
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
    """

    Simple Momentum optimizer with velocity state

    This optimizer has a flag for Nestrov Momentum.

    The update equations are as follows:

    .. math::

        & velocity = mu * velocity + gradient

        & if (use\_nesterov):

        &   param = param - gradient * learning\_rate + mu * velocity * learning\_rate

        & else:

        &   param = param - learning\_rate * velocity

    Args:
        learning_rate (float|Variable): the learning rate used to update parameters. \
        Can be a float value or a Variable with one float value as data element.
        momentum (float): momentum factor
        use_nesterov (bool): enables Nesterov momentum

    Examples:
        .. code-block:: python

Q
qiaolongfei 已提交
341
            optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
Q
qiaolongfei 已提交
342
            optimizer.minimize(cost)
343 344 345
    """
    _velocity_acc_str = "velocity"

D
dzhwinter 已提交
346
    def __init__(self, learning_rate, momentum, use_nesterov=False, **kwargs):
347 348
        assert learning_rate is not None
        assert momentum is not None
Q
Qiao Longfei 已提交
349 350
        super(MomentumOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
351 352
        self.type = "momentum"
        self._momentum = momentum
353
        self._use_nesterov = bool(use_nesterov)
354 355 356 357 358

    def _create_accumulators(self, block, parameters):
        assert isinstance(block, framework.Block)

        for p in parameters:
Q
Qiao Longfei 已提交
359
            self._add_accumulator(self._velocity_acc_str, p)
360 361 362 363 364 365 366 367 368 369 370 371 372

    def _append_optimize_op(self, block, param_and_grad):
        assert isinstance(block, framework.Block)

        velocity_acc = self._get_accumulator(self._velocity_acc_str,
                                             param_and_grad[0])
        # create the momentum optimize op
        momentum_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "Velocity": velocity_acc,
373
                "LearningRate": self._create_param_lr(param_and_grad)
374 375 376 377 378
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "VelocityOut": velocity_acc
            },
379
            attrs={"mu": self._momentum,
380
                   "use_nesterov": self._use_nesterov})
381 382

        return momentum_op
383 384 385


class AdagradOptimizer(Optimizer):
Q
qiaolongfei 已提交
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
    """
    **Adaptive Gradient Algorithm (Adagrad)**

    The update is done as follows:

    .. math::

        moment\_out &= moment + grad * grad

        param\_out &= param - \\frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}

    The original paper(http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)
    does not have the epsilon attribute. It is added here in our implementation
    as also proposed here: http://cs231n.github.io/neural-networks-3/#ada
    for numerical stability to avoid the division by zero error.

    Args:
        learning_rate (float|Variable): the learning rate used to update parameters. \
        Can be a float value or a Variable with one float value as data element.
        epsilon (float): a small float value for numerical stability.

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
            optimizer.minimize(cost)
412 413 414
    """
    _moment_acc_str = "moment"

D
dzhwinter 已提交
415
    def __init__(self, learning_rate, epsilon=1.0e-6, **kwargs):
416 417
        assert learning_rate is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
418 419
        super(AdagradOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
420 421 422 423 424 425 426
        self.type = "adagrad"
        self._epsilon = epsilon

    def _create_accumulators(self, block, parameters):
        assert isinstance(block, framework.Block)

        for p in parameters:
Q
Qiao Longfei 已提交
427
            self._add_accumulator(self._moment_acc_str, p)
428 429 430 431 432 433 434

    def _append_optimize_op(self, block, param_and_grad):
        assert isinstance(block, framework.Block)

        moment_acc = self._get_accumulator(self._moment_acc_str,
                                           param_and_grad[0])

435
        # Create the adagrad optimizer op
436 437 438 439 440 441
        adagrad_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "Moment": moment_acc,
442
                "LearningRate": self._create_param_lr(param_and_grad)
443 444 445 446 447 448
            },
            outputs={"ParamOut": param_and_grad[0],
                     "MomentOut": moment_acc},
            attrs={"epsilon": self._epsilon})

        return adagrad_op
449 450 451 452 453 454 455 456 457 458 459 460


class AdamOptimizer(Optimizer):
    """Implements the Adam Optimizer
    """
    _moment1_acc_str = "moment1"
    _moment2_acc_str = "moment2"

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
461
                 epsilon=1e-8,
D
dzhwinter 已提交
462
                 **kwargs):
463 464 465 466
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
467 468
        super(AdamOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
469 470 471 472 473 474 475 476
        self.type = "adam"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon

    def _create_accumulators(self, block, parameters):
        assert isinstance(block, framework.Block)

Q
Qiao Longfei 已提交
477
        main_block = block.program.global_block()
478 479
        # Create beta1 and beta2 power tensors
        beta_shape = [1]
Q
Qiao Longfei 已提交
480
        self._beta1_pow_acc = self.helper.create_global_variable(
Y
Yu Yang 已提交
481
            name=unique_name.generate('beta1_pow_acc'),
D
dzhwinter 已提交
482
            dtype='float32' if self._dtype == None else self._dtype,
Q
Qiao Longfei 已提交
483 484 485 486
            shape=beta_shape,
            lod_level=0,
            persistable=True)
        self.helper.set_variable_initializer(
487
            self._beta1_pow_acc, initializer=Constant(self._beta1))
Q
Qiao Longfei 已提交
488 489

        self._beta2_pow_acc = self.helper.create_global_variable(
Y
Yu Yang 已提交
490
            name=unique_name.generate('beta2_pow_acc'),
D
dzhwinter 已提交
491
            dtype='float32' if self._dtype == None else self._dtype,
Q
Qiao Longfei 已提交
492 493 494 495 496
            shape=beta_shape,
            lod_level=0,
            persistable=True)

        self.helper.set_variable_initializer(
497
            self._beta2_pow_acc, initializer=Constant(self._beta2))
498 499 500

        # Create accumulator tensors for first and second moments
        for p in parameters:
Q
Qiao Longfei 已提交
501 502
            self._add_accumulator(self._moment1_acc_str, p)
            self._add_accumulator(self._moment2_acc_str, p)
503 504 505 506 507 508 509 510

    def _append_optimize_op(self, block, param_and_grad):
        assert isinstance(block, framework.Block)

        moment1 = self._get_accumulator(self._moment1_acc_str,
                                        param_and_grad[0])
        moment2 = self._get_accumulator(self._moment2_acc_str,
                                        param_and_grad[0])
511
        # create the adam optimize op
512 513 514 515 516
        adam_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
517
                "LearningRate": self._create_param_lr(param_and_grad),
518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
                "Moment1": moment1,
                "Moment2": moment2,
                "Beta1Pow": self._beta1_pow_acc,
                "Beta2Pow": self._beta2_pow_acc
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "Moment1Out": moment1,
                "Moment2Out": moment2
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adam_op

    def _finish_update(self, block):
        """Update Beta1 and Beta2 Power accumulators
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
540 541
        main_block = block.program.global_block()
        scale_beta1 = main_block.append_op(
542 543 544 545 546
            type="scale",
            inputs={"X": self._beta1_pow_acc},
            outputs={"Out": self._beta1_pow_acc},
            attrs={"scale": self._beta1})

Q
Qiao Longfei 已提交
547
        scale_beta2 = main_block.append_op(
548 549 550 551 552 553
            type="scale",
            inputs={"X": self._beta2_pow_acc},
            outputs={"Out": self._beta2_pow_acc},
            attrs={"scale": self._beta2})

        return [scale_beta1, scale_beta2]
554 555 556 557 558 559 560 561 562 563 564 565


class AdamaxOptimizer(Optimizer):
    """Implements the Adamax Optimizer
    """
    _moment_acc_str = "moment"
    _inf_norm_acc_str = "inf_norm"

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
566
                 epsilon=1e-8,
D
dzhwinter 已提交
567
                 **kwargs):
568 569 570 571
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
572 573
        super(AdamaxOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
574 575 576 577 578 579 580 581
        self.type = "adamax"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon

    def _create_accumulators(self, block, parameters):
        # Create beta1 power accumulator tensor
        beta_shape = [1]
Q
Qiao Longfei 已提交
582
        self._beta1_pow_acc = self.helper.create_global_variable(
Y
Yu Yang 已提交
583
            name=unique_name.generate('beta1_pow_acc'),
D
dzhwinter 已提交
584
            dtype='float32' if self._dtype == None else self._dtype,
Q
Qiao Longfei 已提交
585 586 587 588
            shape=beta_shape,
            lod_level=0,
            persistable=True)
        self.helper.set_variable_initializer(
589
            self._beta1_pow_acc, initializer=Constant(self._beta1))
590 591 592

        # Create accumulator tensors for first moment and infinity norm
        for p in parameters:
Q
Qiao Longfei 已提交
593 594
            self._add_accumulator(self._moment_acc_str, p)
            self._add_accumulator(self._inf_norm_acc_str, p)
595 596 597 598 599 600 601 602 603 604 605 606 607

    def _append_optimize_op(self, block, param_and_grad):
        assert isinstance(block, framework.Block)

        moment = self._get_accumulator(self._moment_acc_str, param_and_grad[0])
        inf_norm = self._get_accumulator(self._inf_norm_acc_str,
                                         param_and_grad[0])
        # create the adamax optimize op
        adamax_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
608
                "LearningRate": self._create_param_lr(param_and_grad),
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
                "Moment": moment,
                "InfNorm": inf_norm,
                "Beta1Pow": self._beta1_pow_acc
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "MomentOut": moment,
                "InfNormOut": inf_norm
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adamax_op

    def _finish_update(self, block):
        """Update Beta1 Power accumulator
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
630 631
        main_block = block.program.global_block()
        scale_beta1 = main_block.append_op(
632 633 634 635 636 637
            type="scale",
            inputs={"X": self._beta1_pow_acc},
            outputs={"Out": self._beta1_pow_acc},
            attrs={"scale": self._beta1})

        return [scale_beta1]
638 639 640 641 642 643 644


class DecayedAdagradOptimizer(Optimizer):
    """Simple Decayed Adagrad optimizer with moment state
    """
    _moment_acc_str = "moment"

D
dzhwinter 已提交
645
    def __init__(self, learning_rate, decay=0.95, epsilon=1.0e-6, **kwargs):
646 647 648 649
        assert learning_rate is not None
        assert decay is not None
        assert epsilon is not None

Q
Qiao Longfei 已提交
650 651
        super(DecayedAdagradOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
        self.type = "decayed_adagrad"
        self._decay = decay
        self._epsilon = epsilon

    def _create_accumulators(self, block, parameters):
        assert isinstance(block, framework.Block)

        for p in parameters:
            self._add_accumulator(self._moment_acc_str, p)

    def _append_optimize_op(self, block, param_and_grad):
        assert isinstance(block, framework.Block)

        moment_acc = self._get_accumulator(self._moment_acc_str,
                                           param_and_grad[0])

        # Create the decayed adagrad optimizer op
        decayed_adagrad_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "Moment": moment_acc,
                "LearningRate": self._create_param_lr(param_and_grad)
            },
            outputs={"ParamOut": param_and_grad[0],
                     "MomentOut": moment_acc},
            attrs={"epsilon": self._epsilon})

        return decayed_adagrad_op
682 683


684
class AdadeltaOptimizer(Optimizer):
685 686
    """
    **Adadelta Optimizer**
Q
qiaolongfei 已提交
687

688
    Simple Adadelta optimizer with average squared grad state and
689
    average squared update state.
690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711
    The details of adadelta please refer to this
    `ADADELTA: AN ADAPTIVE LEARNING RATE METHOD
    <http://www.matthewzeiler.com/pubs/googleTR2012/googleTR2012.pdf>`_.

    ..  math::

        E(g_t^2) &= \\rho * E(g_{t-1}^2) + (1-\\rho) * g^2 \\\\
        learning\\_rate &= sqrt( ( E(dx_{t-1}^2) + \\epsilon ) / ( \\
                          E(g_t^2) + \\epsilon ) ) \\\\
        E(dx_t^2) &= \\rho * E(dx_{t-1}^2) + (1-\\rho) * (-g*learning\\_rate)^2

    Args:
        learning_rate(float): global leraning rate
        rho(float): rho in equation
        epsilon(float): epsilon in equation

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adadelta(
                learning_rate=0.0003, epsilon=1.0e-6, rho=0.95)
            _, params_grads = optimizer.minimize(cost)
712
    """
713

714 715 716 717
    _avg_squared_grad_acc_str = "_avg_squared_grad"
    _avg_squared_update_acc_str = "_avg_squared_update"

    def __init__(self, learning_rate, epsilon=1.0e-6, rho=0.95, **kwargs):
718 719 720 721 722 723
        if learning_rate is None:
            raise ValueError("learning_rate is not set.")
        if epsilon is None:
            raise ValueError("epsilon is not set.")
        if rho is None:
            raise ValueError("rho is not set.")
724 725 726 727 728 729 730
        super(AdadeltaOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
        self.type = "adadelta"
        self._epsilon = epsilon
        self._rho = rho

    def _create_accumulators(self, block, parameters):
731 732
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
733 734 735 736 737 738

        for p in parameters:
            self._add_accumulator(self._avg_squared_grad_acc_str, p)
            self._add_accumulator(self._avg_squared_update_acc_str, p)

    def _append_optimize_op(self, block, param_and_grad):
739 740
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766

        avg_squared_grad_acc = self._get_accumulator(
            self._avg_squared_grad_acc_str, param_and_grad[0])
        avg_squared_update_acc = self._get_accumulator(
            self._avg_squared_update_acc_str, param_and_grad[0])

        # Create the adadelta optimizer op
        adadelta_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "AvgSquaredGrad": avg_squared_grad_acc,
                "AvgSquaredUpdate": avg_squared_update_acc
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "AvgSquaredGradOut": avg_squared_grad_acc,
                "AvgSquaredUpdateOut": avg_squared_update_acc
            },
            attrs={"epsilon": self._epsilon,
                   "rho": self._rho})

        return adadelta_op


Q
qingqing01 已提交
767 768 769 770 771 772 773 774 775 776
class RMSPropOptimizer(Optimizer):
    """
    Root Mean Squared Propagation (RMSProp) is an unpublished, adaptive learning
    rate method. The original slides proposed RMSProp: Slide 29 of
    http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf .

    The original equation is as follows:

    ..  math::

Q
qiaolongfei 已提交
777
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
778 779 780 781

        w & = w - \\frac{\\eta} {\\sqrt{r(w,t) + \\epsilon}} \\nabla Q_{i}(w)

    The first equation calculates moving average of the squared gradient for
Q
qiaolongfei 已提交
782
    each weight. Then dividing the gradient by :math:`sqrt{v(w,t)}`.
Q
qingqing01 已提交
783 784 785 786 787 788

    In some cases, adding a momentum term :math: `\\beta` is beneficial.
    In our implementation, Nesterov momentum is used:

    ..  math::

Q
qiaolongfei 已提交
789
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
790 791 792 793 794 795

        v(w, t) & = \\beta v(w, t-1) + \\frac{\\eta} {\\sqrt{v(w,t) +
            \\epsilon}} \\nabla Q_{i}(w)

        w & = w - v(w, t)

Q
qiaolongfei 已提交
796
    where, :math:`\\rho` is a hyperparameter and typical values are 0.9, 0.95
Q
qingqing01 已提交
797 798 799 800 801 802 803
    and so on. :math: `beta` is the momentum term. :math: `\\epsilon` is a
    smoothing term to avoid division by zero, usually set somewhere in range
    from 1e-4 to 1e-8.


    Args:
        learning_rate(float): global leraning rate.
Q
qiaolongfei 已提交
804 805
        rho(float): rho is :math:`\\rho` in equation, set 0.95 by default.
        epsilon(float): :math:`\\epsilon` in equation is smoothing term to
Q
qingqing01 已提交
806
            avoid division by zero, set 1e-6 by default.
Q
qiaolongfei 已提交
807
        momentum(float): :math:`\\beta` in equation is the momentum term,
Q
qingqing01 已提交
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
            set 0.0 by default.

    Raises:
        ValueError: If learning_rate, rho, epsilon, momentum are None.

    Examples:
          .. code-block:: python

              optimizer = fluid.optimizer.RMSProp(0.0001)
              _, params_grads = optimizer.minimize(cost)
    """

    _momentum_acc_str = "momentum"
    _mean_square_acc_str = "mean_square"

    def __init__(self,
                 learning_rate,
                 rho=0.95,
                 epsilon=1.0e-6,
                 momentum=0.0,
                 **kwargs):
        super(RMSPropOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
        if learning_rate is None:
            raise ValueError("learning_rate is not set.")
        if rho is None:
            raise ValueError("rho is not set.")
        if epsilon is None:
            raise ValueError("epsilon is not set.")
        if momentum is None:
            raise ValueError("momentum is not set.")

        self.type = "rmsprop"
        self._rho = rho
        self._epsilon = epsilon
        self._momentum = momentum

    def _create_accumulators(self, block, parameters):
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")

        for p in parameters:
            self._add_accumulator(self._momentum_acc_str, p)
            self._add_accumulator(self._mean_square_acc_str, p)

    def _append_optimize_op(self, block, param_and_grad):
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")

        momentum_acc = self._get_accumulator(self._momentum_acc_str,
                                             param_and_grad[0])
        mean_square_acc = self._get_accumulator(self._mean_square_acc_str,
                                                param_and_grad[0])
        rmsprop_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "Moment": momentum_acc,
                "MeanSquare": mean_square_acc,
                "LearningRate": self._create_param_lr(param_and_grad),
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "MomentOut": momentum_acc,
                "MeanSquareOut": mean_square_acc
            },
            attrs={
                "epsilon": self._epsilon,
                "decay": self._rho,
                "momentum": self._momentum
            })

        return rmsprop_op


884 885 886 887 888 889 890 891 892 893 894 895 896 897
# We short the class name, since users will use the optimizer with the package
# name. The sample code:
#
# import paddle.fluid as fluid
#
# sgd = fluid.optimizer.SGD(...)
#
# It is no need to add an `Optimizer` as the class suffix
SGD = SGDOptimizer
Momentum = MomentumOptimizer
Adagrad = AdagradOptimizer
Adam = AdamOptimizer
Adamax = AdamaxOptimizer
DecayedAdagrad = DecayedAdagradOptimizer
898
Adadelta = AdadeltaOptimizer
Q
qingqing01 已提交
899
RMSProp = RMSPropOptimizer
900 901 902 903 904 905 906 907 908 909 910 911 912


class ModelAverage(Optimizer):
    """Accumulate the average of parameters whtin sliding window. The average
    result will be saved in temporary variables which can be applied to
    parameter variables of current model by calling 'apply()' method. And the
    'restore()' method is used to restored the parameter values of current model.

    The size of average window is determined by average_window_rate,
    min_average_window, max_average_window and current update times.

    Args:
        average_window_rate: The rate of average window.
W
wanghaoshuang 已提交
913
        params_grads: A list of parameter-grad variable pairs.
914 915 916 917
        min_average_window: The minimum size of average window.
        max_average_window: The maximum size of average window.

    Examples:
Q
qiaolongfei 已提交
918 919 920

      .. code-block:: python

921 922 923 924 925 926 927 928
        optimizer = fluid.optimizer.Momentum()
        _, params_grads = optimizer.minimize(cost)
        model_average = fluid.optimizer.ModelAverage(params_grads, 0.15,
                                                min_average_window=10000,
                                                max_average_window=20000)
        for pass_id in range(args.pass_num):
            for data in train_reader():
                exe.run(fluid.default_main_program()...)
929 930 931 932

            with model_average.apply(exe):
                for data in test_reader():
                    exe.run(inference_program...)
933 934 935
    """

    def __init__(self,
W
wanghaoshuang 已提交
936
                 average_window_rate,
W
wanghaoshuang 已提交
937
                 params_grads=None,
938 939 940 941 942 943 944
                 min_average_window=10000,
                 max_average_window=10000,
                 **kwargs):
        super(ModelAverage, self).__init__(0.0, **kwargs)
        self.average_window = average_window_rate
        self.min_average_window = min_average_window
        self.max_average_window = max_average_window
945

W
wanghaoshuang 已提交
946 947 948
        self.params_grads = [] if params_grads is None else params_grads
        params = {}
        for param, grad in self.params_grads:
949 950
            if param.do_model_average != False:
                params[param.name] = (param, grad)
951 952
        for param in framework.default_main_program().global_block(
        ).all_parameters():
W
wanghaoshuang 已提交
953
            if param.name not in params and param.do_model_average != False:
954 955 956 957
                grad = param.block.create_var(
                    name=unique_name.generate(".".join([param.name, 'tmp'])),
                    dtype=param.dtype,
                    persistable=False,
W
wanghaoshuang 已提交
958 959 960
                    stop_gradient=True)
                params[param.name] = (param, grad)
        self.params_grads = params.values()
961

962
        for param, grad in self.params_grads:
963
            self._append_average_accumulate_op(param)
964

965 966 967 968
        self.apply_program = Program()
        block = self.apply_program.global_block()
        with program_guard(main_program=self.apply_program):
            for param_grad in self.params_grads:
969
                self._add_average_apply_op(block, param_grad)
970 971 972 973 974

        self.restore_program = Program()
        block = self.restore_program.global_block()
        with program_guard(main_program=self.restore_program):
            for param_grad in self.params_grads:
975
                self._add_average_restore_op(block, param_grad)
976

977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993
    def _add_average_apply_op(self, block, param_grad):
        param = block.clone_variable(param_grad[0])
        grad = block.clone_variable(param_grad[1])
        sum_1 = block.clone_variable(self._get_accumulator('sum_1', param))
        sum_2 = block.clone_variable(self._get_accumulator('sum_2', param))
        sum_3 = block.clone_variable(self._get_accumulator('sum_3', param))
        num_accumulates = block.clone_variable(
            self._get_accumulator('num_accumulates', param))
        old_num_accumulates = block.clone_variable(
            self._get_accumulator('old_num_accumulates', param))
        num_updates = block.clone_variable(
            self._get_accumulator('num_updates', param))
        # backup param value to grad
        layers.assign(input=param, output=grad)
        # param = (sum_1 + sum_2 + sum_3) / (num_accumulates + old_num_accumulates)
        tmp = layers.sum(x=[num_accumulates, old_num_accumulates])
        sum = layers.sum(x=[sum_1, sum_2, sum_3])
D
dzhwinter 已提交
994 995 996 997
        tmp = layers.cast(
            x=tmp, dtype='float32' if self._dtype == None else self._dtype)
        sum = layers.cast(
            x=sum, dtype='float32' if self._dtype == None else self._dtype)
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
        layers.elementwise_div(x=sum, y=tmp, out=param)

    def _add_average_restore_op(self, block, param_grad):
        param = block.clone_variable(param_grad[0])
        grad = block.clone_variable(param_grad[1])
        layers.assign(input=grad, output=param)

    def _append_average_accumulate_op(self, param):
        self.helper = LayerHelper("average_accumulate")
        sum_1 = self._add_accumulator('sum_1', param)
        sum_2 = self._add_accumulator('sum_2', param)
        sum_3 = self._add_accumulator('sum_3', param)
        num_accumulates = self._add_accumulator(
            'num_accumulates', param, dtype='int64', shape=[1])
        old_num_accumulates = self._add_accumulator(
            'old_num_accumulates', param, dtype='int64', shape=[1])
        num_updates = self._add_accumulator(
            'num_updates', param, dtype='int64', shape=[1])

        self.helper.append_op(
            type='average_accumulates',
            inputs={
                "param": param,
                "in_sum_1": sum_1,
                "in_sum_2": sum_2,
                "in_sum_3": sum_3,
                "in_num_accumulates": num_accumulates,
                "in_old_num_accumulates": old_num_accumulates,
                "in_num_updates": num_updates
            },
            outputs={
                "out_sum_1": sum_1,
                "out_sum_2": sum_2,
                "out_sum_3": sum_3,
                "out_num_accumulates": num_accumulates,
                "out_old_num_accumulates": old_num_accumulates,
                "out_num_updates": num_updates,
            },
            attrs={
                "average_window": self.average_window,
                "min_average_window": self.min_average_window,
                "max_average_window": self.max_average_window,
            })

1042 1043
    @contextmanager
    def apply(self, executor, need_restore=True):
1044 1045
        """Apply average values to parameters of current model.
        """
1046 1047 1048 1049 1050 1051
        executor.run(self.apply_program)
        try:
            yield
        finally:
            if need_restore:
                self.restore(executor)
1052 1053 1054 1055

    def restore(self, executor):
        """Restore parameter values of current model.
        """
1056
        executor.run(self.restore_program)