# Rprop¶

class paddle.optimizer. Rprop ( learning_rate=0.001, learning_rate_range=(1e-05, 50), parameters=None, etas=(0.5, 1.2), grad_clip=None, multi_precision=False, name=None ) [source]

Notes: This optimizer is only applicable to full-batch training. Optimizer of the Rprop algorithm.Please refer to this for details: A direct adaptive method for faster backpropagation learning : The RPROP algorithm.

\begin{split}\begin{aligned} &\hspace{0mm} For\ all\ weights\ and\ biases\{ \\ &\hspace{5mm} \textbf{if} \: (\frac{\partial E}{\partial w_{ij}}(t-1)*\frac{\partial E}{\partial w_{ij}}(t)> 0)\ \textbf{then} \: \{ \\ &\hspace{10mm} learning\_rate_{ij}(t)=\mathrm{minimum}(learning\_rate_{ij}(t-1)*\eta^{+},learning\_rate_{max}) \\ &\hspace{10mm} \Delta w_{ij}(t)=-sign(\frac{\partial E}{\partial w_{ij}}(t))*learning\_rate_{ij}(t) \\ &\hspace{10mm} w_{ij}(t+1)=w_{ij}(t)+\Delta w_{ij}(t) \\ &\hspace{5mm} \} \\ &\hspace{5mm} \textbf{else if} \: (\frac{\partial E}{\partial w_{ij}}(t-1)*\frac{\partial E}{\partial w_{ij}}(t)< 0)\ \textbf{then} \: \{ \\ &\hspace{10mm} learning\_rate_{ij}(t)=\mathrm{maximum}(learning\_rate_{ij}(t-1)*\eta^{-},learning\_rate_{min}) \\ &\hspace{10mm} w_{ij}(t+1)=w_{ij}(t) \\ &\hspace{10mm} \frac{\partial E}{\partial w_{ij}}(t)=0 \\ &\hspace{5mm} \} \\ &\hspace{5mm} \textbf{else if} \: (\frac{\partial E}{\partial w_{ij}}(t-1)*\frac{\partial E}{\partial w_{ij}}(t)= 0)\ \textbf{then} \: \{ \\ &\hspace{10mm} \Delta w_{ij}(t)=-sign(\frac{\partial E}{\partial w_{ij}}(t))*learning\_rate_{ij}(t) \\ &\hspace{10mm} w_{ij}(t+1)=w_{ij}(t)+\Delta w_{ij}(t) \\ &\hspace{5mm} \} \\ &\hspace{0mm} \} \\ \end{aligned}\end{split}
Parameters
• learning_rate (float|Tensor|LearningRateDecay, optional) – The initial learning rate used to update Parameter. It can be a float value, a Tensor with a float type or a LearningRateDecay. The default value is 0.001.

• learning_rate_range (tuple, optional) – The range of learning rate. Learning rate cannot be smaller than the first element of the tuple; learning rate cannot be larger than the second element of the tuple. The default value is (1e-5, 50).

• parameters (list|tuple, optional) – List/Tuple of Tensor to update to minimize loss. This parameter is required in dygraph mode. The default value is None in static graph mode, at this time all parameters will be updated.

• etas (tuple, optional) – Tuple used to update learning rate. The first element of the tuple is the multiplicative decrease factor; the second element of the tuple is the multiplicative increase factor. The default value is (0.5, 1.2).

• grad_clip (GradientClipBase, optional) – Gradient clipping strategy, it’s an instance of some derived class of GradientClipBase . There are three clipping strategies ( ClipGradByGlobalNorm , ClipGradByNorm , ClipGradByValue ). Default None, meaning there is no gradient clipping.

• multi_precision (bool, optional) – In mixed precision training scenarios based on GPU, this parameter is mainly used to ensure the numerical stability of gradient updates. When it is set to True, the optimizer will save a backup of FP32 type parameters with an equal value for FP16 type parameters. When updating gradients, first increase the gradient type to FP32, and then assign it to the FP32 type parameter backup. Finally, the updated FP32 type value will be converted to FP16 type first, and then assigned to the actual FP16 type parameters participating in the calculation. The default value is False.

• name (str, optional) – The default value is None. Normally there is no need for user to set this property. For more information, please refer to Name .

Examples

>>> import paddle

>>> inp = paddle.uniform(min=-0.1, max=0.1, shape=[1, 100], dtype='float32')
>>> out = linear(inp)
>>> rprop = paddle.optimizer.Rprop(learning_rate=0.001, learning_rate_range=(0.0001,0.1), parameters=linear.parameters(), etas=(0.5,1.2))
>>> out.backward()
>>> rprop.step()


Create and add backward regularization Operators

Creates and adds backward regularization operators in the BlockDesc. This will add gradients of the regularizer function to the gradients of the parameters and return these modified gradients. This is the same as implementing weight decay in optimizers for regularization.

Parameters
• parameters_and_grads – A list of (parameters, gradients) pairs that need to be regularized.

• regularization – A global regularizer. If the parameter is not set. It will be applied with regularizer.

Returns

Return type

list[(Variable, Variable)]

Raises

Exception – Unknown regularization type

Clear the gradients of all optimized parameters for model.

Parameters

set_to_zero (bool, optional) – If set grads to zero or not, default is True.

Returns

None

Examples

>>> import paddle

>>> a = paddle.arange(26, dtype="float32").reshape([2, 13])
>>> # This can be any optimizer supported by dygraph.
...                             parameters = linear.parameters())
>>> out = linear(a)
>>> out.backward()

get_lr ( )

Get current learning rate of optimizer. If ‘LRScheduler’ is not used, the return value is all the same. If ‘LRScheduler’ is used, the return value is the current scheduled learing rete.

Returns

The current learning rate of optimizer.

Return type

float

Examples

>>> # train on default dynamic graph mode
>>> import numpy as np

>>> ## example1: LRScheduler is not used, return the same value is all the same
>>> for batch in range(10):
...     input = paddle.randint(low=0, high=5, shape=[5])
...     out = emb(input)
...     out.backward()
...     print("Learning rate of step{}: {}".format(batch, adam.get_lr())) # 0.01
Learning rate of step0: 0.01
Learning rate of step1: 0.01
Learning rate of step2: 0.01
Learning rate of step3: 0.01
Learning rate of step4: 0.01
Learning rate of step5: 0.01
Learning rate of step6: 0.01
Learning rate of step7: 0.01
Learning rate of step8: 0.01
Learning rate of step9: 0.01

>>> ## example2: StepDecay is used, return the scheduled learning rate
>>> scheduler = paddle.optimizer.lr.StepDecay(learning_rate=0.5, step_size=2, gamma=0.1)
>>> for batch in range(10):
...     input = paddle.randint(low=0, high=5, shape=[5])
...     out = emb(input)
...     out.backward()
...     print("Learning rate of step{}: {}".format(batch, adam.get_lr())) # 0.5->0.05...
...     scheduler.step()
Learning rate of step0: 0.5
Learning rate of step1: 0.5
Learning rate of step2: 0.05
Learning rate of step3: 0.05
Learning rate of step4: 0.005000000000000001
Learning rate of step5: 0.005000000000000001
Learning rate of step6: 0.0005000000000000001
Learning rate of step7: 0.0005000000000000001
Learning rate of step8: 5.000000000000001e-05
Learning rate of step9: 5.000000000000001e-05

>>> # train on static graph mode
...     x = paddle.static.data(name='x', shape=[None, 10])
...     scheduler = paddle.optimizer.lr.StepDecay(learning_rate=0.5, step_size=2, gamma=0.1)

>>> exe.run(start_prog)
>>> for batch in range(10):
...     print("Learning rate of step{}: {}".format(batch, adam.get_lr())) # 0.5->0.05->0.005...
...     out = exe.run(main_prog, feed={'x': np.random.randn(3, 10).astype('float32')})
...     scheduler.step()
Learning rate of step0: 0.5
Learning rate of step1: 0.5
Learning rate of step2: 0.05
Learning rate of step3: 0.05
Learning rate of step4: 0.005000000000000001
Learning rate of step5: 0.005000000000000001
Learning rate of step6: 0.0005000000000000001
Learning rate of step7: 0.0005000000000000001
Learning rate of step8: 5.000000000000001e-05
Learning rate of step9: 5.000000000000001e-05

minimize ( loss, startup_program=None, parameters=None, no_grad_set=None )

Add operations to minimize loss by updating parameters.

Parameters
• loss (Tensor) – A Tensor containing the value to minimize.

• startup_program (Program, optional) – Program for initializing parameters in parameters. The default value is None, at this time default_startup_program will be used.

• parameters (list, optional) – List of Tensor or Tensor.name to update to minimize loss. The default value is None, at this time all parameters will be updated.

• no_grad_set (set, optional) – Set of Tensor or Tensor.name that don’t need to be updated. The default value is None.

Returns

tuple (optimize_ops, params_grads), A list of operators appended by minimize and a list of (param, grad) tensor pairs, param is Parameter, grad is the gradient value corresponding to the parameter. In static graph mode, the returned tuple can be passed to fetch_list in Executor.run() to indicate program pruning. If so, the program will be pruned by feed and fetch_list before run, see details in Executor.

Return type

tuple

Examples

>>> import paddle
>>> input = paddle.uniform(shape=[10, 10], min=-0.1, max=0.1)
>>> out = linear(input)

...         parameters=linear.parameters(),
...         weight_decay=0.01)
>>> loss.backward()

set_lr ( value )
Api_attr

imperative

Set the value of the learning rate manually in the optimizer. If the optimizer use LRScheduler, this API cannot be invoked, because it will lead to conflict.

Parameters

value (float) – the value of learning rate

Returns

None

Examples

>>> import paddle

>>> # set learning rate manually by python float value
>>> lr_list = [0.2, 0.3, 0.4, 0.5, 0.6]
>>> for i in range(5):
...     print("current lr is {}".format(lr))
current lr is 0.2
current lr is 0.3
current lr is 0.4
current lr is 0.5
current lr is 0.6

set_lr_scheduler ( scheduler )
Api_attr

imperative

Set the LRScheduler of the learning rate manually in the optimizer. If the optimizer already used LRScheduler previously, this API will set it be the new one.

Parameters

scheduler (LRScheduler) – the LRScheduler of learning rate

Returns

None

Examples

>>> import paddle

>>> # set learning rate manually by class LRScheduler
>>> scheduler = paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[2,4,6], gamma=0.8)
>>> print("current lr is {}".format(lr))
current lr is 0.5

>>> # set learning rate manually by another LRScheduler
>>> scheduler = paddle.optimizer.lr.StepDecay(learning_rate=0.1, step_size=5, gamma=0.6)
>>> print("current lr is {}".format(lr))
current lr is 0.1

set_state_dict ( state_dict )

Load optimizer state dict. For Adam optimizer, contains beta1, beta2, momentum etc. If LRScheduler have been used, global_step will be changed.

Parameters

state_dict (dict) – Dict contains all the Tensor needed by optimizer

Returns

None

Examples

>>> import paddle

>>> layer_state_dict = emb.state_dict()

...     d_model=0.01, warmup_steps=100, verbose=True)
...     learning_rate=scheduler,
...     parameters=emb.parameters())


state_dict ( )

Get state dict information from optimizer. It contain all the tensor used by optimizer. For Adam optimizer, contains beta1, beta2, momentum etc. If LRScheduler have been used, global_step will be include in state dict. If the optimizer never be called(minimize function), the state_dict is empty.

Parameters

None

Returns

dict contains all the Tensor used by optimizer

Return type

state_dict(dict)

Examples

>>> import paddle


step ( )

Execute the optimizer and update parameters once.

Returns

None

Examples

>>> import paddle

>>> a = paddle.arange(26, dtype="float32").reshape([2, 13])