diff --git a/doc/fluid/api_cn/layers_cn/control_flow_cn.rst b/doc/fluid/api_cn/layers_cn/control_flow_cn.rst index 76e4f5196c25bbc6d093c6231072ceeffe825c9a..8cd7f04ccfaf80efae421fcd95670a39b4f2ff3e 100644 --- a/doc/fluid/api_cn/layers_cn/control_flow_cn.rst +++ b/doc/fluid/api_cn/layers_cn/control_flow_cn.rst @@ -748,7 +748,7 @@ StaticRNN StaticRNN可以处理一批序列数据。每个样本序列的长度必须相等。StaticRNN将拥有自己的参数，如输入、输出和存储器等。请注意，输入的第一个维度表示序列长度，且输入的所有序列长度必须相同。并且输入和输出的每个轴的含义是相同的。 -**代码示例**： +**代码示例** .. code-block:: python @@ -787,84 +787,84 @@ StaticRNN可以将多个变量标记为其输出。使用rnn()获取输出序列 .. py:method:: memory(init=None, shape=None, batch_ref=None, init_value=0.0, init_batch_dim_idx=0, ref_batch_dim_idx=1) - - 为静态RNN创建一个内存变量。 - 如果init不为None，则此变量将初始化内存。 如果init为None，则必须设置shape和batch_ref，并且此函数将初始化init变量。 - - 参数： - - **init** (Variable|None) - 初始化过的变量，如果没有设置，则必须提供shape和batch_ref，默认值None - - **shape** (list|tuple) - boot memory的形状，注意其不包括batch_size，默认值None - - **batch_ref** (Variable|None) - batch引用变量，默认值None - - **init_value** (float) - boot memory的初始化值，默认值0.0 - - **init_batch_dim_idx** (int) - init变量的batch_size轴，默认值0 - - **ref_batch_dim_idx** (int) - batch_ref变量的batch_size轴 - 返回：内存变量 +为静态RNN创建一个内存变量。 +如果init不为None，则此变量将初始化内存。 如果init为None，则必须设置shape和batch_ref，并且此函数将初始化init变量。 +参数： + - **init** (Variable|None) - 初始化过的变量，如果没有设置，则必须提供shape和batch_ref，默认值None + - **shape** (list|tuple) - boot memory的形状，注意其不包括batch_size，默认值None + - **batch_ref** (Variable|None) - batch引用变量，默认值None + - **init_value** (float) - boot memory的初始化值，默认值0.0 + - **init_batch_dim_idx** (int) - init变量的batch_size轴，默认值0 + - **ref_batch_dim_idx** (int) - batch_ref变量的batch_size轴 - **代码示例**： +返回：内存变量 - .. code-block:: python - import paddle.fluid as fluid - import paddle.fluid.layers as layers +**代码示例** - vocab_size, hidden_size=10000, 200 - x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64') - x_emb = layers.embedding( - input=x, - size=[vocab_size, hidden_size], - dtype='float32', - is_sparse=False) - x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) +.. code-block:: python - rnn = fluid.layers.StaticRNN() - with rnn.step(): - word = rnn.step_input(x_emb) - prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) - hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') - rnn.update_memory(prev, hidden) + import paddle.fluid as fluid + import paddle.fluid.layers as layers + + vocab_size, hidden_size=10000, 200 + x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64') + x_emb = layers.embedding( + input=x, + size=[vocab_size, hidden_size], + dtype='float32', + is_sparse=False) + x_emb = layers.transpose(x_emb, perm=[1, 0, 2]) + + rnn = fluid.layers.StaticRNN() + with rnn.step(): + word = rnn.step_input(x_emb) + prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word) + hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu') + rnn.update_memory(prev, hidden) .. py:method:: step_input(x) - 标记作为StaticRNN输入的序列。 +标记作为StaticRNN输入的序列。 - 参数： - - **x** (Variable) – 输入序列，x的形状应为[seq_len, ...]。 +参数： + - **x** (Variable) – 输入序列，x的形状应为[seq_len, ...]。 - 返回：输入序列中的当前时间步长。 +返回：输入序列中的当前时间步长。 .. py:method:: step_output(o) - 标记作为StaticRNN输出的序列。 +标记作为StaticRNN输出的序列。 - 参数： - -**o** (Variable) – 输出序列 +参数： + -**o** (Variable) – 输出序列 - 返回：None +返回：None .. py:method:: output(*outputs) - 标记StaticRNN输出变量。 +标记StaticRNN输出变量。 - 参数： - -**outputs** – 输出变量 +参数： + -**outputs** – 输出变量 - 返回：None +返回：None .. py:method:: update_memory(mem, var) - 将内存从ex_mem更新为new_mem。请注意，ex_mem和new_mem的形状和数据类型必须相同。 +将内存从ex_mem更新为new_mem。请注意，ex_mem和new_mem的形状和数据类型必须相同。 - 参数： - - **mem** (Variable) – 内存变量 - - **var** (Variable) – RNN块中产生的普通变量 +参数： + - **mem** (Variable) – 内存变量 + - **var** (Variable) – RNN块中产生的普通变量 - 返回：None +返回：None diff --git a/doc/fluid/api_cn/optimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn.rst index 68adba24e8de2279b60bd21915066fc52fbb8278..ba5a3a4f42fadb0779aae3f17a7b7edf4c428e7f 100644 --- a/doc/fluid/api_cn/optimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn.rst @@ -54,9 +54,9 @@ http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避 - **name** - 名称前缀（可选） - **initial_accumulator_value** (float) - moment累加器的初始值。 -**代码示例**： +**代码示例** -.. code-block:: python: +.. code-block:: python import paddle.fluid as fluid import numpy as np @@ -75,6 +75,158 @@ http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避 feed={"inp": np_inp}, fetch_list=[out.name]) +.. py:method:: apply_gradients(params_grads) + +为给定的params_grads对附加优化算子，为minimize过程的第二步 + +参数： + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 + +返回： 附加在当前Program的算子组成的列表 + +返回类型： list + +**代码示例** + +.. code-block:: python + + 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) + + +.. py:method:: 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 + +.. py:method:: 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的示例 + + +.. py:method:: load(stat_dict) + +在dygraph模式下，附带学习率衰减来加载优化器。 + +参数： + - **stat_dict** – load_persistable方法加载的dict + +**代码示例** + +.. code-block:: python + + 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__) + + +.. py:method:: 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 @@ -133,9 +285,9 @@ Adamax 更新规则: 论文中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数 -**代码示例**： +**代码示例** -.. code-block:: python: +.. code-block:: python import paddle.fluid as fluid import numpy @@ -173,6 +325,158 @@ Adamax 更新规则: 目前 ``AdamaxOptimizer`` 不支持 sparse parameter optimization. +.. py:method:: apply_gradients(params_grads) + +为给定的params_grads对附加优化算子，为minimize过程的第二步 + +参数： + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 + +返回： 附加在当前Program的算子组成的列表 + +返回类型： list + +**代码示例** + +.. code-block:: python + + 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) + + +.. py:method:: 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 + +.. py:method:: 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的示例 + + +.. py:method:: load(stat_dict) + +在dygraph模式下，附带学习率衰减来加载优化器。 + +参数： + - **stat_dict** – load_persistable方法加载的dict + +**代码示例** + +.. code-block:: python + + 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__) + + +.. py:method:: 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 @@ -207,9 +511,9 @@ Adam更新如下： - **lazy_mode** （bool: false） - 官方Adam算法有两个移动平均累加器（moving-average accumulators）。累加器在每一步都会更新。在密集模式和稀疏模式下，两条移动平均线的每个元素都会更新。如果参数非常大，那么更新可能很慢。 lazy mode仅更新当前具有梯度的元素，所以它会更快。但是这种模式与原始的算法有不同的描述，可能会导致不同的结果。 -**代码示例**： +**代码示例** -.. code-block:: python: +.. code-block:: python import paddle import paddle.fluid as fluid @@ -234,6 +538,158 @@ Adam更新如下： for data in train_reader(): exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list) +.. py:method:: apply_gradients(params_grads) + +为给定的params_grads对附加优化算子，为minimize过程的第二步 + +参数： + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 + +返回： 附加在当前Program的算子组成的列表 + +返回类型： list + +**代码示例** + +.. code-block:: python + + 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) + + +.. py:method:: 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 + +.. py:method:: 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的示例 + + +.. py:method:: load(stat_dict) + +在dygraph模式下，附带学习率衰减来加载优化器。 + +参数： + - **stat_dict** – load_persistable方法加载的dict + +**代码示例** + +.. code-block:: python + + 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__) + + +.. py:method:: 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 @@ -297,6 +753,158 @@ Decayed Adagrad Optimizer .. note:: 当前， ``DecayedAdagradOptimizer`` 不支持 sparse parameter optimization +.. py:method:: apply_gradients(params_grads) + +为给定的params_grads对附加优化算子，为minimize过程的第二步 + +参数： + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 + +返回： 附加在当前Program的算子组成的列表 + +返回类型： list + +**代码示例** + +.. code-block:: python + + 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) + + +.. py:method:: 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 + +.. py:method:: 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的示例 + + +.. py:method:: load(stat_dict) + +在dygraph模式下，附带学习率衰减来加载优化器。 + +参数： + - **stat_dict** – load_persistable方法加载的dict + +**代码示例** + +.. code-block:: python + + 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__) + + +.. py:method:: 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 @@ -348,6 +956,158 @@ DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来 rampup_begin_step=1252, sparsity=[0.999, 0.999]) +.. py:method:: apply_gradients(params_grads) + +为给定的params_grads对附加优化算子，为minimize过程的第二步 + +参数： + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 + +返回： 附加在当前Program的算子组成的列表 + +返回类型： list + +**代码示例** + +.. code-block:: python + + 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) + + +.. py:method:: 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 + +.. py:method:: 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的示例 + + +.. py:method:: load(stat_dict) + +在dygraph模式下，附带学习率衰减来加载优化器。 + +参数： + - **stat_dict** – load_persistable方法加载的dict + +**代码示例** + +.. code-block:: python + + 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__) + + +.. py:method:: 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 .. _cn_api_fluid_optimizer_ExponentialMovingAverage: @@ -539,29 +1299,181 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi .. note:: 目前, FtrlOptimizer 不支持 sparse parameter optimization +.. py:method:: apply_gradients(params_grads) + +为给定的params_grads对附加优化算子，为minimize过程的第二步 +参数： + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 +返回： 附加在当前Program的算子组成的列表 -.. _cn_api_fluid_optimizer_LambOptimizer: +返回类型： list -LambOptimizer -------------------------------- +**代码示例** -.. py: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) +.. code-block:: python -LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器 -LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小，支持自适应元素更新和精确的分层校正。 更多信息请参考 `Large Batch Optimization for -Deep Learning: Training BERT in 76 minutes `_ 。 -参数更新如下： + 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) -.. math:: - \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} +.. py:method:: apply_optimize(loss, startup_program, params_grads) -其中 :math:`m` 为第一个时刻，:math:`v` 为第二个时刻，:math:`\eta` 为学习率，:math:`\lambda` 为LAMB权重衰减率。 +为给定的params_grads对附加优化算子，为minimize过程的第二步。 参数： - - **learning_rate** (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。 + - **loss** (Variable) – 用于优化过程的损失值变量 + - **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program + - **params_grads** (list)- 用于优化的(param, grad)对组成的列表 + +返回： 附加在当前Program的算子组成的列表 + +返回类型： list + +.. py:method:: 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的示例 + + +.. py:method:: load(stat_dict) + +在dygraph模式下，附带学习率衰减来加载优化器。 + +参数： + - **stat_dict** – load_persistable方法加载的dict + +**代码示例** + +.. code-block:: python + + 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__) + + +.. py:method:: 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 + + + +.. _cn_api_fluid_optimizer_LambOptimizer: + +LambOptimizer +------------------------------- + +.. py: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 `_ 。 +参数更新如下： + +.. math:: + + \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} + +其中 :math:`m` 为第一个时刻，:math:`v` 为第二个时刻，:math:`\eta` 为学习率，:math:`\lambda` 为LAMB权重衰减率。 + +参数： + - **learning_rate** (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。 - **lamb_weight_decay** (float) – LAMB权重衰减率。 - **beta1** (float) – 第一个时刻估计的指数衰减率。 - **beta2** (float) – 第二个时刻估计的指数衰减率。 @@ -587,6 +1499,158 @@ Deep Learning: Training BERT in 76 minutes