optimizer.py 54.9 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.
14 15

from __future__ import print_function
16

17
from collections import defaultdict
18 19
from contextlib import contextmanager

20
from paddle.fluid.framework import Program, Variable, name_scope, default_main_program
Q
Qiao Longfei 已提交
21
from paddle.fluid.transpiler.details.distribute_lookuptable_utils import find_distributed_lookup_table
22

23 24
from . import framework
from . import layers
25
from . import unique_name
26
from .backward import append_backward
27
from .clip import append_gradient_clip_ops, error_clip_callback
28 29 30
from .framework import program_guard
from .initializer import Constant
from .layer_helper import LayerHelper
S
sneaxiy 已提交
31
from .layers import ops
32
from .regularizer import append_regularization_ops
33

34
__all__ = [
Q
qiaolongfei 已提交
35
    'SGD', 'Momentum', 'Adagrad', 'Adam', 'Adamax', 'DecayedAdagrad', 'Ftrl',
36
    'SGDOptimizer', 'MomentumOptimizer', 'AdagradOptimizer', 'AdamOptimizer',
W
weixing02 已提交
37
    'AdamaxOptimizer', 'DecayedAdagradOptimizer', 'RMSPropOptimizer',
38 39
    'FtrlOptimizer', 'Adadelta', 'ModelAverage', 'LarsMomentum',
    'LarsMomentumOptimizer'
40
]
Q
Qiao Longfei 已提交
41 42 43 44 45 46


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

    Define the common interface of an optimizer.
47 48
    User should not use this class directly,
    but need to use one of it's implementation.
Q
Qiao Longfei 已提交
49 50
    """

X
Xin Pan 已提交
51
    def __init__(self, learning_rate, regularization=None, name=None):
52 53
        if not isinstance(learning_rate, float) and \
                not isinstance(learning_rate, framework.Variable):
Q
qiaolongfei 已提交
54
            raise TypeError("learning rate should be float or Variable")
W
whs 已提交
55
        self._name = name
D
dzhwinter 已提交
56
        self.regularization = regularization
57
        self._learning_rate = learning_rate
D
dzhwinter 已提交
58 59
        # the learning rate type should be inferenced from loss
        self._dtype = None
60 61
        # each program should have a independent learning rate
        # program -> Variable(learning_rate)
Q
qiaolongfei 已提交
62
        self._learning_rate_map = dict()
63 64 65
        if isinstance(self._learning_rate, framework.Variable):
            self._learning_rate_map[framework.default_main_program(
            )] = self._learning_rate
66 67 68 69 70
        # 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 已提交
71
        self.helper = None
Q
Qiao Longfei 已提交
72

Q
Qiao Longfei 已提交
73
    def _create_global_learning_rate(self):
Y
yuyang18 已提交
74
        lr = self._global_learning_rate()
Q
Qiao Longfei 已提交
75

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

84 85 86 87 88 89
        # 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),
Q
Qiao Longfei 已提交
90
            dtype='float32' if self._dtype is None else self._dtype,
91 92
            persistable=True)

Y
yuyang18 已提交
93
    def _global_learning_rate(self, program=None):
Q
Qiao Longfei 已提交
94 95 96 97
        """
        get global decayed learning rate
        :return:
        """
98 99
        if program is None:
            program = framework.default_main_program()
Q
qiaolongfei 已提交
100
        return self._learning_rate_map.get(program, None)
Q
Qiao Longfei 已提交
101

Q
Qiao Longfei 已提交
102 103 104 105 106
    def _append_optimize_op(self, block, param_and_grad):
        """ append optimize operator to block and return all the added optimize_op
        """
        raise NotImplementedError()

107 108 109 110
    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 已提交
111 112
        if type(param_lr) == Variable:
            return param_lr
Q
qiaolongfei 已提交
113
        else:
W
Wu Yi 已提交
114
            if param_lr == 1.0:
Y
yuyang18 已提交
115
                return self._global_learning_rate()
W
Wu Yi 已提交
116
            else:
X
Xin Pan 已提交
117 118 119
                with default_main_program()._lr_schedule_guard(
                        is_with_opt=True), framework.name_scope(
                            'scale_with_param_lr'):
120
                    return self._global_learning_rate() * param_lr
121 122 123 124 125 126 127

    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 已提交
128
        """
129 130
        pass

131
    def _finish_update(self, block, parameters_and_grads):
132 133 134 135 136 137 138 139
        """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 已提交
140
            None
141 142 143
        """
        pass

144 145 146 147 148 149
    def _add_accumulator(self,
                         name,
                         param,
                         dtype=None,
                         fill_value=0.0,
                         shape=None):
150 151 152 153 154 155 156 157 158
        """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
        """
W
whs 已提交
159 160
        if self._name is not None:
            name = self._name + "_" + name
161 162
        if (name in self._accumulators and
                param.name in self._accumulators[name]):
163
            raise Exception("Accumulator {} already exists for parameter {}".
164
                            format(name, param.name))
165 166
        if shape == None:
            shape = param.shape
Q
Qiao Longfei 已提交
167 168
        assert isinstance(self.helper, LayerHelper)
        var = self.helper.create_global_variable(
Y
Yu Yang 已提交
169
            name=unique_name.generate(name),
Q
Qiao Longfei 已提交
170
            persistable=True,
F
fengjiayi 已提交
171
            dtype=dtype or param.dtype,
Q
Qiao Longfei 已提交
172
            type=param.type,
173
            shape=shape)
Q
Qiao Longfei 已提交
174
        self.helper.set_variable_initializer(
175
            var, initializer=Constant(value=float(fill_value)))
Q
Qiao Longfei 已提交
176
        self._accumulators[name][param.name] = var
177
        return var
178 179 180 181 182 183 184 185 186 187 188

    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
        """
W
whs 已提交
189 190
        if self._name is not None:
            name = self._name + "_" + name
191 192 193 194 195 196
        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 已提交
197 198 199 200
    def _create_optimization_pass(self,
                                  parameters_and_grads,
                                  loss,
                                  startup_program=None):
Q
Qiao Longfei 已提交
201 202 203
        """Add optimization operators to update gradients to variables.

        Args:
Q
qiaolongfei 已提交
204 205 206
          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 已提交
207 208

        Returns:
209 210 211 212
          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 已提交
213
        """
214 215 216 217 218
        # 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
219
        # for parameters and extend _finish_update method to add custom ops.
220 221

        # Create any accumulators
Q
Qiao Longfei 已提交
222
        program = loss.block.program
D
dzhwinter 已提交
223
        self._dtype = loss.dtype
224
        with program_guard(program, startup_program):
Y
Yancey1989 已提交
225 226
            global_block = framework.default_main_program().global_block()
            start = len(global_block.ops)
227 228 229
            self.helper = LayerHelper(self.__class__.__name__)
            self._create_accumulators(loss.block,
                                      [p[0] for p in parameters_and_grads])
Q
Qiao Longfei 已提交
230
            self._create_global_learning_rate()
231 232 233

            optimize_ops = []
            for param_and_grad in parameters_and_grads:
234 235
                if param_and_grad[1] is None:
                    continue
W
Wu Yi 已提交
236
                with param_and_grad[0].block.program._optimized_guard(
237
                        param_and_grad), name_scope("optimizer"):
238
                    if param_and_grad[0].trainable is True:
Y
yuyang18 已提交
239 240 241
                        optimize_op = self._append_optimize_op(loss.block,
                                                               param_and_grad)
                        optimize_ops.append(optimize_op)
242 243 244

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

Y
Yancey1989 已提交
247
            end = len(global_block.ops)
W
Wu Yi 已提交
248
            return global_block._slice_ops(start, end)
Q
Qiao Longfei 已提交
249

Q
Qiao Longfei 已提交
250 251
    def _process_distribute_lookuptable(self, param_grads, loss,
                                        startup_program):
Q
Qiao Longfei 已提交
252 253 254 255 256 257 258 259 260
        """
        Because distribute lookup table only support SGD optimizer for now, not support
        other optimizer and regularization, so we should find the table parameter out,
        and avoid to add regularization and other op for it, and add sgd optimize op
        for it independently.
        :param param_grads(list((Var, Var))): list of (param, grad) pair.
        :param loss: the loss variable.
        :param startup_program: the startup program
        """
Q
Qiao Longfei 已提交
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
        program = loss.block.program
        table_name = find_distributed_lookup_table(program)
        table_param = None
        table_grad = None
        new_param_grads = []
        for p, g in param_grads:
            if p.name == table_name:
                if table_param is not None:
                    raise RuntimeError(
                        "multi dist table var found, only support one now!")
                table_param = p
                table_grad = g
            else:
                new_param_grads.append((p, g))
        sgd_op = None
        if table_param is not None:
            with program_guard(program, startup_program):
                param_and_grad = [table_param, table_grad]
                with table_param.block.program._optimized_guard(param_and_grad), \
                     framework.name_scope("optimizer"):
Q
Qiao Longfei 已提交
281
                    self._create_global_learning_rate()
Q
Qiao Longfei 已提交
282 283 284 285 286 287 288 289 290 291 292 293
                    # create the optimize op
                    sgd_op = loss.block.append_op(
                        type='sgd',
                        inputs={
                            "Param": table_param,
                            "Grad": table_grad,
                            "LearningRate":
                            self._create_param_lr(param_and_grad)
                        },
                        outputs={"ParamOut": param_and_grad[0]})
        return new_param_grads, (table_param, table_grad), sgd_op

Q
Qiao Longfei 已提交
294 295
    def minimize(self,
                 loss,
296
                 startup_program=None,
Q
Qiao Longfei 已提交
297 298
                 parameter_list=None,
                 no_grad_set=None):
Q
Qiao Longfei 已提交
299 300
        """Add operations to minimize `loss` by updating `parameter_list`.

F
fengjiayi 已提交
301
        This method combines interface `append_backward()` and
Q
Qiao Longfei 已提交
302 303
        `create_optimization_pass()` into one.
        """
Q
Qiao Longfei 已提交
304 305
        params_grads = append_backward(loss, parameter_list, no_grad_set,
                                       [error_clip_callback])
Q
Qiao Longfei 已提交
306

Q
Qiao Longfei 已提交
307
        params_grads = sorted(params_grads, key=lambda x: x[0].name)
Y
Yu Yang 已提交
308

Q
Qiao Longfei 已提交
309 310
        params_grads, table_param_and_grad, table_optimize_op = \
            self._process_distribute_lookuptable(params_grads, loss, startup_program)
Y
Yu Yang 已提交
311

Q
Qiao Longfei 已提交
312
        params_grads = append_gradient_clip_ops(params_grads)
313

Q
Qiao Longfei 已提交
314 315 316
        # Add regularization if any
        params_grads = append_regularization_ops(params_grads,
                                                 self.regularization)
Y
Yu Yang 已提交
317

Q
Qiao Longfei 已提交
318 319 320 321 322 323
        optimize_ops = self._create_optimization_pass(params_grads, loss,
                                                      startup_program)
        if table_optimize_op is not None:
            optimize_ops.append(table_optimize_op)
            params_grads.append(table_param_and_grad)
        return optimize_ops, params_grads
Q
Qiao Longfei 已提交
324 325 326


class SGDOptimizer(Optimizer):
Q
qiaolongfei 已提交
327 328 329 330 331 332 333 334 335 336
    """
    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.
X
Xin Pan 已提交
337 338 339
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
340 341 342 343

    Examples:
        .. code-block:: python

Q
qiaolongfei 已提交
344
            sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.2)
Q
qiaolongfei 已提交
345
            sgd_optimizer.minimize(cost)
Q
Qiao Longfei 已提交
346 347
    """

X
Xin Pan 已提交
348
    def __init__(self, learning_rate, regularization=None, name=None):
Q
Qiao Longfei 已提交
349
        assert learning_rate is not None
Q
Qiao Longfei 已提交
350
        super(SGDOptimizer, self).__init__(
X
Xin Pan 已提交
351 352 353
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
Q
Qiao Longfei 已提交
354 355
        self.type = "sgd"

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

Q
Qiao Longfei 已提交
359 360 361 362 363 364
        # create the optimize op
        sgd_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
365
                "LearningRate": self._create_param_lr(param_and_grad)
Q
Qiao Longfei 已提交
366
            },
367
            outputs={"ParamOut": param_and_grad[0]})
Q
Qiao Longfei 已提交
368 369

        return sgd_op
370 371 372


class MomentumOptimizer(Optimizer):
Q
qiaolongfei 已提交
373 374 375 376 377 378 379 380 381 382 383 384 385 386
    """

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

387
        &\quad   param = param - (gradient + mu * velocity) * learning\_rate
Q
qiaolongfei 已提交
388 389 390

        & else:

Q
qiaolongfei 已提交
391
        &\quad   param = param - learning\_rate * velocity
Q
qiaolongfei 已提交
392 393 394 395 396 397

    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
X
Xin Pan 已提交
398 399 400
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
401 402 403 404

    Examples:
        .. code-block:: python

Q
qiaolongfei 已提交
405
            optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
Q
qiaolongfei 已提交
406
            optimizer.minimize(cost)
407 408 409
    """
    _velocity_acc_str = "velocity"

X
Xin Pan 已提交
410 411 412 413 414 415
    def __init__(self,
                 learning_rate,
                 momentum,
                 use_nesterov=False,
                 regularization=None,
                 name=None):
416 417
        assert learning_rate is not None
        assert momentum is not None
Q
Qiao Longfei 已提交
418
        super(MomentumOptimizer, self).__init__(
X
Xin Pan 已提交
419 420 421
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
422 423
        self.type = "momentum"
        self._momentum = momentum
424
        self._use_nesterov = bool(use_nesterov)
425 426 427 428 429

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

        for p in parameters:
Q
Qiao Longfei 已提交
430
            self._add_accumulator(self._velocity_acc_str, p)
431 432 433 434 435 436 437 438 439 440 441 442 443

    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,
444
                "LearningRate": self._create_param_lr(param_and_grad)
445 446 447 448 449
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "VelocityOut": velocity_acc
            },
450
            attrs={"mu": self._momentum,
451
                   "use_nesterov": self._use_nesterov})
452 453

        return momentum_op
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 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
class LarsMomentumOptimizer(Optimizer):
    """
    Momentum optimizer with LARS support

    The update equations are as follows:

    .. math::

        & local\_learning\_rate = learning\_rate * lars\_coeff * \\
          \\frac{||param||}{||gradient|| + lars\_weight\_decay * ||param||}

        & velocity = mu * velocity + local\_learning\_rate * (gradient + lars\_weight\_decay * param)

        & param = param - velocity

    Args:
        learning_rate (float|Variable): the learning rate used to update parameters. \
        Can be a float value or a Variable with one float value as data element.
        momentum (float): momentum factor
        lars_coeff (float): defines how much we trust the layer to change its weights.
        lars_weight_decay (float): weight decay coefficient for decaying using LARS.
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
        

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
            optimizer.minimize(cost)
    """
    _velocity_acc_str = "velocity"

    def __init__(self,
                 learning_rate,
                 momentum,
                 lars_coeff=0.001,
                 lars_weight_decay=0.0005,
                 regularization=None,
                 name=None):
        assert learning_rate is not None
        assert momentum is not None
        super(LarsMomentumOptimizer, self).__init__(
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
        self.type = "lars_momentum"
        self._momentum = momentum
        self._lars_coeff = float(lars_coeff)
        self._lars_weight_decay = float(lars_weight_decay)

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

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

    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,
                "LearningRate": self._create_param_lr(param_and_grad)
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "VelocityOut": velocity_acc
            },
            attrs={
                "mu": self._momentum,
                "lars_coeff": self._lars_coeff,
                "lars_weight_decay": self._lars_weight_decay
            })

        return momentum_op


541
class AdagradOptimizer(Optimizer):
Q
qiaolongfei 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
    """
    **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.
X
Xin Pan 已提交
562 563 564
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
565 566 567 568 569 570

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
            optimizer.minimize(cost)
571 572 573
    """
    _moment_acc_str = "moment"

X
Xin Pan 已提交
574 575 576 577 578
    def __init__(self,
                 learning_rate,
                 epsilon=1.0e-6,
                 regularization=None,
                 name=None):
579 580
        assert learning_rate is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
581
        super(AdagradOptimizer, self).__init__(
X
Xin Pan 已提交
582 583 584
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
585 586 587 588 589 590 591
        self.type = "adagrad"
        self._epsilon = epsilon

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

        for p in parameters:
Q
Qiao Longfei 已提交
592
            self._add_accumulator(self._moment_acc_str, p)
593 594 595 596 597 598 599

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

600
        # Create the adagrad optimizer op
601 602 603 604 605 606
        adagrad_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "Moment": moment_acc,
607
                "LearningRate": self._create_param_lr(param_and_grad)
608 609 610 611 612 613
            },
            outputs={"ParamOut": param_and_grad[0],
                     "MomentOut": moment_acc},
            attrs={"epsilon": self._epsilon})

        return adagrad_op
614 615 616


class AdamOptimizer(Optimizer):
Q
qiaolongfei 已提交
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
    """
    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.
X
Xin Pan 已提交
644 645 646
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
647 648 649 650 651 652 653

    Examples:
        .. code-block:: python

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

654 655 656
    """
    _moment1_acc_str = "moment1"
    _moment2_acc_str = "moment2"
Q
qiaolongfei 已提交
657 658
    _beta1_pow_acc_str = "beta1_pow_acc"
    _beta2_pow_acc_str = "beta2_pow_acc"
659 660 661 662 663

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
664
                 epsilon=1e-8,
X
Xin Pan 已提交
665 666
                 regularization=None,
                 name=None):
667 668 669 670
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
671
        super(AdamOptimizer, self).__init__(
X
Xin Pan 已提交
672 673 674
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
675 676 677 678 679 680 681 682 683 684
        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 已提交
685 686
            self._add_accumulator(self._moment1_acc_str, p)
            self._add_accumulator(self._moment2_acc_str, p)
Q
qiaolongfei 已提交
687 688 689 690 691 692 693 694 695 696 697 698
            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])
699 700 701 702 703 704 705 706

    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 已提交
707 708 709 710 711
        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])

712
        # create the adam optimize op
713 714 715 716 717
        adam_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
718
                "LearningRate": self._create_param_lr(param_and_grad),
719 720
                "Moment1": moment1,
                "Moment2": moment2,
Q
qiaolongfei 已提交
721 722
                "Beta1Pow": beta1_pow_acc,
                "Beta2Pow": beta2_pow_acc
723 724 725 726 727 728 729 730 731 732 733 734 735 736
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "Moment1Out": moment1,
                "Moment2Out": moment2
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adam_op

737
    def _finish_update(self, block, param_and_grads):
738 739 740
        """Update Beta1 and Beta2 Power accumulators
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
741
        main_block = block.program.global_block()
742 743 744
        for param, grad in param_and_grads:
            if grad is None:
                continue
X
Xin Pan 已提交
745 746
            with param.block.program._optimized_guard(
                [param, grad]), name_scope("optimizer"):
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
                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})
762 763 764


class AdamaxOptimizer(Optimizer):
Q
qiaolongfei 已提交
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
    """
    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.
X
Xin Pan 已提交
795 796 797
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
798 799 800 801 802 803

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adamax(learning_rate=0.2)
            optimizer.minimize(cost)
C
chengduo 已提交
804 805 806

    Notes:
       Currently, AdamaxOptimizer doesn't support sparse parameter optimization.
807 808 809
    """
    _moment_acc_str = "moment"
    _inf_norm_acc_str = "inf_norm"
Q
qiaolongfei 已提交
810
    _beta1_pow_acc_str = "beta1_pow_acc"
811 812 813 814 815

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
816
                 epsilon=1e-8,
X
Xin Pan 已提交
817 818
                 regularization=None,
                 name=None):
819 820 821 822
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
823
        super(AdamaxOptimizer, self).__init__(
X
Xin Pan 已提交
824 825 826
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
827 828 829 830 831 832 833 834
        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 已提交
835 836
            self._add_accumulator(self._moment_acc_str, p)
            self._add_accumulator(self._inf_norm_acc_str, p)
Q
qiaolongfei 已提交
837 838 839 840 841 842
            self._add_accumulator(
                name=self._beta1_pow_acc_str,
                param=p,
                dtype='float32',
                fill_value=self._beta1,
                shape=[1])
843 844 845 846 847 848 849

    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 已提交
850 851
        beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
                                              param_and_grad[0])
852 853 854 855 856 857
        # create the adamax optimize op
        adamax_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
858
                "LearningRate": self._create_param_lr(param_and_grad),
859 860
                "Moment": moment,
                "InfNorm": inf_norm,
Q
qiaolongfei 已提交
861
                "Beta1Pow": beta1_pow_acc
862 863 864 865 866 867 868 869 870 871 872 873 874 875
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "MomentOut": moment,
                "InfNormOut": inf_norm
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adamax_op

876
    def _finish_update(self, block, parameters_and_grads):
877 878 879
        """Update Beta1 Power accumulator
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
880
        main_block = block.program.global_block()
881 882 883
        for param, grad in parameters_and_grads:
            if grad is None:
                continue
X
Xin Pan 已提交
884 885
            with param.block.program._optimized_guard(
                [param, grad]), name_scope('adamx'):
886 887 888 889 890 891 892
                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})
893 894 895


class DecayedAdagradOptimizer(Optimizer):
896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
    """
    **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.
X
Xin Pan 已提交
918 919 920
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
921 922 923 924 925 926

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
            optimizer.minimize(cost)
C
chengduo 已提交
927 928 929

    Notes:
       Currently, DecayedAdagradOptimizer doesn't support sparse parameter optimization.
930 931 932
    """
    _moment_acc_str = "moment"

X
Xin Pan 已提交
933 934 935 936 937 938
    def __init__(self,
                 learning_rate,
                 decay=0.95,
                 epsilon=1.0e-6,
                 regularization=None,
                 name=None):
939 940 941 942
        assert learning_rate is not None
        assert decay is not None
        assert epsilon is not None

Q
Qiao Longfei 已提交
943
        super(DecayedAdagradOptimizer, self).__init__(
X
Xin Pan 已提交
944 945 946
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
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
        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
977 978


979
class AdadeltaOptimizer(Optimizer):
980 981
    """
    **Adadelta Optimizer**
Q
qiaolongfei 已提交
982

983
    Simple Adadelta optimizer with average squared grad state and
984
    average squared update state.
985 986 987 988 989 990 991 992 993 994 995 996
    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 已提交
997
        learning_rate(float): global learning rate
998 999
        rho(float): rho in equation
        epsilon(float): epsilon in equation
X
Xin Pan 已提交
1000 1001 1002
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
1003 1004 1005 1006 1007 1008 1009

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adadelta(
                learning_rate=0.0003, epsilon=1.0e-6, rho=0.95)
            _, params_grads = optimizer.minimize(cost)
C
chengduo 已提交
1010 1011 1012

    Notes:
       Currently, AdadeltaOptimizer doesn't support sparse parameter optimization.
1013
    """
1014

1015 1016 1017
    _avg_squared_grad_acc_str = "_avg_squared_grad"
    _avg_squared_update_acc_str = "_avg_squared_update"

X
Xin Pan 已提交
1018 1019 1020 1021 1022 1023
    def __init__(self,
                 learning_rate,
                 epsilon=1.0e-6,
                 rho=0.95,
                 regularization=None,
                 name=None):
1024 1025 1026 1027 1028 1029
        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.")
1030
        super(AdadeltaOptimizer, self).__init__(
X
Xin Pan 已提交
1031 1032 1033
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
1034 1035 1036 1037 1038
        self.type = "adadelta"
        self._epsilon = epsilon
        self._rho = rho

    def _create_accumulators(self, block, parameters):
1039 1040
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
1041 1042 1043 1044 1045 1046

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

        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 已提交
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
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 已提交
1085
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
1086 1087 1088 1089

        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 已提交
1090
    each weight. Then dividing the gradient by :math:`sqrt{v(w,t)}`.
Q
qingqing01 已提交
1091 1092 1093 1094 1095 1096

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

    ..  math::

Q
qiaolongfei 已提交
1097
        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
Q
qingqing01 已提交
1098

1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
        v(w, t) & = \\beta v(w, t-1) + \\frac{\\eta} {\\sqrt{r(w,t) +
            \\epsilon}} \\nabla Q_{i}(w)

        w & = w - v(w, t)

    if centered is True:

    ..  math::

        r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2

        g(w, t) & = \\rho g(w, t-1) + (1 - \\rho)\\nabla Q_{i}(w)

        v(w, t) & = \\beta v(w, t-1) + \\frac{\\eta} {\\sqrt{r(w,t) - (g(w, t))^2 +
Q
qingqing01 已提交
1113 1114 1115 1116
            \\epsilon}} \\nabla Q_{i}(w)

        w & = w - v(w, t)

Q
qiaolongfei 已提交
1117
    where, :math:`\\rho` is a hyperparameter and typical values are 0.9, 0.95
Q
qingqing01 已提交
1118 1119 1120 1121 1122 1123
    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 已提交
1124
        learning_rate(float): global learning rate.
Q
qingqing01 已提交
1125 1126 1127
        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 已提交
1128
        momentum(float): :math:`\\beta` in equation is the momentum term,
Q
qingqing01 已提交
1129
            set 0.0 by default.
1130 1131 1132 1133
        centered(bool): If True, gradients are normalized by the estimated variance of
            the gradient; if False, by the uncentered second moment. Setting this to
            True may help with training, but is slightly more expensive in terms of
            computation and memory. Defaults to False.
X
Xin Pan 已提交
1134 1135 1136
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qingqing01 已提交
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149

    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"
1150
    _mean_grad_acc_str = "mean_grad"
Q
qingqing01 已提交
1151 1152 1153 1154 1155 1156

    def __init__(self,
                 learning_rate,
                 rho=0.95,
                 epsilon=1.0e-6,
                 momentum=0.0,
1157
                 centered=False,
X
Xin Pan 已提交
1158 1159
                 regularization=None,
                 name=None):
Q
qingqing01 已提交
1160
        super(RMSPropOptimizer, self).__init__(
X
Xin Pan 已提交
1161 1162 1163
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
Q
qingqing01 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
        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
1177
        self._centered = centered
Q
qingqing01 已提交
1178 1179 1180 1181 1182 1183 1184 1185

    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)
1186
            self._add_accumulator(self._mean_grad_acc_str, p)
Q
qingqing01 已提交
1187 1188 1189 1190 1191 1192 1193 1194 1195

    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])
1196 1197
        mean_grad_acc = self._get_accumulator(self._mean_grad_acc_str,
                                              param_and_grad[0])
Q
qingqing01 已提交
1198 1199 1200 1201 1202 1203 1204
        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,
1205
                "MeanGrad": mean_grad_acc,
Q
qingqing01 已提交
1206 1207 1208 1209 1210
                "LearningRate": self._create_param_lr(param_and_grad),
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "MomentOut": momentum_acc,
1211 1212
                "MeanSquareOut": mean_square_acc,
                "MeanGradOut": mean_grad_acc
Q
qingqing01 已提交
1213 1214 1215 1216
            },
            attrs={
                "epsilon": self._epsilon,
                "decay": self._rho,
1217 1218
                "momentum": self._momentum,
                "centered": self._centered
Q
qingqing01 已提交
1219 1220 1221 1222 1223
            })

        return rmsprop_op


Q
qiaolongfei 已提交
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
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):
X
Xin Pan 已提交
1269 1270 1271
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
1272 1273 1274 1275 1276 1277 1278 1279 1280

    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)
C
chengduo 已提交
1281 1282 1283

    Notes:
       Currently, FtrlOptimizer doesn't support sparse parameter optimization.
Q
qiaolongfei 已提交
1284 1285 1286 1287 1288
    """

    _squared_acc_str = "squared"
    _linear_acc_str = "linear"

X
Xin Pan 已提交
1289 1290 1291 1292 1293 1294 1295
    def __init__(self,
                 learning_rate,
                 l1=0.0,
                 l2=0.0,
                 lr_power=-0.5,
                 regularization=None,
                 name=None):
Q
qiaolongfei 已提交
1296
        super(FtrlOptimizer, self).__init__(
X
Xin Pan 已提交
1297 1298 1299
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
Q
qiaolongfei 已提交
1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
        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


1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
# 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
1359
Adadelta = AdadeltaOptimizer
Q
qingqing01 已提交
1360
RMSProp = RMSPropOptimizer
Q
qiaolongfei 已提交
1361
Ftrl = FtrlOptimizer
1362
LarsMomentum = LarsMomentumOptimizer
1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377


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.
X
Xin Pan 已提交
1378 1379 1380
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
1381
    Examples:
Q
qiaolongfei 已提交
1382 1383 1384

      .. code-block:: python

1385
        optimizer = fluid.optimizer.Momentum()
1386 1387
        optimizer.minimize(cost)
        model_average = fluid.optimizer.ModelAverage(0.15,
1388 1389 1390 1391 1392
                                                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()...)
1393 1394 1395 1396

            with model_average.apply(exe):
                for data in test_reader():
                    exe.run(inference_program...)
1397 1398 1399
    """

    def __init__(self,
W
wanghaoshuang 已提交
1400
                 average_window_rate,
1401 1402
                 min_average_window=10000,
                 max_average_window=10000,
X
Xin Pan 已提交
1403 1404 1405 1406
                 regularization=None,
                 name=None):
        super(ModelAverage, self).__init__(
            0.0, regularization=regularization, name=name)
1407 1408 1409
        self.average_window = average_window_rate
        self.min_average_window = min_average_window
        self.max_average_window = max_average_window
1410

1411
        self.params_grads = []
1412 1413
        for param in framework.default_main_program().global_block(
        ).all_parameters():
1414
            if param.do_model_average != False:
1415 1416 1417 1418
                grad = param.block.create_var(
                    name=unique_name.generate(".".join([param.name, 'tmp'])),
                    dtype=param.dtype,
                    persistable=False,
W
wanghaoshuang 已提交
1419
                    stop_gradient=True)
1420
                self.params_grads.append((param, grad))
1421

1422
        for param, grad in self.params_grads:
1423 1424
            if grad is None:
                continue
X
Xin Pan 已提交
1425 1426
            with param.block.program._optimized_guard(
                [param, grad]), name_scope('move_average'):
1427
                self._append_average_accumulate_op(param)
1428

1429 1430 1431 1432
        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:
1433
                self._add_average_apply_op(block, param_grad)
1434 1435 1436 1437 1438

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

1441
    def _add_average_apply_op(self, block, param_grad):
L
Luo Tao 已提交
1442 1443 1444 1445 1446 1447
        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(
1448
            self._get_accumulator('num_accumulates', param))
L
Luo Tao 已提交
1449
        old_num_accumulates = block._clone_variable(
1450
            self._get_accumulator('old_num_accumulates', param))
L
Luo Tao 已提交
1451
        num_updates = block._clone_variable(
1452 1453 1454 1455 1456 1457
            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 已提交
1458 1459 1460 1461
        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)
S
sneaxiy 已提交
1462
        ops._elementwise_div(x=sum, y=tmp, out=param)
1463 1464

    def _add_average_restore_op(self, block, param_grad):
L
Luo Tao 已提交
1465 1466
        param = block._clone_variable(param_grad[0])
        grad = block._clone_variable(param_grad[1])
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
        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,
            })

1506 1507
    @contextmanager
    def apply(self, executor, need_restore=True):
1508 1509
        """Apply average values to parameters of current model.
        """
1510 1511 1512 1513 1514 1515
        executor.run(self.apply_program)
        try:
            yield
        finally:
            if need_restore:
                self.restore(executor)
1516 1517 1518 1519

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