Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
未验证 提交 e063c601 编写于 作者: W wopeizl 提交者： GitHub
浏览文件
操作

fix the chinese doc for paddle test=develop (#1386) 

* fix the chinese doc for paddle test=develop
paddle.fluid.layers.create_global_var
paddle.fluid.layers.create_parameter
paddle.fluid.optimizer.FtrlOptimizer
paddle.fluid.optimizer.LarsMomentumOptimizer
paddle.fluid.optimizer.MomentumOptimizer
paddle.fluid.optimizer.RMSPropOptimizer
paddle.fluid.optimizer.SGDOptimizer
上级 4af8a9d2
显示空白变更内容
内联 并排
Showing with 62 addition and 732 deletion
doc/fluid/api_cn/layers_cn/create_global_var_cn.rst
浏览文件 @ e063c601
......@@ -5,19 +5,19 @@ create_global_var
.. py:function:: paddle.fluid.layers.create_global_var(shape,value,dtype,persistable=False,force_cpu=False,name=None)
在全局块中创建一个新的带有 ``value`` 的张量。
该OP在全局块中创建一个新的Tensor，Tensor的值为 ``value`` 。
参数：
- **shape** (list[int])-变量的维度
- **value** (float)-变量的值。填充新创建的变量
- **dtype** (string)-变量的数据类型
- **persistable** (bool)-如果是永久变量。默认：False
- **force_cpu** (bool)-将该变量压入CPU。默认：False
- **name** (str|None)-变量名。如果设为空，则自动创建变量名。默认：None.
- **shape** (list[int])- 指定输出Tensor的形状，它可以是一个整数列表。
- **value** (float)- 变量的值，填充新创建的变量。
- **dtype** (str|numpy.dtype，可选)– 初始化数据类型。可设置的字符串值有："float32"，"float64"，"int32"，"int64"。
- **persistable** (bool，可选)- 是否为永久变量，默认：False。
- **force_cpu** (bool，可选)- 是否将该变量压入CPU，默认值为 False。
- **name** (str，可选)- 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
返回：创建的变量
返回：创建的Tensor变量
返回类型：变量（Variable）
返回类型：Variable
**代码示例**：
......
doc/fluid/api_cn/layers_cn/create_parameter_cn.rst
浏览文件 @ e063c601
......@@ -5,18 +5,20 @@ create_parameter
.. py:function:: paddle.fluid.layers.create_parameter(shape,dtype,name=None,attr=None,is_bias=False,default_initializer=None)
创建一个参数。该参数是一个可学习的变量，拥有梯度并且可优化。
该OP创建一个参数。该参数是一个可学习的变量，拥有梯度并且可优化。
注：这是一个低级别的API。如果您希望自己创建新的op，这个API将非常有用，无需使用layers。
**注意：这是一个低级别的API。如果您希望自己创建新的op，这个API将非常有用，无需使用layers。**
参数：
- **shape** (list[int])-参数的维度
- **dtype** (string)-参数的元素类型
- **attr** (ParamAttr)-参数的属性
- **is_bias** (bool)-当default_initializer为空，该值会对选择哪个默认初始化程序产生影响。如果is_bias为真，则使用initializer.Constant(0.0)，否则使用Xavier()。
- **default_initializer** (Initializer)-参数的初始化程序
- **shape** (list[int])- 指定输出Tensor的形状，它可以是一个整数列表。
- **dtype** (str|numpy.dtype，可选)– 初始化数据类型。可设置的字符串值有："float32"，"float64"，"int32"，"int64"。
- **attr** (ParamAttr)- 参数的属性。
- **is_bias** (bool，可选)- 当default_initializer为空，该值会对选择哪个默认初始化程序产生影响。如果is_bias为真，则使用initializer.Constant(0.0)，否则使用Xavier()， 默认值False。
- **default_initializer** (Initializer，可选)- 参数的初始化程序，默认值为空。
返回：创建的参数
返回：创建的Tensor变量。
返回类型：Variable。
**代码示例**：
......
doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst
浏览文件 @ e063c601
......@@ -5,7 +5,7 @@ FtrlOptimizer
.. py:class:: paddle.fluid.optimizer.FtrlOptimizer(learning_rate, l1=0.0, l2=0.0, lr_power=-0.5,regularization=None, name=None)
FTRL (Follow The Regularized Leader) Optimizer.
该接口实现FTRL (Follow The Regularized Leader) Optimizer.
FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_)
......@@ -29,12 +29,12 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
参数:
- **learning_rate** (float|Variable)-全局学习率。
- **l1** (float) - L1 regularization strength.
- **l2** (float) - L2 regularization strength.
- **lr_power** (float) - 学习率降低指数
- **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** — 可选的名称前缀
- **learning_rate** (float|Variable)- 全局学习率。
- **l1** (float，可选) - L1 regularization strength，默认值0.0。
- **l2** (float，可选) - L2 regularization strength，默认值0.0。
- **lr_power** (float，可选) - 学习率降低指数，默认值-0.5。
- **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 。
- **name** (str, 可选) - 可选的名称前缀，一般无需设置，默认值为None。
抛出异常：
- ``ValueError`` - 如果 ``learning_rate`` , ``rho`` , ``epsilon`` , ``momentum`` 为 None.
......@@ -69,144 +69,7 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
.. note::
目前, FtrlOptimizer 不支持 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__)
**注意：目前, FtrlOptimizer 不支持 sparse parameter optimization。**
.. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None, grad_clip=None)
......@@ -223,7 +86,7 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
- **no_grad_set** (set|None) – 应该被无视的Variables集合
- **grad_clip** (GradClipBase|None) – 梯度裁剪的策略
返回： (optimize_ops, params_grads)，分别为附加的算子列表；一个由(param, grad) 变量对组成的列表，用于优化
返回： (optimize_ops, params_grads)，数据类型为(list, list)，其中optimize_ops是minimize接口为网络添加的OP列表，params_grads是一个由(param, grad)变量对组成的列表，param是Parameter，grad是该Parameter对应的梯度值
返回类型： tuple
......
doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst
浏览文件 @ e063c601
......@@ -5,7 +5,7 @@ LarsMomentumOptimizer
.. py:class:: paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)
LARS支持的Momentum优化器
该接口实现LARS支持的Momentum优化器
公式作如下更新：
......@@ -17,12 +17,13 @@ LARS支持的Momentum优化器
& param = param - velocity
参数：
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
- **momentum** (float) - 动量因子
- **lars_coeff** (float) - 定义LARS本地学习率的权重
- **lars_weight_decay** (float) - 使用LARS进行衰减的权重衰减系数
- **regularization** - 正则化函数，例如 :code:`fluid.regularizer.L2DecayRegularizer`
- **name** - 名称前缀，可选
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量。
- **momentum** (float) - 动量因子。
- **lars_coeff** (float，可选) - 定义LARS本地学习率的权重，默认值0.001。
- **lars_weight_decay** (float，可选) - 使用LARS进行衰减的权重衰减系数，默认值0.0005。
- **regularization** - 正则化函数，例如 :code:`fluid.regularizer.L2DecayRegularizer`。
- **name** (str, 可选) - 可选的名称前缀，一般无需设置，默认值为None。
**代码示例**
......@@ -44,139 +45,6 @@ LARS支持的Momentum优化器
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)
......@@ -187,13 +55,13 @@ LARS支持的Momentum优化器
该算子相当于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) – 梯度裁剪的策略
- **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) 变量对组成的列表，用于优化
返回： (optimize_ops, params_grads)，数据类型为(list, list)，其中optimize_ops是minimize接口为网络添加的OP列表，params_grads是一个由(param, grad)变量对组成的列表，param是Parameter，grad是该Parameter对应的梯度值
返回类型： tuple
......
doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst
浏览文件 @ e063c601
......@@ -5,7 +5,7 @@ MomentumOptimizer
.. py:class:: paddle.fluid.optimizer.MomentumOptimizer(learning_rate, momentum, use_nesterov=False, regularization=None, name=None)
含有速度状态的Simple Momentum 优化器
该接口实现含有速度状态的Simple Momentum 优化器
该优化器含有牛顿动量标志，公式更新如下：
......@@ -16,11 +16,11 @@ MomentumOptimizer
& else:\\&\quad param = param - learning\_rate * velocity
参数：
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
- **momentum** (float) - 动量因子
- **use_nesterov** (bool) - 赋能牛顿动量
- **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
- **name** - 名称前缀（可选）
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量。
- **momentum** (float) - 动量因子。
- **use_nesterov** (bool，可选) - 赋能牛顿动量，默认值False。
- **regularization** - 正则化函数，，例如 :code:`fluid.regularizer.L2DecayRegularizer`，默认值None。
- **name** (str, 可选) - 可选的名称前缀，一般无需设置，默认值为None。
**代码示例**：
......@@ -51,139 +51,6 @@ 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)
......
doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst
浏览文件 @ e063c601
......@@ -5,7 +5,7 @@ RMSPropOptimizer
.. py:class:: paddle.fluid.optimizer.RMSPropOptimizer(learning_rate, rho=0.95, epsilon=1e-06, momentum=0.0, centered=False, regularization=None, name=None)
均方根传播（RMSProp）法是一种未发表的,自适应学习率的方法。原演示幻灯片中提出了RMSProp：[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张。等式如下所示：
该接口实现均方根传播（RMSProp）法，是一种未发表的,自适应学习率的方法。原演示幻灯片中提出了RMSProp：[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张。等式如下所示：
.. math::
r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
......@@ -30,12 +30,12 @@ RMSPropOptimizer
参数：
- **learning_rate** （float） - 全局学习率。
- **rho** （float） - rho是等式中的 :math:`rho` ，默认设置为0.95。
- **epsilon** （float） - 等式中的epsilon是平滑项，避免被零除，默认设置为1e-6。
- **momentum** （float） - 方程中的β是动量项，默认设置为0.0。
- **centered** （bool） - 如果为True，则通过梯度的估计方差,对梯度进行归一化；如果False，则由未centered的第二个moment归一化。将此设置为True有助于模型训练，但会消耗额外计算和内存资源。默认为False。
- **rho** （float，可选） - rho是等式中的 :math:`rho` ，默认值0.95。
- **epsilon** （float，可选） - 等式中的epsilon是平滑项，避免被零除，默认值1e-6。
- **momentum** （float，可选） - 方程中的β是动量项，默认值0.0。
- **centered** （bool，可选） - 如果为True，则通过梯度的估计方差,对梯度进行归一化；如果False，则由未centered的第二个moment归一化。将此设置为True有助于模型训练，但会消耗额外计算和内存资源。默认为False。
- **regularization** - 正则器项，如 ``fluid.regularizer.L2DecayRegularizer`` 。
- **name** - 可选的名称前缀。
- **name** (str, 可选) - 可选的名称前缀，一般无需设置，默认值为None。
抛出异常:
- ``ValueError`` -如果 ``learning_rate`` ， ``rho`` ， ``epsilon`` ， ``momentum`` 为None。
......@@ -69,139 +69,6 @@ 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)
......@@ -252,6 +119,3 @@ RMSPropOptimizer
doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst
浏览文件 @ e063c601
......@@ -5,7 +5,7 @@ SGDOptimizer
.. py:class:: paddle.fluid.optimizer.SGDOptimizer(learning_rate, regularization=None, name=None)
随机梯度下降算法的优化器
该接口实现随机梯度下降算法的优化器
.. math::
\\param\_out=param-learning\_rate*grad\\
......@@ -13,8 +13,8 @@ SGDOptimizer
参数:
- **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
- **regularization** - 一个正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** - 可选的名称前缀。
- **regularization** - 一个正则化器，例如 ``fluid.regularizer.L2DecayRegularizer`` 。
- **name** (str, 可选) - 可选的名称前缀，一般无需设置，默认值为None。
**代码示例**
......@@ -47,140 +47,6 @@ 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)
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或