optimizer.py 55.0 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.distribute_lookup_table 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
                 regularization=None,
Q
Qiao Longfei 已提交
666 667
                 name=None,
                 sparse_mode=False):
668 669 670 671
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
672
        super(AdamOptimizer, self).__init__(
X
Xin Pan 已提交
673 674 675
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
676 677 678 679
        self.type = "adam"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon
Q
Qiao Longfei 已提交
680
        self._sparse_mode = sparse_mode
681 682 683 684 685 686

    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 已提交
687 688
            self._add_accumulator(self._moment1_acc_str, p)
            self._add_accumulator(self._moment2_acc_str, p)
Q
qiaolongfei 已提交
689 690 691 692 693 694 695 696 697 698 699 700
            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])
701 702 703 704 705 706 707 708

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

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

        return adam_op

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


class AdamaxOptimizer(Optimizer):
Q
qiaolongfei 已提交
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 795 796 797
    """
    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 已提交
798 799 800
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
801 802 803 804 805 806

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.Adamax(learning_rate=0.2)
            optimizer.minimize(cost)
C
chengduo 已提交
807 808 809

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

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

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

        return adamax_op

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


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

    Examples:
        .. code-block:: python

            optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
            optimizer.minimize(cost)
C
chengduo 已提交
930 931 932

    Notes:
       Currently, DecayedAdagradOptimizer doesn't support sparse parameter optimization.
933 934 935
    """
    _moment_acc_str = "moment"

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

Q
Qiao Longfei 已提交
946
        super(DecayedAdagradOptimizer, self).__init__(
X
Xin Pan 已提交
947 948 949
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
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
        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
980 981


982
class AdadeltaOptimizer(Optimizer):
983 984
    """
    **Adadelta Optimizer**
Q
qiaolongfei 已提交
985

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

    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 已提交
1013 1014 1015

    Notes:
       Currently, AdadeltaOptimizer doesn't support sparse parameter optimization.
1016
    """
1017

1018 1019 1020
    _avg_squared_grad_acc_str = "_avg_squared_grad"
    _avg_squared_update_acc_str = "_avg_squared_update"

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

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

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

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

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

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

    ..  math::

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

1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
        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 已提交
1116 1117 1118 1119
            \\epsilon}} \\nabla Q_{i}(w)

        w & = w - v(w, t)

Q
qiaolongfei 已提交
1120
    where, :math:`\\rho` is a hyperparameter and typical values are 0.9, 0.95
Q
qingqing01 已提交
1121 1122 1123 1124 1125 1126
    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 已提交
1127
        learning_rate(float): global learning rate.
Q
qingqing01 已提交
1128 1129 1130
        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 已提交
1131
        momentum(float): :math:`\\beta` in equation is the momentum term,
Q
qingqing01 已提交
1132
            set 0.0 by default.
1133 1134 1135 1136
        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 已提交
1137 1138 1139
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qingqing01 已提交
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152

    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"
1153
    _mean_grad_acc_str = "mean_grad"
Q
qingqing01 已提交
1154 1155 1156 1157 1158 1159

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

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

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

        return rmsprop_op


Q
qiaolongfei 已提交
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 1269 1270 1271
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 已提交
1272 1273 1274
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
Q
qiaolongfei 已提交
1275 1276 1277 1278 1279 1280 1281 1282 1283

    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 已提交
1284 1285 1286

    Notes:
       Currently, FtrlOptimizer doesn't support sparse parameter optimization.
Q
qiaolongfei 已提交
1287 1288 1289 1290 1291
    """

    _squared_acc_str = "squared"
    _linear_acc_str = "linear"

X
Xin Pan 已提交
1292 1293 1294 1295 1296 1297 1298
    def __init__(self,
                 learning_rate,
                 l1=0.0,
                 l2=0.0,
                 lr_power=-0.5,
                 regularization=None,
                 name=None):
Q
qiaolongfei 已提交
1299
        super(FtrlOptimizer, self).__init__(
X
Xin Pan 已提交
1300 1301 1302
            learning_rate=learning_rate,
            regularization=regularization,
            name=name)
Q
qiaolongfei 已提交
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 1345 1346 1347
        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


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


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 已提交
1381 1382 1383
        regularization: A Regularizer, such as
                        fluid.regularizer.L2DecayRegularizer.
        name: A optional name prefix.
1384
    Examples:
Q
qiaolongfei 已提交
1385 1386 1387

      .. code-block:: python

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

            with model_average.apply(exe):
                for data in test_reader():
                    exe.run(inference_program...)
1400 1401 1402
    """

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

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

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

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

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

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

    def _add_average_restore_op(self, block, param_grad):
L
Luo Tao 已提交
1468 1469
        param = block._clone_variable(param_grad[0])
        grad = block._clone_variable(param_grad[1])
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 1506 1507 1508
        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,
            })

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

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