optimizer.py 45.3 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 18 19 20 21 22 23 24 25
from . import framework
from . import layers
from .backward import append_backward
from .framework import program_guard
from . import unique_name
from .initializer import Constant
from .layer_helper import LayerHelper
from .regularizer import append_regularization_ops
from .clip import append_gradient_clip_ops, error_clip_callback
26
from contextlib import contextmanager
27

28
__all__ = [
Q
qiaolongfei 已提交
29
    'SGD', 'Momentum', 'Adagrad', 'Adam', 'Adamax', 'DecayedAdagrad', 'Ftrl',
30
    'SGDOptimizer', 'MomentumOptimizer', 'AdagradOptimizer', 'AdamOptimizer',
W
weixing02 已提交
31
    'AdamaxOptimizer', 'DecayedAdagradOptimizer', 'RMSPropOptimizer',
Y
yuyang18 已提交
32
    'FtrlOptimizer', 'Adadelta', 'ModelAverage', 'RMSPropOptimizer'
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):
Y
yuyang18 已提交
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
            persistable=True)

Y
yuyang18 已提交
89
    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
        if type(param_lr) == Variable:
            # param learning rate has been updated (LARS)
109
            print(("returns updated param lr ", param_lr))
W
Wu Yi 已提交
110
            return param_lr
Q
qiaolongfei 已提交
111
        else:
W
Wu Yi 已提交
112
            if param_lr == 1.0:
Y
yuyang18 已提交
113
                return self._global_learning_rate()
W
Wu Yi 已提交
114
            else:
Y
yuyang18 已提交
115
                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
    def _finish_update(self, block, parameters_and_grads):
127 128 129 130 131 132 133 134
        """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:
Q
qiaolongfei 已提交
135
            None
136 137 138
        """
        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]

Y
yuyang18 已提交
188 189 190 191
    def _create_optimization_pass(self,
                                  parameters_and_grads,
                                  loss,
                                  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
            if self._LARS_weight_decay > 0.0:
                layers.append_LARS(parameters_and_grads,
Y
yuyang18 已提交
224
                                   self._global_learning_rate(),
W
Wu Yi 已提交
225
                                   self._LARS_weight_decay)
226 227 228

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

            # Get custom finish ops for subclasses
            # FIXME: Need to fix this once we figure out how to handle dependencies
240
            self._finish_update(loss.block, parameters_and_grads)
241

Y
Yancey1989 已提交
242
            end = len(global_block.ops)
W
Wu Yi 已提交
243
            return global_block._slice_ops(start, end)
Q
Qiao Longfei 已提交
244

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

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

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

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

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

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


class SGDOptimizer(Optimizer):
Q
qiaolongfei 已提交
272 273 274 275 276 277 278 279 280 281 282 283 284 285
    """
    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 已提交
286
            sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.2)
Q
qiaolongfei 已提交
287
            sgd_optimizer.minimize(cost)
Q
Qiao Longfei 已提交
288 289
    """

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

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

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

        return sgd_op
310 311 312


class MomentumOptimizer(Optimizer):
Q
qiaolongfei 已提交
313 314 315 316 317 318 319 320 321 322 323 324 325 326
    """

    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):

327
        &\quad   param = param - (gradient + mu * velocity) * learning\_rate
Q
qiaolongfei 已提交
328 329 330

        & else:

Q
qiaolongfei 已提交
331
        &\quad   param = param - learning\_rate * velocity
Q
qiaolongfei 已提交
332 333 334 335 336 337 338 339 340 341

    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 已提交
342
            optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
Q
qiaolongfei 已提交
343
            optimizer.minimize(cost)
344 345 346
    """
    _velocity_acc_str = "velocity"

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

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

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

    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,
374
                "LearningRate": self._create_param_lr(param_and_grad)
375 376 377 378 379
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "VelocityOut": velocity_acc
            },
380
            attrs={"mu": self._momentum,
381
                   "use_nesterov": self._use_nesterov})
382 383

        return momentum_op
384 385 386


class AdagradOptimizer(Optimizer):
Q
qiaolongfei 已提交
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 412
    """
    **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)
413 414 415
    """
    _moment_acc_str = "moment"

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

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

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

    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])

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

        return adagrad_op
450 451 452


class AdamOptimizer(Optimizer):
Q
qiaolongfei 已提交
453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
    """
    This implements the Adam optimizer from Section 2 of the Adam
    paper : https://arxiv.org/abs/1412.6980.
    Adam is a first-order gradient-based optimization method based on
    adaptive estimates of lower-order moments.

    Adam updates:

    .. math::

        t & = t + 1

        moment\_1\_out & = {\\beta}_1 * moment\_1 + (1 - {\\beta}_1) * grad

        moment\_2\_out & = {\\beta}_2 * moment\_2 + (1 - {\\beta}_2) * grad * grad

        learning\_rate & = learning\_rate * \\
                          \\frac{\sqrt{1 - {\\beta}_2^t}}{1 - {\\beta}_1^t}

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

    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.
        beta1 (float): The exponential decay rate for the 1st moment estimates.
        beta2 (float): The exponential decay rate for the 2nd moment estimates.
        epsilon (float): a small float value for numerical stability.

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adam(learning_rate=0.2)
            optimizer.minimize(cost)

487 488 489
    """
    _moment1_acc_str = "moment1"
    _moment2_acc_str = "moment2"
Q
qiaolongfei 已提交
490 491
    _beta1_pow_acc_str = "beta1_pow_acc"
    _beta2_pow_acc_str = "beta2_pow_acc"
492 493 494 495 496

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
497
                 epsilon=1e-8,
D
dzhwinter 已提交
498
                 **kwargs):
499 500 501 502
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
503 504
        super(AdamOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
505 506 507 508 509 510 511 512 513 514
        self.type = "adam"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon

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

        # Create accumulator tensors for first and second moments
        for p in parameters:
Q
Qiao Longfei 已提交
515 516
            self._add_accumulator(self._moment1_acc_str, p)
            self._add_accumulator(self._moment2_acc_str, p)
Q
qiaolongfei 已提交
517 518 519 520 521 522 523 524 525 526 527 528
            self._add_accumulator(
                name=self._beta1_pow_acc_str,
                param=p,
                dtype='float32',
                fill_value=self._beta1,
                shape=[1])
            self._add_accumulator(
                name=self._beta2_pow_acc_str,
                param=p,
                dtype='float32',
                fill_value=self._beta2,
                shape=[1])
529 530 531 532 533 534 535 536

    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])
Q
qiaolongfei 已提交
537 538 539 540 541
        beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                              param_and_grad[0])
        beta2_pow_acc = self._get_accumulator(self._beta2_pow_acc_str,
                                              param_and_grad[0])

542
        # create the adam optimize op
543 544 545 546 547
        adam_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
548
                "LearningRate": self._create_param_lr(param_and_grad),
549 550
                "Moment1": moment1,
                "Moment2": moment2,
Q
qiaolongfei 已提交
551 552
                "Beta1Pow": beta1_pow_acc,
                "Beta2Pow": beta2_pow_acc
553 554 555 556 557 558 559 560 561 562 563 564 565 566
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "Moment1Out": moment1,
                "Moment2Out": moment2
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adam_op

567
    def _finish_update(self, block, param_and_grads):
568 569 570
        """Update Beta1 and Beta2 Power accumulators
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
571
        main_block = block.program.global_block()
572 573 574 575
        for param, grad in param_and_grads:
            if grad is None:
                continue
            with param.block.program.optimized_guard([param, grad]):
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
                beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                                      param)
                beta2_pow_acc = self._get_accumulator(self._beta2_pow_acc_str,
                                                      param)
                main_block.append_op(
                    type="scale",
                    inputs={"X": beta1_pow_acc},
                    outputs={"Out": beta1_pow_acc},
                    attrs={"scale": self._beta1})

                main_block.append_op(
                    type="scale",
                    inputs={"X": beta2_pow_acc},
                    outputs={"Out": beta2_pow_acc},
                    attrs={"scale": self._beta2})
591 592 593


class AdamaxOptimizer(Optimizer):
Q
qiaolongfei 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
    """
    We implement the Adamax optimizer from Section 7 of the Adam
    paper: https://arxiv.org/abs/1412.6980. Adamax is a variant of the
    Adam algorithm based on the infinity norm.

    Adamax updates:

    .. math::

        t & = t + 1

        moment\_out & = {\\beta}_1 * moment + (1 - {\\beta}_1) * grad

        inf\_norm\_out & = max({\\beta}_2 * inf\_norm + \epsilon, |grad|)

        learning\_rate & = \\frac{learning\_rate}{1 - {\\beta}_1^t}

        param\_out & = param - learning\_rate * \\frac{moment\_out}{inf\_norm\_out}


    The original paper does not have an epsilon attribute.
    However, it is added here for numerical stability to prevent the
    division by 0 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.
        beta1 (float): The exponential decay rate for the 1st moment estimates.
        beta2 (float): The exponential decay rate for the 2nd moment estimates.
        epsilon (float): a small float value for numerical stability.

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adamax(learning_rate=0.2)
            optimizer.minimize(cost)
630 631 632
    """
    _moment_acc_str = "moment"
    _inf_norm_acc_str = "inf_norm"
Q
qiaolongfei 已提交
633
    _beta1_pow_acc_str = "beta1_pow_acc"
634 635 636 637 638

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
639
                 epsilon=1e-8,
D
dzhwinter 已提交
640
                 **kwargs):
641 642 643 644
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
645 646
        super(AdamaxOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
647 648 649 650 651 652 653 654
        self.type = "adamax"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon

    def _create_accumulators(self, block, parameters):
        # Create accumulator tensors for first moment and infinity norm
        for p in parameters:
Q
Qiao Longfei 已提交
655 656
            self._add_accumulator(self._moment_acc_str, p)
            self._add_accumulator(self._inf_norm_acc_str, p)
Q
qiaolongfei 已提交
657 658 659 660 661 662
            self._add_accumulator(
                name=self._beta1_pow_acc_str,
                param=p,
                dtype='float32',
                fill_value=self._beta1,
                shape=[1])
663 664 665 666 667 668 669

    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])
Q
qiaolongfei 已提交
670 671
        beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                              param_and_grad[0])
672 673 674 675 676 677
        # create the adamax optimize op
        adamax_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
678
                "LearningRate": self._create_param_lr(param_and_grad),
679 680
                "Moment": moment,
                "InfNorm": inf_norm,
Q
qiaolongfei 已提交
681
                "Beta1Pow": beta1_pow_acc
682 683 684 685 686 687 688 689 690 691 692 693 694 695
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "MomentOut": moment,
                "InfNormOut": inf_norm
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adamax_op

696
    def _finish_update(self, block, parameters_and_grads):
697 698 699
        """Update Beta1 Power accumulator
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
700
        main_block = block.program.global_block()
701 702 703 704
        for param, grad in parameters_and_grads:
            if grad is None:
                continue
            with param.block.program.optimized_guard([param, grad]):
705 706 707 708 709 710 711
                beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                                      param)
                main_block.append_op(
                    type="scale",
                    inputs={"X": beta1_pow_acc},
                    outputs={"Out": beta1_pow_acc},
                    attrs={"scale": self._beta1})
712 713 714


class DecayedAdagradOptimizer(Optimizer):
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
    """
    **Decayed Adagrad Optimizer**

    The original paper(http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)

    The update is done as follows:

    .. math::

        moment\_out & = decay * moment + (1 - decay) * 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 an epsilon attribute. It is added here 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.
        decay (float): decay rate.
        epsilon (float): a small float value for numerical stability.

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
            optimizer.minimize(cost)
743 744 745
    """
    _moment_acc_str = "moment"

D
dzhwinter 已提交
746
    def __init__(self, learning_rate, decay=0.95, epsilon=1.0e-6, **kwargs):
747 748 749 750
        assert learning_rate is not None
        assert decay is not None
        assert epsilon is not None

Q
Qiao Longfei 已提交
751 752
        super(DecayedAdagradOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
        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
783 784


785
class AdadeltaOptimizer(Optimizer):
786 787
    """
    **Adadelta Optimizer**
Q
qiaolongfei 已提交
788

789
    Simple Adadelta optimizer with average squared grad state and
790
    average squared update state.
791 792 793 794 795 796 797 798 799 800 801 802
    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:
Q
qiaolongfei 已提交
803
        learning_rate(float): global learning rate
804 805 806 807 808 809 810 811 812
        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)
813
    """
814

815 816 817 818
    _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):
819 820 821 822 823 824
        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.")
825 826 827 828 829 830 831
        super(AdadeltaOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
        self.type = "adadelta"
        self._epsilon = epsilon
        self._rho = rho

    def _create_accumulators(self, block, parameters):
832 833
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
834 835 836 837 838 839

        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):
840 841
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
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

        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 已提交
868 869 870 871 872 873 874 875 876 877
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 已提交
878
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
879 880 881 882

        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 已提交
883
    each weight. Then dividing the gradient by :math:`sqrt{v(w,t)}`.
Q
qingqing01 已提交
884 885 886 887 888 889

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

    ..  math::

Q
qiaolongfei 已提交
890
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
891 892 893 894 895 896

        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 已提交
897
    where, :math:`\\rho` is a hyperparameter and typical values are 0.9, 0.95
Q
qingqing01 已提交
898 899 900 901 902 903
    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:
Q
qiaolongfei 已提交
904
        learning_rate(float): global learning rate.
Q
qingqing01 已提交
905 906 907
        rho(float): rho is :math: `\\rho` in equation, set 0.95 by default.
        epsilon(float): :math: `\\epsilon` in equation is smoothing term to
            avoid division by zero, set 1e-6 by default.
Q
qiaolongfei 已提交
908
        momentum(float): :math:`\\beta` in equation is the momentum term,
Q
qingqing01 已提交
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
            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


Q
qiaolongfei 已提交
985 986 987 988 989 990 991 992 993 994 995 996 997 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 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
class FtrlOptimizer(Optimizer):
    """
    FTRL (Follow The Regularized Leader) Optimizer.

    The paper that proposed Follow The Regularized Leader (FTRL):
    (https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf)

    ..  math::

        &new\_accum = squared\_accum + grad^2

        &if (lr\_power == -0.5):

        &\quad  linear\_accum += grad - \\frac{\\sqrt{new\_accum} - \\sqrt{squared\_accum}}{learning\_rate * param}

        &else:

        &\quad   linear\_accum += grad - \\frac{new\_accum^{-lr\_power} - accum^{-lr\_power}}{learning\_rate * param}


        &x = l1 * sign(linear\_accum) - linear\_accum

        &if (lr\_power == -0.5):

        &\quad   y = \\frac{\\sqrt{new\_accum}}{learning\_rate} + (2 * l2)

        &\quad   pre\_shrink = \\frac{x}{y}

        &\quad   param = (abs(linear\_accum) > l1).select(pre\_shrink, 0.0)

        &else:

        &\quad   y = \\frac{new\_accum^{-lr\_power}}{learning\_rate} + (2 * l2)

        &\quad   pre\_shrink = \\frac{x}{y}

        &\quad   param = (abs(linear\_accum) > l1).select(pre\_shrink, 0.0)

        &squared\_accum += grad^2

    Args:
        learning_rate (float|Variable): global learning rate.
        l1 (float):
        l2 (float):
        lr_power (float):

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

    Examples:
          .. code-block:: python

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

    _squared_acc_str = "squared"
    _linear_acc_str = "linear"

    def __init__(self, learning_rate, l1=0.0, l2=0.0, lr_power=-0.5, **kwargs):
        super(FtrlOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
        if learning_rate is None:
            raise ValueError("learning_rate is not set.")

        self.type = "ftrl"
        self._l1 = l1
        self._l2 = l2
        self._lr_power = lr_power

    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._squared_acc_str, p)
            self._add_accumulator(self._linear_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.")

        squared_acc = self._get_accumulator(self._squared_acc_str,
                                            param_and_grad[0])
        linear_acc = self._get_accumulator(self._linear_acc_str,
                                           param_and_grad[0])
        ftrl_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "SquaredAccumulator": squared_acc,
                "LinearAccumulator": linear_acc,
                "LearningRate": self._create_param_lr(param_and_grad),
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "SquaredAccumOut": squared_acc,
                "LinearAccumOut": linear_acc
            },
            attrs={"l1": self._l1,
                   "l2": self._l1,
                   "lr_power": self._lr_power})

        return ftrl_op


1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
# 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
1106
Adadelta = AdadeltaOptimizer
Q
qingqing01 已提交
1107
RMSProp = RMSPropOptimizer
Q
qiaolongfei 已提交
1108
Ftrl = FtrlOptimizer
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125


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.
        min_average_window: The minimum size of average window.
        max_average_window: The maximum size of average window.

    Examples:
Q
qiaolongfei 已提交
1126 1127 1128

      .. code-block:: python

1129
        optimizer = fluid.optimizer.Momentum()
1130 1131
        optimizer.minimize(cost)
        model_average = fluid.optimizer.ModelAverage(0.15,
1132 1133 1134 1135 1136
                                                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()...)
1137 1138 1139 1140

            with model_average.apply(exe):
                for data in test_reader():
                    exe.run(inference_program...)
1141 1142 1143
    """

    def __init__(self,
W
wanghaoshuang 已提交
1144
                 average_window_rate,
1145 1146 1147 1148 1149 1150 1151
                 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
1152

1153
        self.params_grads = []
1154 1155
        for param in framework.default_main_program().global_block(
        ).all_parameters():
1156
            if param.do_model_average != False:
1157 1158 1159 1160
                grad = param.block.create_var(
                    name=unique_name.generate(".".join([param.name, 'tmp'])),
                    dtype=param.dtype,
                    persistable=False,
W
wanghaoshuang 已提交
1161
                    stop_gradient=True)
1162
                self.params_grads.append((param, grad))
1163

1164
        for param, grad in self.params_grads:
1165 1166 1167
            if grad is None:
                continue
            with param.block.program.optimized_guard([param, grad]):
1168
                self._append_average_accumulate_op(param)
1169

1170 1171 1172 1173
        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:
1174
                self._add_average_apply_op(block, param_grad)
1175 1176 1177 1178 1179

        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:
1180
                self._add_average_restore_op(block, param_grad)
1181

1182
    def _add_average_apply_op(self, block, param_grad):
L
Luo Tao 已提交
1183 1184 1185 1186 1187 1188
        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(
1189
            self._get_accumulator('num_accumulates', param))
L
Luo Tao 已提交
1190
        old_num_accumulates = block._clone_variable(
1191
            self._get_accumulator('old_num_accumulates', param))
L
Luo Tao 已提交
1192
        num_updates = block._clone_variable(
1193 1194 1195 1196 1197 1198
            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 已提交
1199 1200 1201 1202
        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)
1203 1204 1205
        layers.elementwise_div(x=sum, y=tmp, out=param)

    def _add_average_restore_op(self, block, param_grad):
L
Luo Tao 已提交
1206 1207
        param = block._clone_variable(param_grad[0])
        grad = block._clone_variable(param_grad[1])
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
        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,
            })

1247 1248
    @contextmanager
    def apply(self, executor, need_restore=True):
1249 1250
        """Apply average values to parameters of current model.
        """
1251 1252 1253 1254 1255 1256
        executor.run(self.apply_program)
        try:
            yield
        finally:
            if need_restore:
                self.restore(executor)
1257 1258 1259 1260

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