diff --git a/doc/fluid/api_cn/layers_cn/create_global_var_cn.rst b/doc/fluid/api_cn/layers_cn/create_global_var_cn.rst index da8473bcd3c818cd88adcd2b14fc40940943e54e..abc253080e5ca5e7f4cb977fad0667475fb6f873 100644 --- a/doc/fluid/api_cn/layers_cn/create_global_var_cn.rst +++ b/doc/fluid/api_cn/layers_cn/create_global_var_cn.rst @@ -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 **代码示例**： diff --git a/doc/fluid/api_cn/layers_cn/create_parameter_cn.rst b/doc/fluid/api_cn/layers_cn/create_parameter_cn.rst index e4faa6c17eaa7073ee14d7026554fa4c589ed57e..b71b8cb23fec4c0d49f525028d8a2f00c512e26a 100644 --- a/doc/fluid/api_cn/layers_cn/create_parameter_cn.rst +++ b/doc/fluid/api_cn/layers_cn/create_parameter_cn.rst @@ -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。 **代码示例**： diff --git a/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst index 206d83275fd62568b834c371f2276c50669f6074..3a35a5fc9f3b832bab910cbb97b1b4ac9f5090a2 100644 --- a/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/FtrlOptimizer_cn.rst @@ -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 `_) @@ -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,8 +86,8 @@ 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 +返回类型： tuple diff --git a/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst index bc726a78df9671c078bea7c5716b2a07b371789d..b3d786885bf12886017ba015aafbab2ea8050d10 100644 --- a/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst @@ -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,15 +55,15 @@ 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 +返回类型： tuple diff --git a/doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst index 1bab86dd28ccb77cf7e80a7938bcc13c1b8c9e91..be577db15b26401066d3afae69d583f5294a46e9 100644 --- a/doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/MomentumOptimizer_cn.rst @@ -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。 **代码示例**： @@ -29,7 +29,7 @@ MomentumOptimizer import paddle import paddle.fluid as fluid import numpy as np - + place = fluid.CPUPlace() main = fluid.Program() with fluid.program_guard(main): @@ -38,10 +38,10 @@ MomentumOptimizer y_predict = fluid.layers.fc(input=x, size=1, act=None) cost = fluid.layers.square_error_cost(input=y_predict, label=y) avg_cost = fluid.layers.mean(cost) - + moment_optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.001, momentum=0.9) moment_optimizer.minimize(avg_cost) - + fetch_list = [avg_cost] train_reader = paddle.batch( paddle.dataset.uci_housing.train(), batch_size=1) @@ -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) diff --git a/doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst index 8f2c5e71a9b5e5e006b2ae0c7448b149cbd4d64c..b2ddffead4844b04d2496ed68136801fe7b443fe 100644 --- a/doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/RMSPropOptimizer_cn.rst @@ -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 - - - diff --git a/doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst index 3dd1c267a992df8c4a731adb94bd74a0ec94ee63..9f3446abd262dc9c7b52b6082ba6fad840de0374 100644 --- a/doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/SGDOptimizer_cn.rst @@ -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)