diff --git a/doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst b/doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst index 46ee0d4cc37f5b5f52089c8a6ed4861902912634..02df5be0440e19562ab2cc3cdc870813f4230855 100644 --- a/doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst +++ b/doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst @@ -7,7 +7,7 @@ StaticRNN StaticRNN可以处理一批序列数据。每个样本序列的长度必须相等。StaticRNN将拥有自己的参数，如输入、输出和存储器等。请注意，输入的第一个维度表示序列长度，且输入的所有序列长度必须相同。并且输入和输出的每个轴的含义是相同的。 -**代码示例**： +**代码示例** .. code-block:: python @@ -42,88 +42,88 @@ StaticRNN可以将多个变量标记为其输出。使用rnn()获取输出序列 .. py:method:: step() - 用户在该代码块中定义RNN中的operators。 +用户在该代码块中定义RNN中的operators。 .. 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变量。 +为静态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轴 +参数： + - **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/AdagradOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/AdagradOptimizer_cn.rst index fbfb3f58a249b4fd4f510fc6328d55512a902fef..812931be1efe686e258a6e8b084485ab492a097e 100644 --- a/doc/fluid/api_cn/optimizer_cn/AdagradOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/AdagradOptimizer_cn.rst @@ -24,9 +24,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 @@ -45,6 +45,161 @@ 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 + + + diff --git a/doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst index 1b0412b7e483057034110754da2a9836e7081175..a11d7a729f2c2e17f500cd47b68c3b5ce1012791 100644 --- a/doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst @@ -24,7 +24,7 @@ Adam更新如下： **代码示例**： -.. code-block:: python: +.. code-block:: python import paddle import paddle.fluid as fluid @@ -51,6 +51,161 @@ Adam更新如下： +.. 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 + + + diff --git a/doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst index f07351102fcf816ea2fc0e1f28f47e3d91f87c59..85c9a0ea4d1e5de168fdd939099a68b0a7ead936 100644 --- a/doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst @@ -26,7 +26,7 @@ Adamax 更新规则: **代码示例**： -.. code-block:: python: +.. code-block:: python import paddle.fluid as fluid import numpy @@ -63,7 +63,160 @@ Adamax 更新规则: .. note:: 目前 ``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 diff --git a/doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst index 9809174e32a843819e8ebc18a4963a066bcc4342..dbb59ba23337f53b8839ce974a1cedbc28694c9e 100644 --- a/doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst @@ -48,3 +48,157 @@ DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来 + +.. 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 + diff --git a/doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst index f9fb440ace02fd4829f03b7abcc804a5d45b0f0b..0e3aac065d8b8b5b3b9f56d6ad102996a4842d93 100644 --- a/doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst @@ -42,5 +42,156 @@ Decayed Adagrad Optimizer 当前， ``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 diff --git a/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst index 06b0a33a265b786bf1f3199d7b427e34a035b9bb..206d83275fd62568b834c371f2276c50669f6074 100644 --- a/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst @@ -74,4 +74,157 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi +.. 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 + diff --git a/doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst index 275c903b7949c60be6e3b10128256eaf992fd0e0..ffadcfaf2e22ef7c97b9261ea1b191e916a93945 100644 --- a/doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst @@ -44,4 +44,155 @@ Deep Learning: Training BERT in 76 minutes