fluid.optimizer

Adadelta

paddle.fluid.optimizer.Adadelta

AdadeltaOptimizer 的别名

Adagrad

paddle.fluid.optimizer.Adagrad

AdagradOptimizer 的别名

AdagradOptimizer

class paddle.fluid.optimizer.AdagradOptimizer(learning_rate, epsilon=1e-06, regularization=None, name=None, initial_accumulator_value=0.0)[源代码]

Adaptive Gradient Algorithm(Adagrad)

更新如下:

\[\begin{split}moment\_out &= moment + grad * grad\\param\_out &= param - \frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}\end{split}\]

原始论文(http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf)没有epsilon属性。在我们的实现中也作了如下更新: http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性,避免除数为0的错误发生。

参数:
  • learning_rate (float|Variable)-学习率,用于更新参数。作为数据参数,可以是一个浮点类型值或者有一个浮点类型值的变量
  • epsilon (float) - 维持数值稳定性的短浮点型值
  • regularization - 规则化函数,例如fluid.regularizer.L2DecayRegularizer
  • name - 名称前缀(可选)
  • initial_accumulator_value (float) - moment累加器的初始值。

代码示例

import paddle.fluid as fluid
import numpy as np

np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
inp = fluid.layers.data(
    name="inp", shape=[2, 2], append_batch_size=False)
out = fluid.layers.fc(inp, size=3)
out = fluid.layers.reduce_sum(out)
optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
optimizer.minimize(out)

exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
exe.run(
    feed={"inp": np_inp},
    fetch_list=[out.name])
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

Adam

paddle.fluid.optimizer.Adam

AdamOptimizer 的别名

Adamax

paddle.fluid.optimizer.Adamax

AdamaxOptimizer 的别名

AdamaxOptimizer

class paddle.fluid.optimizer.AdamaxOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None)[源代码]

我们参考Adam论文第7节中的Adamax优化: https://arxiv.org/abs/1412.6980 , Adamax是基于无穷大范数的Adam算法的一个变种。

Adamax 更新规则:

\[\begin{split}\\t = t + 1\end{split}\]
\[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}\]
\[\begin{split}param\_out = param - learning\_rate * \frac{moment\_1}{\sqrt{moment\_2} + \epsilon}\\\end{split}\]

论文中没有 epsilon 参数。但是,为了数值稳定性, 防止除0错误, 增加了这个参数

代码示例

import paddle.fluid as fluid
import numpy

# First create the Executor.
place = fluid.CPUPlace() # fluid.CUDAPlace(0)
exe = fluid.Executor(place)

train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
    data = fluid.layers.data(name='X', shape=[1], dtype='float32')
    hidden = fluid.layers.fc(input=data, size=10)
    loss = fluid.layers.mean(hidden)
    adam = fluid.optimizer.Adamax(learning_rate=0.2)
    adam.minimize(loss)

# Run the startup program once and only once.
exe.run(startup_program)

x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(program=train_program,
              feed={'X': x},
               fetch_list=[loss.name])
参数:
  • learning_rate (float|Variable) - 用于更新参数的学习率。可以是浮点值,也可以是具有一个浮点值作为数据元素的变量。
  • beta1 (float) - 第1阶段估计的指数衰减率
  • beta2 (float) - 第2阶段估计的指数衰减率。
  • epsilon (float) -非常小的浮点值,为了数值的稳定性质
  • regularization - 正则化器,例如 fluid.regularizer.L2DecayRegularizer
  • name - 可选的名称前缀。

注解

目前 AdamaxOptimizer 不支持 sparse parameter optimization.

apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

AdamOptimizer

class paddle.fluid.optimizer.AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None, lazy_mode=False)[源代码]

该函数实现了自适应矩估计优化器,介绍自 Adam论文 的第二节。Adam是一阶基于梯度下降的算法,基于自适应低阶矩估计。 Adam更新如下:

\[\begin{split}\\t = t + 1\end{split}\]
\[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=\frac{learning\_rate}{1-\beta_1^t}\]
\[\begin{split}param\_out=param−learning\_rate*\frac{moment\_out}{inf\_norm\_out}\\\end{split}\]
参数:
  • learning_rate (float|Variable)-学习率,用于更新参数。作为数据参数,可以是一个浮点类型值或有一个浮点类型值的变量
  • beta1 (float)-一阶矩估计的指数衰减率
  • beta2 (float)-二阶矩估计的指数衰减率
  • epsilon (float)-保持数值稳定性的短浮点类型值
  • regularization - 规则化函数,例如''fluid.regularizer.L2DecayRegularizer
  • name - 可选名称前缀
  • lazy_mode (bool: false) - 官方Adam算法有两个移动平均累加器(moving-average accumulators)。累加器在每一步都会更新。在密集模式和稀疏模式下,两条移动平均线的每个元素都会更新。如果参数非常大,那么更新可能很慢。 lazy mode仅更新当前具有梯度的元素,所以它会更快。但是这种模式与原始的算法有不同的描述,可能会导致不同的结果。

代码示例

import paddle
import paddle.fluid as fluid

place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
    x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    y_predict = fluid.layers.fc(input=x, size=1, act=None)
    cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    avg_cost = fluid.layers.mean(cost)
    adam_optimizer = fluid.optimizer.AdamOptimizer(0.01)
    adam_optimizer.minimize(avg_cost)

    fetch_list = [avg_cost]
    train_reader = paddle.batch(
        paddle.dataset.uci_housing.train(), batch_size=1)
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe = fluid.Executor(place)
    exe.run(fluid.default_startup_program())
    for data in train_reader():
        exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

DecayedAdagrad

paddle.fluid.optimizer.DecayedAdagrad

DecayedAdagradOptimizer 的别名

DecayedAdagradOptimizer

class paddle.fluid.optimizer.DecayedAdagradOptimizer(learning_rate, decay=0.95, epsilon=1e-06, regularization=None, name=None)[源代码]

Decayed Adagrad Optimizer

原始论文

原始论文: http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf 中没有 epsilon 参数。但是,为了数值稳定性, 防止除0错误, 增加了这个参数

\[moment\_out = decay*moment+(1-decay)*grad*grad\]
\[param\_out = param-\frac{learning\_rate*grad}{\sqrt{moment\_out}+\epsilon }\]
参数:
  • learning_rate (float|Variable) - 用于更新参数的学习率。可以是浮点值,也可以是具有一个浮点值作为数据元素的变量。
  • decay (float) – 衰减率
  • regularization - 一个正则化器,例如 fluid.regularizer.L2DecayRegularizer
  • epsilon (float) - 非常小的浮点值,为了数值稳定性
  • name — 可选的名称前缀。

代码示例

import paddle.fluid as fluid
import paddle.fluid.layers as layers
from paddle.fluid.optimizer import DecayedAdagrad

x = layers.data( name='x', shape=[-1, 10], dtype='float32' )
trans = layers.fc( x, 100 )
cost = layers.reduce_mean( trans )
optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
optimizer.minimize(cost)

注解

当前, DecayedAdagradOptimizer 不支持 sparse parameter optimization

apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

DGCMomentumOptimizer

class paddle.fluid.optimizer.DGCMomentumOptimizer(learning_rate, momentum, rampup_begin_step, rampup_step=1, sparsity=[0.999], use_nesterov=False, local_grad_clip_norm=None, num_trainers=None, regularization=None, name=None)[源代码]

原始论文: https://arxiv.org/abs/1712.01887

DGC通过仅发送重要梯度(稀疏更新)来减少通信带宽:仅发送大于给定阈值的梯度。

为避免丢失信息,DGC在本地累积其余梯度。最终,这些梯度会积累到足够大,从而可以传输。

因此,DGC即时发送相对较大的梯度,但最终随时间积累而发送所有梯度。

此外,为了确保不损失精度,DGC在梯度稀疏化之上采用动量修正和局部梯度修剪(clip)来维持模型性能。

DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来克服由于reduced通讯而导致的数据陈旧性(staleness)问题。

这个优化器会执行如下操作:

  1. 通过从张量获取前TopK个导入值来压缩梯度,并将其用于allreduce以减少网络带宽。
  2. 调用momentum来降低cost。
参数:
  • learning_rate (float | Variable) - 用于更新参数的学习率。可以是浮点值或由一个浮点型数据组成的Variable。
  • momentum (float) - 动量因子。
  • rampup_begin_step (int) - 进行梯度压缩的起步点。
  • rampup_step (int) - 使用稀疏期的时间。默认值为1.例如:如果稀疏度为[0.75,0.9375,0.984375,0.996,0.999],并且rampup_step为5,则在0步时使用0.75,在1步时使用0.9375,依此类推。当达到sparsity数组末尾时,它此后延续使用0.999。
  • sparsity (list [float]) - 从梯度张量中获取较为重要的元素,比率为(1-当前稀疏度)。
  • use_nesterov (bool) - 启用Nesterov momentum。 True意味着使用nesterov。
  • local_grad_clip_norm (float) - 如果需要,clip norm值。
  • num_trainers - 训练节点的数量。
  • regularization - 正则器,如fluid.regularizer.L2DecayRegularizer。
  • name - 可选的名称前缀。

代码示例

import paddle.fluid as fluid
optimizer = fluid.optimizer.DGCMomentumOptimizer(
                                    learning_rate=0.0001,
                                    momentum=0.9,
                                    rampup_step=1000,
                                    rampup_begin_step=1252,
                                    sparsity=[0.999, 0.999])
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

ExponentialMovingAverage

class paddle.fluid.optimizer.ExponentialMovingAverage(decay=0.999, thres_steps=None, name=None)[源代码]

用指数衰减计算参数的移动平均值。 给出参数 \(\theta\) ,它的指数移动平均值(exponential moving average, EMA) 为

\[\begin{split}\begin{align}\begin{aligned}\text{EMA}_0 & = 0\\\text{EMA}_t & = \text{decay} * \text{EMA}_{t-1} + (1 - \text{decay}) * \theta_t\end{aligned}\end{align}\end{split}\]

update() 方法计算出的平均结果将保存在由对象创建和维护的临时变量中,并且可以通过调用 apply() 方法把结果应用于当前模型的参数。另外,restore() 方法用于恢复参数。

偏差教正。 所有的EMAs均初始化为 \(0\) ,因此它们将为零偏差,可以通过除以因子 \((1 - \text{decay}^t)\) 来校正,即在调用 apply() 方法时应用于参数的真实EMAs将为:

\[\widehat{\text{EMA}}_t = \frac{\text{EMA}_t}{1 - \text{decay}^t}\]

衰减率调度。 一个非常接近于1的很大的衰减率将会导致平均值移动得很慢。更优的策略是,一开始就设置一个相对较小的衰减率。参数thres_steps允许用户传递一个变量以设置衰减率,在这种情况下, 真实的衰减率变为 :

\[\min(\text{decay}, \frac{1 + \text{thres_steps}}{10 + \text{thres_steps}})\]

通常thres_steps可以是全局训练steps。

参数:
  • decay (float) – 指数衰减率,通常接近1,如0.999,0.9999,……
  • thres_steps (Variable|None) – 如果不为None,指定衰减率。
  • name (str|None) – 名字前缀(可选项)。

代码示例

import numpy
import paddle
import paddle.fluid as fluid

data = fluid.layers.data(name='x', shape=[5], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
cost = fluid.layers.mean(hidden)

test_program = fluid.default_main_program().clone(for_test=True)

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

global_steps = fluid.layers.learning_rate_scheduler._decay_step_counter()
ema = fluid.optimizer.ExponentialMovingAverage(0.999, thres_steps=global_steps)
ema.update()

place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())

for pass_id in range(3):
    for batch_id in range(6):
        data = numpy.random.random(size=(10, 5)).astype('float32')
        exe.run(program=fluid.default_main_program(),
            feed={'x': data},
            fetch_list=[cost.name])

    # usage 1
    with ema.apply(exe):
        data = numpy.random.random(size=(10, 5)).astype('float32')
        exe.run(program=test_program,
                feed={'x': data},
                fetch_list=[hidden.name])

     # usage 2
    with ema.apply(exe, need_restore=False):
        data = numpy.random.random(size=(10, 5)).astype('float32')
        exe.run(program=test_program,
                feed={'x': data},
                fetch_list=[hidden.name])
    ema.restore(exe)
update()

更新指数滑动平均。仅在训练程序中调用此方法。

apply(executor, need_restore=True)
参数:
  • executor (Executor) – 执行应用的执行引擎。
  • need_restore (bool) –是否在应用后恢复参数。
restore(executor)
参数:
  • executor (Executor) – 执行存储的执行引擎。

Ftrl

paddle.fluid.optimizer.Ftrl

FtrlOptimizer 的别名

FtrlOptimizer

class paddle.fluid.optimizer.FtrlOptimizer(learning_rate, l1=0.0, l2=0.0, lr_power=-0.5, regularization=None, name=None)[源代码]

FTRL (Follow The Regularized Leader) Optimizer.

FTRL 原始论文: ( https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf)

\[\begin{split}&\qquad new\_accum=squared\_accum+grad^2\\\\ &\qquad if(lr\_power==−0.5):\\ &\qquad \qquad linear\_accum+=grad-\frac{\sqrt{new\_accum}-\sqrt{squared\_accum}}{learning\_rate*param}\\ &\qquad else:\\ &\qquad \qquad linear\_accum+=grad-\frac{new\_accum^{-lr\_power}-accum^{-lr\_power}}{learning\_rate*param}\\\\ &\qquad x=l1*sign(linear\_accum)−linear\_accum\\\\ &\qquad if(lr\_power==−0.5):\\ &\qquad \qquad y=\frac{\sqrt{new\_accum}}{learning\_rate}+(2*l2)\\ &\qquad \qquad pre\_shrink=\frac{x}{y}\\ &\qquad \qquad param=(abs(linear\_accum)>l1).select(pre\_shrink,0.0)\\ &\qquad else:\\ &\qquad \qquad y=\frac{new\_accum^{-lr\_power}}{learning\_rate}+(2*l2)\\ &\qquad \qquad pre\_shrink=\frac{x}{y}\\ &\qquad \qquad param=(abs(linear\_accum)>l1).select(pre\_shrink,0.0)\\\\ &\qquad squared\_accum+=grad^2\end{split}\]
参数:
  • learning_rate (float|Variable)-全局学习率。
  • l1 (float) - L1 regularization strength.
  • l2 (float) - L2 regularization strength.
  • lr_power (float) - 学习率降低指数
  • regularization - 正则化器,例如 fluid.regularizer.L2DecayRegularizer
  • name — 可选的名称前缀
抛出异常:
  • ValueError - 如果 learning_rate , rho , epsilon , momentum 为 None.

代码示例

import paddle
import paddle.fluid as fluid
import numpy as np

place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
    x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    y_predict = fluid.layers.fc(input=x, size=1, act=None)
    cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    avg_cost = fluid.layers.mean(cost)

    ftrl_optimizer = fluid.optimizer.Ftrl(learning_rate=0.1)
    ftrl_optimizer.minimize(avg_cost)

    fetch_list = [avg_cost]
    train_reader = paddle.batch(
        paddle.dataset.uci_housing.train(), batch_size=1)
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe = fluid.Executor(place)
    exe.run(fluid.default_startup_program())
    for data in train_reader():
        exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)

注解

目前, FtrlOptimizer 不支持 sparse parameter optimization

apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

LambOptimizer

class paddle.fluid.optimizer.LambOptimizer(learning_rate=0.001, lamb_weight_decay=0.01, beta1=0.9, beta2=0.999, epsilon=1e-06, regularization=None, exclude_from_weight_decay_fn=None, name=None)[源代码]

LAMB(Layer-wise Adaptive Moments optimizer for Batching training)优化器 LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小,支持自适应元素更新和精确的分层校正。 更多信息请参考 Large Batch Optimization for Deep Learning: Training BERT in 76 minutes 。 参数更新如下:

\[\begin{split}\begin{align}\begin{aligned}m_t &= \beta_1 m_{t - 1}+ (1 - \beta_1)g_t \\\v_t &= \beta_2 v_{t - 1} + (1 - \beta_2)g_t^2 \\\r_t &= \frac{m_t}{\sqrt{v_t}+\epsilon} \\\w_t &= w_{t-1} -\eta_t \frac{\left \| w_{t-1}\right \|}{\left \| r_t + \lambda w_{t-1}\right \|} (r_t + \lambda w_{t-1})\end{aligned}\end{align}\end{split}\]

其中 \(m\) 为第一个时刻,\(v\) 为第二个时刻,\(\eta\) 为学习率,\(\lambda\) 为LAMB权重衰减率。

参数:
  • learning_rate (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。
  • lamb_weight_decay (float) – LAMB权重衰减率。
  • beta1 (float) – 第一个时刻估计的指数衰减率。
  • beta2 (float) – 第二个时刻估计的指数衰减率。
  • epsilon (float) – 一个小的浮点值,目的是维持数值稳定性。
  • regularization (Regularizer) – 一个正则化器,如fluid.regularizer.L1DecayRegularizer。
  • exclude_from_weight_decay_fn (function) – 当返回值为True时从权重衰减中去除某个参数。
  • name (str|None) – 名字前缀(可选项)。

代码示例

import paddle.fluid as fluid

data = fluid.layers.data(name='x', shape=[5], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
cost = fluid.layers.mean(hidden)

def exclude_fn(param):
    return param.name.endswith('.b_0')

optimizer = fluid.optimizer.Lamb(learning_rate=0.002,
                                 exclude_from_weight_decay_fn=exclude_fn)
optimizer.minimize(cost)
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

LarsMomentum

paddle.fluid.optimizer.LarsMomentum

fluid.optimizer.LarsMomentumOptimizer 的别名

LarsMomentumOptimizer

class paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)[源代码]

LARS支持的Momentum优化器

公式作如下更新:

\[\begin{split}& 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\end{split}\]
参数:
  • learning_rate (float|Variable) - 学习率,用于参数更新。作为数据参数,可以是浮点型值或含有一个浮点型值的变量
  • momentum (float) - 动量因子
  • lars_coeff (float) - 定义LARS本地学习率的权重
  • lars_weight_decay (float) - 使用LARS进行衰减的权重衰减系数
  • regularization - 正则化函数,例如 fluid.regularizer.L2DecayRegularizer
  • name - 名称前缀,可选

代码示例:

import paddle.fluid as fluid
optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
optimizer.minimize(cost)
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

ModelAverage

class paddle.fluid.optimizer.ModelAverage(average_window_rate, min_average_window=10000, max_average_window=10000, regularization=None, name=None)[源代码]

在滑动窗口中累积参数的平均值。平均结果将保存在临时变量中,通过调用 apply() 方法可应用于当前模型的参数变量。使用 restore() 方法恢复当前模型的参数值。

平均窗口的大小由 average_window_ratemin_average_windowmax_average_window 以及当前更新次数决定。

参数:
  • average_window_rate – 窗口平均速率
  • min_average_window – 平均窗口大小的最小值
  • max_average_window – 平均窗口大小的最大值
  • regularization – 正则化器,例如 fluid.regularizer.L2DecayRegularizer
  • name – 可选的名称前缀

代码示例

import paddle.fluid as fluid
import numpy

# 首先创建执行引擎
place = fluid.CPUPlace()  # fluid.CUDAPlace(0)
exe = fluid.Executor(place)

train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
    # 构建net
    data = fluid.layers.data(name='X', shape=[1], dtype='float32')
    hidden = fluid.layers.fc(input=data, size=10)
    loss = fluid.layers.mean(hidden)
    optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
    optimizer.minimize(loss)

    # 构建ModelAverage优化器
    model_average = fluid.optimizer.ModelAverage(0.15,
                                      min_average_window=10000,
                                      max_average_window=20000)
    exe.run(startup_program)
    x = numpy.random.random(size=(10, 1)).astype('float32')
    outs = exe.run(program=train_program,
                   feed={'X': x},
                   fetch_list=[loss.name])
   # 应用ModelAverage
    with model_average.apply(exe):
         x = numpy.random.random(size=(10, 1)).astype('float32')
         exe.run(program=train_program,
                feed={'X': x},
                fetch_list=[loss.name])
apply(executor, need_restore=True)

将平均值应用于当前模型的参数。

参数:
  • executor (fluid.Executor) – 当前的执行引擎。
  • need_restore (bool) – 如果您最后需要实现恢复,将其设为True。默认值True。
restore(executor)

恢复当前模型的参数值

参数:
  • executor (fluid.Executor) – 当前的执行引擎。
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

Momentum

paddle.fluid.optimizer.Momentum

MomentumOptimizer 的别名

MomentumOptimizer

class paddle.fluid.optimizer.MomentumOptimizer(learning_rate, momentum, use_nesterov=False, regularization=None, name=None)[源代码]

含有速度状态的Simple Momentum 优化器

该优化器含有牛顿动量标志,公式更新如下:

\[\begin{split}& velocity = mu * velocity + gradient\\ & if (use\_nesterov):\\ &\quad param = param - (gradient + mu * velocity) * learning\_rate\\ & else:\\&\quad param = param - learning\_rate * velocity\end{split}\]
参数:
  • learning_rate (float|Variable) - 学习率,用于参数更新。作为数据参数,可以是浮点型值或含有一个浮点型值的变量
  • momentum (float) - 动量因子
  • use_nesterov (bool) - 赋能牛顿动量
  • regularization - 正则化函数,比如fluid.regularizer.L2DecayRegularizer
  • name - 名称前缀(可选)

代码示例

import paddle
import paddle.fluid as fluid
import numpy as np

place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
    x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    y_predict = fluid.layers.fc(input=x, size=1, act=None)
    cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    avg_cost = fluid.layers.mean(cost)

    moment_optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.001, momentum=0.9)
    moment_optimizer.minimize(avg_cost)

    fetch_list = [avg_cost]
    train_reader = paddle.batch(
        paddle.dataset.uci_housing.train(), batch_size=1)
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe = fluid.Executor(place)
    exe.run(fluid.default_startup_program())
    for data in train_reader():
        exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

PipelineOptimizer

class paddle.fluid.optimizer.PipelineOptimizer(optimizer, cut_list=None, place_list=None, concurrency_list=None, queue_size=30, sync_steps=1, start_cpu_core_id=0)[源代码]

使用流水线模式进行训练。 Program会根据切分列表cut_list进行分割。如果cut_list的长度是k,则整个program(包括反向部分)将被分割为2*k-1个section。 所以place_list和concurrency_list的长度也必须是2*k-1。

注解

虽然我们在流水线训练模式中采用异步更新的方式来加速,但最终的效果会依赖于每条流水线的训练进程。我们将在未来尝试同步模式。

参数:
  • optimizer (Optimizer) - 基础优化器,如SGD
  • cut_list (list of Variable list) - main_program的cut变量列表
  • place_list (list of Place) - 对应section运行所在的place
  • concurrency_list (list of int) - 指定每个section的并发度列表
  • queue_size (int) - 每个section都会消费其输入队列(in-scope queue)中的scope,并向输出队列(out-scope queue)产出scope。 此参数的作用就是指定队列的大小。 可选,默认值:30
  • sync_steps (int) - 不同显卡之间的同步周期数。可选,默认值:1
  • start_cpu_core_id (int) - 指定所使用的第一个CPU核的id。可选,默认值:0

代码示例

import paddle.fluid as fluid
import paddle.fluid.layers as layers
x = fluid.layers.data(name='x', shape=[1], dtype='int64', lod_level=0)
y = fluid.layers.data(name='y', shape=[1], dtype='int64', lod_level=0)
emb_x = layers.embedding(input=x, param_attr=fluid.ParamAttr(name="embx"), size=[10,2], is_sparse=False)
emb_y = layers.embedding(input=y, param_attr=fluid.ParamAttr(name="emby",learning_rate=0.9), size=[10,2], is_sparse=False)
concat = layers.concat([emb_x, emb_y], axis=1)
fc = layers.fc(input=concat, name="fc", size=1, num_flatten_dims=1, bias_attr=False)
loss = layers.reduce_mean(fc)
optimizer = fluid.optimizer.SGD(learning_rate=0.5)
optimizer = fluid.optimizer.PipelineOptimizer(optimizer,
        cut_list=[[emb_x, emb_y], [loss]],
        place_list=[fluid.CPUPlace(), fluid.CUDAPlace(0), fluid.CPUPlace()],
        concurrency_list=[1, 1, 4],
        queue_size=2,
        sync_steps=1,
        )
optimizer.minimize(loss)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
filelist = [] # you should set your own filelist, e.g. filelist = ["dataA.txt"]
dataset = fluid.DatasetFactory().create_dataset("FileInstantDataset")
dataset.set_use_var([x,y])
dataset.set_batch_size(batch_size)
dataset.set_filelist(filelist)
exe.train_from_dataset(
            fluid.default_main_program(),
            dataset,
            thread=2,
            debug=False,
            fetch_list=[],
            fetch_info=[],
            print_period=1)

RMSPropOptimizer

class paddle.fluid.optimizer.RMSPropOptimizer(learning_rate, rho=0.95, epsilon=1e-06, momentum=0.0, centered=False, regularization=None, name=None)[源代码]

均方根传播(RMSProp)法是一种未发表的,自适应学习率的方法。原演示幻灯片中提出了RMSProp:[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张。等式如下所示:

\[\begin{split}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)\end{split}\]

第一个等式计算每个权重平方梯度的移动平均值,然后将梯度除以 \(sqrtv(w,t)\)

\[\begin{split}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{r(w,t) +\epsilon}} \nabla Q_{i}(w)\\ w & = w - v(w, t)\end{split}\]

如果居中为真:

\[\begin{split}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 +\epsilon}} \nabla Q_{i}(w)\\ w & = w - v(w, t)\end{split}\]

其中, \(ρ\) 是超参数,典型值为0.9,0.95等。 \(beta\) 是动量术语。 \(epsilon\) 是一个平滑项,用于避免除零,通常设置在1e-4到1e-8的范围内。

参数:
  • learning_rate (float) - 全局学习率。
  • rho (float) - rho是等式中的 \(rho\) ,默认设置为0.95。
  • epsilon (float) - 等式中的epsilon是平滑项,避免被零除,默认设置为1e-6。
  • momentum (float) - 方程中的β是动量项,默认设置为0.0。
  • centered (bool) - 如果为True,则通过梯度的估计方差,对梯度进行归一化;如果False,则由未centered的第二个moment归一化。将此设置为True有助于模型训练,但会消耗额外计算和内存资源。默认为False。
  • regularization - 正则器项,如 fluid.regularizer.L2DecayRegularizer
  • name - 可选的名称前缀。
抛出异常:
  • ValueError -如果 learning_raterhoepsilonmomentum 为None。

示例代码

import paddle
import paddle.fluid as fluid
import numpy as np

place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
    x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    y_predict = fluid.layers.fc(input=x, size=1, act=None)
    cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    avg_cost = fluid.layers.mean(cost)

    rms_optimizer = fluid.optimizer.RMSProp(learning_rate=0.1)
    rms_optimizer.minimize(avg_cost)

    fetch_list = [avg_cost]
    train_reader = paddle.batch(
        paddle.dataset.uci_housing.train(), batch_size=1)
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe = fluid.Executor(place)
    exe.run(fluid.default_startup_program())
    for data in train_reader():
        exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple

SGD

paddle.fluid.optimizer.SGD

SGDOptimizer 的别名

SGDOptimizer

class paddle.fluid.optimizer.SGDOptimizer(learning_rate, regularization=None, name=None)[源代码]

随机梯度下降算法的优化器

\[\begin{split}\\param\_out=param-learning\_rate*grad\\\end{split}\]
参数:
  • learning_rate (float|Variable) - 用于更新参数的学习率。可以是浮点值,也可以是具有一个浮点值作为数据元素的变量。
  • regularization - 一个正则化器,例如 fluid.regularizer.L2DecayRegularizer
  • name - 可选的名称前缀。

代码示例

import paddle
import paddle.fluid as fluid
import numpy as np

place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
    x = fluid.layers.data(name='x', shape=[13], dtype='float32')
    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
    y_predict = fluid.layers.fc(input=x, size=1, act=None)
    cost = fluid.layers.square_error_cost(input=y_predict, label=y)
    avg_cost = fluid.layers.mean(cost)

    sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
    sgd_optimizer.minimize(avg_cost)

    fetch_list = [avg_cost]
    train_reader = paddle.batch(
        paddle.dataset.uci_housing.train(), batch_size=1)
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe = fluid.Executor(place)
    exe.run(fluid.default_startup_program())
    for data in train_reader():
        exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
apply_gradients(params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步

参数:
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

import paddle.fluid as fluid
loss = network()
optimizer = fluid.optimizer.SGD(learning_rate=0.1)
params_grads = optimizer.backward(loss)
# you may append operations for params_grads here
# ...
optimizer.apply_gradients(params_grads)
apply_optimize(loss, startup_program, params_grads)

为给定的params_grads对附加优化算子,为minimize过程的第二步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • params_grads (list)- 用于优化的(param, grad)对组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)

自动做diff来向当前program附加反向算子,为minimize过程的第一步。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • callbacks (list|None) – 当为某参数附加反向算子时所要运行的callables组成的列表

返回: 附加在当前Program的算子组成的列表

返回类型: list

代码示例

详见apply_gradients的示例

load(stat_dict)

在dygraph模式下,附带学习率衰减来加载优化器。

参数:
  • stat_dict – load_persistable方法加载的dict

代码示例

from __future__ import print_function
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.optimizer import SGDOptimizer
from paddle.fluid.dygraph.nn import FC
from paddle.fluid.dygraph.base import to_variable

class MLP(fluid.Layer):
    def __init__(self, name_scope):
        super(MLP, self).__init__(name_scope)

        self._fc1 = FC(self.full_name(), 10)
        self._fc2 = FC(self.full_name(), 10)

    def forward(self, inputs):
        y = self._fc1(inputs)
        y = self._fc2(y)
        return y

with fluid.dygraph.guard():
    mlp = MLP('mlp')
    optimizer2 = SGDOptimizer(
        learning_rate=fluid.layers.natural_exp_decay(
        learning_rate=0.1,
        decay_steps=10000,
        decay_rate=0.5,
        staircase=True))

    train_reader = paddle.batch(
            paddle.dataset.mnist.train(), batch_size=128, drop_last=True)

    for batch_id, data in enumerate(train_reader()):
        dy_x_data = np.array(
                [x[0].reshape(1, 28, 28) for x in data]).astype('float32')

        y_data = np.array([x[1] for x in data]).astype('int64').reshape(
                128, 1)

        img = to_variable(dy_x_data)
        label = to_variable(y_data)
        label._stop_gradient = True
        cost = mlp(img)
        avg_loss = fluid.layers.reduce_mean(cost)
        avg_loss.backward()
        optimizer.minimize(avg_loss)
        mlp.clear_gradients()
        fluid.dygraph.save_persistables(
                mlp.state_dict(), [optimizer, optimizer2], "save_dir_2")
        if batch_id == 2:
                break

with fluid.dygraph.guard():
    mlp_load = MLP('mlp')
    optimizer_load2 = SGDOptimizer(
            learning_rate=fluid.layers.natural_exp_decay(
            learning_rate=0.1,
            decay_steps=10000,
            decay_rate=0.5,
            staircase=True))
    parameters, optimizers = fluid.dygraph.load_persistables(
        "save_dir_2")
    mlp_load.load_dict(parameters)
    optimizer_load2.load(optimizers)
self.assertTrue(optimizer2._learning_rate.__dict__ == optimizer_load2._learning_rate.__dict__)
minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)

通过更新parameter_list来添加操作,进而使损失最小化。

该算子相当于backward()和apply_gradients()功能的合体。

参数:
  • loss (Variable) – 用于优化过程的损失值变量
  • startup_program (Program) – 用于初始化在parameter_list中参数的startup_program
  • parameter_list (list) – 待更新的Variables组成的列表
  • no_grad_set (set|None) – 应该被无视的Variables集合
  • grad_clip (GradClipBase|None) – 梯度裁剪的策略

返回: (optimize_ops, params_grads),分别为附加的算子列表;一个由(param, grad) 变量对组成的列表,用于优化

返回类型: tuple