optimizer.py 45.1 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
__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 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
            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

Q
qiaolongfei 已提交
126
    def _finish_update(self, block, parameters):
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:
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
Q
qiaolongfei 已提交
239 240
            self._finish_update(loss.block,
                                [p[0] for p in parameters_and_grads])
241

Y
Yancey1989 已提交
242 243
            end = len(global_block.ops)
            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):

Q
qiaolongfei 已提交
327
        &\quad   param = param - gradient * learning\_rate + 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

Q
qiaolongfei 已提交
567
    def _finish_update(self, block, parameters):
568 569 570
        """Update Beta1 and Beta2 Power accumulators
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
571
        main_block = block.program.global_block()
Q
qiaolongfei 已提交
572
        for param in parameters:
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
            with param.block.program.optimized_guard(param):
                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})
589 590 591


class AdamaxOptimizer(Optimizer):
Q
qiaolongfei 已提交
592 593 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
    """
    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)
628 629 630
    """
    _moment_acc_str = "moment"
    _inf_norm_acc_str = "inf_norm"
Q
qiaolongfei 已提交
631
    _beta1_pow_acc_str = "beta1_pow_acc"
632 633 634 635 636

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
637
                 epsilon=1e-8,
D
dzhwinter 已提交
638
                 **kwargs):
639 640 641 642
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
643 644
        super(AdamaxOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
645 646 647 648 649 650 651 652
        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 已提交
653 654
            self._add_accumulator(self._moment_acc_str, p)
            self._add_accumulator(self._inf_norm_acc_str, p)
Q
qiaolongfei 已提交
655 656 657 658 659 660
            self._add_accumulator(
                name=self._beta1_pow_acc_str,
                param=p,
                dtype='float32',
                fill_value=self._beta1,
                shape=[1])
661 662 663 664 665 666 667

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

        return adamax_op

Q
qiaolongfei 已提交
694
    def _finish_update(self, block, parameters):
695 696 697
        """Update Beta1 Power accumulator
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
698
        main_block = block.program.global_block()
Q
qiaolongfei 已提交
699
        for param in parameters:
700 701 702 703 704 705 706 707
            with param.block.program.optimized_guard(param):
                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})
708 709 710


class DecayedAdagradOptimizer(Optimizer):
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738
    """
    **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)
739 740 741
    """
    _moment_acc_str = "moment"

D
dzhwinter 已提交
742
    def __init__(self, learning_rate, decay=0.95, epsilon=1.0e-6, **kwargs):
743 744 745 746
        assert learning_rate is not None
        assert decay is not None
        assert epsilon is not None

Q
Qiao Longfei 已提交
747 748
        super(DecayedAdagradOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
749 750 751 752 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
        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
779 780


781
class AdadeltaOptimizer(Optimizer):
782 783
    """
    **Adadelta Optimizer**
Q
qiaolongfei 已提交
784

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

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

    def _create_accumulators(self, block, parameters):
828 829
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
830 831 832 833 834 835

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

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

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

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

    ..  math::

Q
qiaolongfei 已提交
886
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
887 888 889 890 891 892

        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 已提交
893
    where, :math:`\\rho` is a hyperparameter and typical values are 0.9, 0.95
Q
qingqing01 已提交
894 895 896 897 898 899
    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 已提交
900
        learning_rate(float): global learning rate.
Q
qingqing01 已提交
901 902 903
        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 已提交
904
        momentum(float): :math:`\\beta` in equation is the momentum term,
Q
qingqing01 已提交
905 906 907 908 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
            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 已提交
981 982 983 984 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
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


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


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 已提交
1122 1123 1124

      .. code-block:: python

1125
        optimizer = fluid.optimizer.Momentum()
1126 1127
        optimizer.minimize(cost)
        model_average = fluid.optimizer.ModelAverage(0.15,
1128 1129 1130 1131 1132
                                                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()...)
1133 1134 1135 1136

            with model_average.apply(exe):
                for data in test_reader():
                    exe.run(inference_program...)
1137 1138 1139
    """

    def __init__(self,
W
wanghaoshuang 已提交
1140
                 average_window_rate,
1141 1142 1143 1144 1145 1146 1147
                 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
1148

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

1160
        for param, grad in self.params_grads:
1161 1162
            with param.block.program.optimized_guard(param):
                self._append_average_accumulate_op(param)
1163

1164 1165 1166 1167
        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:
1168
                self._add_average_apply_op(block, param_grad)
1169 1170 1171 1172 1173

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

1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
    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 已提交
1193 1194 1195 1196
        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)
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 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
        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,
            })

1241 1242
    @contextmanager
    def apply(self, executor, need_restore=True):
1243 1244
        """Apply average values to parameters of current model.
        """
1245 1246 1247 1248 1249 1250
        executor.run(self.apply_program)
        try:
            yield
        finally:
            if need_restore:
                self.restore(executor)
1251 1252 1253 1254

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