optimizer.py 34.5 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 14
# 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.

15
from collections import defaultdict
16
from paddle.fluid.framework import Program
17
import framework
Q
Qiao Longfei 已提交
18
import layers
F
fengjiayi 已提交
19
from backward import append_backward
Y
Yu Yang 已提交
20 21
from framework import program_guard
import unique_name
22 23 24
from initializer import Constant
from layer_helper import LayerHelper
from regularizer import append_regularization_ops
F
fengjiayi 已提交
25
from clip import append_gradient_clip_ops, error_clip_callback
26
from contextlib import contextmanager
27

28 29
__all__ = [
    'SGD', 'Momentum', 'Adagrad', 'Adam', 'Adamax', 'DecayedAdagrad',
30
    'Adadelta', 'ModelAverage'
31
]
Q
Qiao Longfei 已提交
32 33 34 35 36 37


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

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

Y
Yu Yang 已提交
42
    def __init__(self, learning_rate, regularization=None):
43 44
        if not isinstance(learning_rate, float) and \
                not isinstance(learning_rate, framework.Variable):
Q
qiaolongfei 已提交
45
            raise TypeError("learning rate should be float or Variable")
D
dzhwinter 已提交
46
        self.regularization = regularization
47 48 49
        self._learning_rate = learning_rate
        # each program should have a independent learning rate
        # program -> Variable(learning_rate)
Q
qiaolongfei 已提交
50
        self._learning_rate_map = dict()
51 52 53
        if isinstance(self._learning_rate, framework.Variable):
            self._learning_rate_map[framework.default_main_program(
            )] = self._learning_rate
54 55 56 57 58
        # 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 已提交
59
        self.helper = None
Q
Qiao Longfei 已提交
60

Q
Qiao Longfei 已提交
61
    def _create_global_learning_rate(self):
62
        lr = self.global_learning_rate()
Q
Qiao Longfei 已提交
63

64 65 66 67
        if isinstance(lr, framework.Variable):
            return
        else:
            if not isinstance(self._learning_rate, float):
Q
qiaolongfei 已提交
68
                raise TypeError(
69 70
                    "learning rate variable is create outside optimizer,"
                    "can not create new learning rate variable for new program")
Q
Qiao Longfei 已提交
71

72 73 74 75 76 77 78 79 80 81
        # 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),
            dtype='float32',
            persistable=True)

    def global_learning_rate(self, program=None):
Q
Qiao Longfei 已提交
82 83 84 85
        """
        get global decayed learning rate
        :return:
        """
86 87
        if program is None:
            program = framework.default_main_program()
Q
qiaolongfei 已提交
88
        return self._learning_rate_map.get(program, None)
Q
Qiao Longfei 已提交
89

Q
Qiao Longfei 已提交
90 91 92 93 94
    def _append_optimize_op(self, block, param_and_grad):
        """ append optimize operator to block and return all the added optimize_op
        """
        raise NotImplementedError()

95 96 97 98
    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']
Q
qiaolongfei 已提交
99 100 101 102
        if param_lr == 1.0:
            return self.global_learning_rate()
        else:
            return self.global_learning_rate() * param_lr
103 104 105 106 107 108 109

    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 已提交
110
        """
111 112
        pass

113 114 115 116 117 118 119 120 121 122 123 124 125
    def _finish_update(self, block):
        """Finish any custom updates needed
           before completing an optimization step

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

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

126 127 128 129 130 131
    def _add_accumulator(self,
                         name,
                         param,
                         dtype=None,
                         fill_value=0.0,
                         shape=None):
132 133 134 135 136 137 138 139 140 141 142
        """Utility function to add an accumulator for a parameter

        Args:
            block: the block in which the loss variable is present
            name: name of the accumulator
            param: parameter variable for which accumulator is to be added
            dtype: data type of the accumulator variable
            fill_value: value to initialize the accumulator variable
        """
        if (name in self._accumulators and
                param.name in self._accumulators[name]):
143
            raise Exception("Accumulator {} already exists for parameter {}".
144
                            format(name, param.name))
145 146
        if shape == None:
            shape = param.shape
Q
Qiao Longfei 已提交
147 148
        assert isinstance(self.helper, LayerHelper)
        var = self.helper.create_global_variable(
Y
Yu Yang 已提交
149
            name=unique_name.generate(name),
Q
Qiao Longfei 已提交
150
            persistable=True,
F
fengjiayi 已提交
151
            dtype=dtype or param.dtype,
Q
Qiao Longfei 已提交
152
            type=param.type,
153
            shape=shape)
Q
Qiao Longfei 已提交
154
        self.helper.set_variable_initializer(
155
            var, initializer=Constant(value=float(fill_value)))
Q
Qiao Longfei 已提交
156
        self._accumulators[name][param.name] = var
157
        return var
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174

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

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

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

Q
Qiao Longfei 已提交
175 176 177
    def create_optimization_pass(self,
                                 parameters_and_grads,
                                 loss,
178
                                 startup_program=None):
Q
Qiao Longfei 已提交
179 180 181 182 183 184 185
        """Add optimization operators to update gradients to variables.

        Args:
          loss: the target that this optimization is for.
          parameters_and_grads: a list of (variable, gradient) pair to update.

        Returns:
186 187 188 189
          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 已提交
190
          :param startup_program:
Q
Qiao Longfei 已提交
191
        """
192 193 194 195 196
        # 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
197
        # for parameters and extend _finish_update method to add custom ops.
198 199

        # Create any accumulators
Q
Qiao Longfei 已提交
200
        program = loss.block.program
201
        with program_guard(program, startup_program):
Y
Yancey1989 已提交
202 203
            global_block = framework.default_main_program().global_block()
            start = len(global_block.ops)
204 205 206
            self.helper = LayerHelper(self.__class__.__name__)
            self._create_accumulators(loss.block,
                                      [p[0] for p in parameters_and_grads])
Q
Qiao Longfei 已提交
207
            self._create_global_learning_rate()
208 209 210 211 212 213 214 215 216 217 218

            optimize_ops = []
            for param_and_grad in parameters_and_grads:
                if param_and_grad[0].trainable is True and param_and_grad[
                        1] is not None:
                    optimize_op = self._append_optimize_op(loss.block,
                                                           param_and_grad)
                    optimize_ops.append(optimize_op)

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

Y
Yancey1989 已提交
221 222
            end = len(global_block.ops)
            return global_block.slice_ops(start, end)
Q
Qiao Longfei 已提交
223

Q
Qiao Longfei 已提交
224 225
    def minimize(self,
                 loss,
226
                 startup_program=None,
Q
Qiao Longfei 已提交
227 228
                 parameter_list=None,
                 no_grad_set=None):
Q
Qiao Longfei 已提交
229 230
        """Add operations to minimize `loss` by updating `parameter_list`.

F
fengjiayi 已提交
231
        This method combines interface `append_backward()` and
Q
Qiao Longfei 已提交
232 233
        `create_optimization_pass()` into one.
        """
F
fengjiayi 已提交
234
        params_grads = append_backward(loss, parameter_list, no_grad_set,
Y
Yang Yang 已提交
235
                                       [error_clip_callback])
Y
Yu Yang 已提交
236

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

Y
Yu Yang 已提交
239 240
        params_grads = append_gradient_clip_ops(params_grads)

F
fengjiayi 已提交
241
        # Add regularization if any
D
dzhwinter 已提交
242 243
        params_grads = append_regularization_ops(params_grads,
                                                 self.regularization)
Y
Yu Yang 已提交
244

Q
Qiao Longfei 已提交
245
        optimize_ops = self.create_optimization_pass(params_grads, loss,
246
                                                     startup_program)
T
typhoonzero 已提交
247
        return optimize_ops, params_grads
Q
Qiao Longfei 已提交
248 249 250 251 252 253


class SGDOptimizer(Optimizer):
    """ Simple SGD optimizer without any state.
    """

D
dzhwinter 已提交
254
    def __init__(self, learning_rate, **kwargs):
Q
Qiao Longfei 已提交
255
        assert learning_rate is not None
Q
Qiao Longfei 已提交
256 257
        super(SGDOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
Q
Qiao Longfei 已提交
258 259
        self.type = "sgd"

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

Q
Qiao Longfei 已提交
263 264 265 266 267 268
        # create the optimize op
        sgd_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
269
                "LearningRate": self._create_param_lr(param_and_grad)
Q
Qiao Longfei 已提交
270
            },
271
            outputs={"ParamOut": param_and_grad[0]})
Q
Qiao Longfei 已提交
272 273

        return sgd_op
274 275 276 277 278 279 280


class MomentumOptimizer(Optimizer):
    """Simple Momentum optimizer with velocity state
    """
    _velocity_acc_str = "velocity"

D
dzhwinter 已提交
281
    def __init__(self, learning_rate, momentum, use_nesterov=False, **kwargs):
282 283
        assert learning_rate is not None
        assert momentum is not None
Q
Qiao Longfei 已提交
284 285
        super(MomentumOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
286 287
        self.type = "momentum"
        self._momentum = momentum
288
        self._use_nesterov = bool(use_nesterov)
289 290 291 292 293

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

        for p in parameters:
Q
Qiao Longfei 已提交
294
            self._add_accumulator(self._velocity_acc_str, p)
295 296 297 298 299 300 301 302 303 304 305 306 307

    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,
308
                "LearningRate": self._create_param_lr(param_and_grad)
309 310 311 312 313
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "VelocityOut": velocity_acc
            },
314
            attrs={"mu": self._momentum,
315
                   "use_nesterov": self._use_nesterov})
316 317

        return momentum_op
318 319 320 321 322 323 324


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

D
dzhwinter 已提交
325
    def __init__(self, learning_rate, epsilon=1.0e-6, **kwargs):
326 327
        assert learning_rate is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
328 329
        super(AdagradOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
330 331 332 333 334 335 336
        self.type = "adagrad"
        self._epsilon = epsilon

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

        for p in parameters:
Q
Qiao Longfei 已提交
337
            self._add_accumulator(self._moment_acc_str, p)
338 339 340 341 342 343 344

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

345
        # Create the adagrad optimizer op
346 347 348 349 350 351
        adagrad_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
                "Moment": moment_acc,
352
                "LearningRate": self._create_param_lr(param_and_grad)
353 354 355 356 357 358
            },
            outputs={"ParamOut": param_and_grad[0],
                     "MomentOut": moment_acc},
            attrs={"epsilon": self._epsilon})

        return adagrad_op
359 360 361 362 363 364 365 366 367 368 369 370


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

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
371
                 epsilon=1e-8,
D
dzhwinter 已提交
372
                 **kwargs):
373 374 375 376
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
377 378
        super(AdamOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
379 380 381 382 383 384 385 386
        self.type = "adam"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon

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

Q
Qiao Longfei 已提交
387
        main_block = block.program.global_block()
388 389
        # Create beta1 and beta2 power tensors
        beta_shape = [1]
Q
Qiao Longfei 已提交
390
        self._beta1_pow_acc = self.helper.create_global_variable(
Y
Yu Yang 已提交
391
            name=unique_name.generate('beta1_pow_acc'),
Q
Qiao Longfei 已提交
392 393 394 395 396
            dtype='float32',
            shape=beta_shape,
            lod_level=0,
            persistable=True)
        self.helper.set_variable_initializer(
397
            self._beta1_pow_acc, initializer=Constant(self._beta1))
Q
Qiao Longfei 已提交
398 399

        self._beta2_pow_acc = self.helper.create_global_variable(
Y
Yu Yang 已提交
400
            name=unique_name.generate('beta2_pow_acc'),
Q
Qiao Longfei 已提交
401 402 403 404 405 406
            dtype='float32',
            shape=beta_shape,
            lod_level=0,
            persistable=True)

        self.helper.set_variable_initializer(
407
            self._beta2_pow_acc, initializer=Constant(self._beta2))
408 409 410

        # Create accumulator tensors for first and second moments
        for p in parameters:
Q
Qiao Longfei 已提交
411 412
            self._add_accumulator(self._moment1_acc_str, p)
            self._add_accumulator(self._moment2_acc_str, p)
413 414 415 416 417 418 419 420

    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])
421
        # create the adam optimize op
422 423 424 425 426
        adam_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
427
                "LearningRate": self._create_param_lr(param_and_grad),
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
                "Moment1": moment1,
                "Moment2": moment2,
                "Beta1Pow": self._beta1_pow_acc,
                "Beta2Pow": self._beta2_pow_acc
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "Moment1Out": moment1,
                "Moment2Out": moment2
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adam_op

    def _finish_update(self, block):
        """Update Beta1 and Beta2 Power accumulators
        """
        assert isinstance(block, framework.Block)
Q
Qiao Longfei 已提交
450 451
        main_block = block.program.global_block()
        scale_beta1 = main_block.append_op(
452 453 454 455 456
            type="scale",
            inputs={"X": self._beta1_pow_acc},
            outputs={"Out": self._beta1_pow_acc},
            attrs={"scale": self._beta1})

Q
Qiao Longfei 已提交
457
        scale_beta2 = main_block.append_op(
458 459 460 461 462 463
            type="scale",
            inputs={"X": self._beta2_pow_acc},
            outputs={"Out": self._beta2_pow_acc},
            attrs={"scale": self._beta2})

        return [scale_beta1, scale_beta2]
464 465 466 467 468 469 470 471 472 473 474 475


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

    def __init__(self,
                 learning_rate=0.001,
                 beta1=0.9,
                 beta2=0.999,
476
                 epsilon=1e-8,
D
dzhwinter 已提交
477
                 **kwargs):
478 479 480 481
        assert learning_rate is not None
        assert beta1 is not None
        assert beta2 is not None
        assert epsilon is not None
Q
Qiao Longfei 已提交
482 483
        super(AdamaxOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
484 485 486 487 488 489 490 491
        self.type = "adamax"
        self._beta1 = beta1
        self._beta2 = beta2
        self._epsilon = epsilon

    def _create_accumulators(self, block, parameters):
        # Create beta1 power accumulator tensor
        beta_shape = [1]
Q
Qiao Longfei 已提交
492
        self._beta1_pow_acc = self.helper.create_global_variable(
Y
Yu Yang 已提交
493
            name=unique_name.generate('beta1_pow_acc'),
Q
Qiao Longfei 已提交
494 495 496 497 498
            dtype='float32',
            shape=beta_shape,
            lod_level=0,
            persistable=True)
        self.helper.set_variable_initializer(
499
            self._beta1_pow_acc, initializer=Constant(self._beta1))
500 501 502

        # Create accumulator tensors for first moment and infinity norm
        for p in parameters:
Q
Qiao Longfei 已提交
503 504
            self._add_accumulator(self._moment_acc_str, p)
            self._add_accumulator(self._inf_norm_acc_str, p)
505 506 507 508 509 510 511 512 513 514 515 516 517

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

        moment = self._get_accumulator(self._moment_acc_str, param_and_grad[0])
        inf_norm = self._get_accumulator(self._inf_norm_acc_str,
                                         param_and_grad[0])
        # create the adamax optimize op
        adamax_op = block.append_op(
            type=self.type,
            inputs={
                "Param": param_and_grad[0],
                "Grad": param_and_grad[1],
518
                "LearningRate": self._create_param_lr(param_and_grad),
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
                "Moment": moment,
                "InfNorm": inf_norm,
                "Beta1Pow": self._beta1_pow_acc
            },
            outputs={
                "ParamOut": param_and_grad[0],
                "MomentOut": moment,
                "InfNormOut": inf_norm
            },
            attrs={
                "beta1": self._beta1,
                "beta2": self._beta2,
                "epsilon": self._epsilon
            })

        return adamax_op

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

        return [scale_beta1]
548 549 550 551 552 553 554


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

D
dzhwinter 已提交
555
    def __init__(self, learning_rate, decay=0.95, epsilon=1.0e-6, **kwargs):
556 557 558 559
        assert learning_rate is not None
        assert decay is not None
        assert epsilon is not None

Q
Qiao Longfei 已提交
560 561
        super(DecayedAdagradOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
        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
592 593


594
class AdadeltaOptimizer(Optimizer):
595 596 597
    """
    **Adadelta Optimizer**
    Simple Adadelta optimizer with average squared grad state and
598
    average squared update state.
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
    The details of adadelta please refer to this
    `ADADELTA: AN ADAPTIVE LEARNING RATE METHOD
    <http://www.matthewzeiler.com/pubs/googleTR2012/googleTR2012.pdf>`_.

    ..  math::

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

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

    Examples:
        .. code-block:: python

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

623 624 625 626
    _avg_squared_grad_acc_str = "_avg_squared_grad"
    _avg_squared_update_acc_str = "_avg_squared_update"

    def __init__(self, learning_rate, epsilon=1.0e-6, rho=0.95, **kwargs):
627 628 629 630 631 632
        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.")
633 634 635 636 637 638 639
        super(AdadeltaOptimizer, self).__init__(
            learning_rate=learning_rate, **kwargs)
        self.type = "adadelta"
        self._epsilon = epsilon
        self._rho = rho

    def _create_accumulators(self, block, parameters):
640 641
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
642 643 644 645 646 647

        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):
648 649
        if not isinstance(block, framework.Block):
            raise TypeError("block is not instance of framework.Block.")
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675

        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 已提交
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 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
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::

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

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

    The first equation calculates moving average of the squared gradient for
    each weight. Then dividing the gradient by :math: `sqrt{v(w,t)}`.

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

    ..  math::

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

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

        w & = w - v(w, t)

    where, :math: `\\rho` is a hyperparameter and typical values are 0.9, 0.95
    and so on. :math: `beta` is the momentum term. :math: `\\epsilon` is a
    smoothing term to avoid division by zero, usually set somewhere in range
    from 1e-4 to 1e-8.


    Args:
        learning_rate(float): global leraning rate.
        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.
        momentum(float): :math: `\\beta` in equation is the momentum term,
            set 0.0 by default.

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

    Examples:
          .. code-block:: python

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

    _momentum_acc_str = "momentum"
    _mean_square_acc_str = "mean_square"

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

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

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

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

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

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

        return rmsprop_op


793 794 795 796 797 798 799 800 801 802 803 804 805 806
# 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
807
Adadelta = AdadeltaOptimizer
Q
qingqing01 已提交
808
RMSProp = RMSPropOptimizer
809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835


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:
        params_grads: A list of parameter-grad variable pairs.
        average_window_rate: The rate of average window.
        min_average_window: The minimum size of average window.
        max_average_window: The maximum size of average window.

    Examples:
        ...
        optimizer = fluid.optimizer.Momentum()
        _, params_grads = optimizer.minimize(cost)
        model_average = fluid.optimizer.ModelAverage(params_grads, 0.15,
                                                min_average_window=10000,
                                                max_average_window=20000)
        for pass_id in range(args.pass_num):
            for data in train_reader():
                exe.run(fluid.default_main_program()...)
836 837 838 839

            with model_average.apply(exe):
                for data in test_reader():
                    exe.run(inference_program...)
840 841 842 843 844 845 846 847 848 849 850 851 852
    """

    def __init__(self,
                 params_grads,
                 average_window_rate,
                 min_average_window=10000,
                 max_average_window=10000,
                 **kwargs):
        super(ModelAverage, self).__init__(0.0, **kwargs)
        self.average_window = average_window_rate
        self.min_average_window = min_average_window
        self.max_average_window = max_average_window
        self.params_grads = params_grads
853 854 855
        for param, grad in self.params_grads:
            if grad is not None:
                self._append_average_accumulate_op(param)
856

857 858 859 860
        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:
861 862
                if param_grad[1] is not None:
                    self._add_average_apply_op(block, param_grad)
863 864 865 866 867

        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:
868 869
                if param_grad[1] is not None:
                    self._add_average_restore_op(block, param_grad)
870

871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
    def _add_average_apply_op(self, block, param_grad):
        param = block.clone_variable(param_grad[0])
        grad = block.clone_variable(param_grad[1])
        sum_1 = block.clone_variable(self._get_accumulator('sum_1', param))
        sum_2 = block.clone_variable(self._get_accumulator('sum_2', param))
        sum_3 = block.clone_variable(self._get_accumulator('sum_3', param))
        num_accumulates = block.clone_variable(
            self._get_accumulator('num_accumulates', param))
        old_num_accumulates = block.clone_variable(
            self._get_accumulator('old_num_accumulates', param))
        num_updates = block.clone_variable(
            self._get_accumulator('num_updates', param))
        # backup param value to grad
        layers.assign(input=param, output=grad)
        # param = (sum_1 + sum_2 + sum_3) / (num_accumulates + old_num_accumulates)
        tmp = layers.sum(x=[num_accumulates, old_num_accumulates])
        sum = layers.sum(x=[sum_1, sum_2, sum_3])
        tmp = layers.cast(x=tmp, dtype='float32')
        sum = layers.cast(x=sum, dtype='float32')
        layers.elementwise_div(x=sum, y=tmp, out=param)

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

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

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

934 935
    @contextmanager
    def apply(self, executor, need_restore=True):
936 937
        """Apply average values to parameters of current model.
        """
938 939 940 941 942 943
        executor.run(self.apply_program)
        try:
            yield
        finally:
            if need_restore:
                self.restore(executor)
944 945 946 947

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