Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
提交 ef45bcad 编写于 作者: H Hao Wang 提交者： xsrobin
浏览文件
操作

update optimizer cn to 1.5 en official (#1062)

上级 f84af2fa
隐藏空白更改
内联 并排
Showing with 1883 addition and 58 deletion
doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst
浏览文件 @ ef45bcad
......@@ -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
......
doc/fluid/api_cn/optimizer_cn/AdagradOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -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
......
doc/fluid/api_cn/optimizer_cn/AdamOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -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
......
doc/fluid/api_cn/optimizer_cn/AdamaxOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -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
......
doc/fluid/api_cn/optimizer_cn/DGCMomentumOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -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
doc/fluid/api_cn/optimizer_cn/DecayedAdagradOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -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
doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -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
doc/fluid/api_cn/optimizer_cn/LambOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -44,4 +44,155 @@ Deep Learning: Training BERT in 76 minutes <https://arxiv.org/pdf/1904.00962.pdf
optimizer.minimize(cost)
.. 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
doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -24,7 +24,7 @@ LARS支持的Momentum优化器
- **regularization** - 正则化函数，例如 :code:`fluid.regularizer.L2DecayRegularizer`
- **name** - 名称前缀，可选
**代码示例：**
**代码示例**
.. code-block:: python
......@@ -32,7 +32,158 @@ LARS支持的Momentum优化器
optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
optimizer.minimize(cost)
.. 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
......
doc/fluid/api_cn/optimizer_cn/ModelAverage_cn.rst
浏览文件 @ ef45bcad
......@@ -72,7 +72,158 @@ ModelAverage
- **executor** (fluid.Executor) – 当前的执行引擎。
.. 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
doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -17,10 +17,10 @@ MomentumOptimizer
参数：
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
- **momentum** (float) - 动量因子
- **momentum** (float) - 动量因子
- **use_nesterov** (bool) - 赋能牛顿动量
- **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
- **name** - 名称前缀（可选）
- **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
- **name** - 名称前缀（可选）
**代码示例**：
......@@ -51,7 +51,158 @@ MomentumOptimizer
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
......
doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -69,7 +69,158 @@ RMSPropOptimizer
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
......
doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst
浏览文件 @ ef45bcad
......@@ -47,9 +47,158 @@ SGDOptimizer
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
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或