o Qe(@sHddlmZddlmZddlmZddlmZgZGdddeZdS) ) Optimizer)core) framework)VariablecsVeZdZdZdZdZdZ     dfd d Zd d ZddZ ddZ Z S)RMSPropa Root Mean Squared Propagation (RMSProp) is an unpublished, adaptive learning rate method. The original slides proposed RMSProp: Slide 29 of http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf . The original equation is as follows: .. math:: r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2 w & = w - \frac{\eta} {\sqrt{r(w,t) + \epsilon}} \nabla Q_{i}(w) The first equation calculates moving average of the squared gradient for each weight. Then dividing the gradient by :math:`sqrt{v(w,t)}`. In some cases, adding a momentum term :math: `\\beta` is beneficial. In our implementation, Nesterov momentum is used: .. math:: r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2 v(w, t) & = \beta v(w, t-1) + \frac{\eta} {\sqrt{r(w,t) + \epsilon}} \nabla Q_{i}(w) w & = w - v(w, t) if centered is True: .. math:: r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2 g(w, t) & = \rho g(w, t-1) + (1 - \rho)\nabla Q_{i}(w) v(w, t) & = \beta v(w, t-1) + \frac{\eta} {\sqrt{r(w,t) - (g(w, t))^2 + \epsilon}} \nabla Q_{i}(w) w & = w - v(w, t) where, :math:`\rho` is a hyperparameter and typical values are 0.9, 0.95 and so on. :math:`\beta` is the momentum term. :math:`\epsilon` is a smoothing term to avoid division by zero, usually set somewhere in range from 1e-4 to 1e-8. Parameters: learning_rate (float|LRScheduler): The learning rate used to update ``Parameter``. It can be a float value or a LRScheduler. rho(float, optional): rho is :math:`\rho` in equation, default is 0.95. epsilon(float, optional): :math:`\epsilon` in equation is smoothing term to avoid division by zero, default is 1e-6. momentum(float, optional): :math:`\beta` in equation is the momentum term, default is 0.0. centered(bool, optional): If True, gradients are normalized by the estimated variance of the gradient; if False, by the uncentered second moment. Setting this to True may help with training, but is slightly more expensive in terms of computation and memory. Defaults to False. parameters (list|tuple, optional): List/Tuple of ``Tensor`` to update to minimize ``loss``. This parameter is required in dygraph mode. And you can specify different options for different parameter groups such as the learning rate, weight decay, etc, then the parameters are list of dict. Note that the learning_rate in paramter groups represents the scale of base learning_rate. The default value is None in static mode, at this time all parameters will be updated. weight_decay (float|WeightDecayRegularizer, optional): The strategy of regularization. It canbe a float value as coeff of L2 regularization or \ :ref:`api_fluid_regularizer_L1Decay`, :ref:`api_fluid_regularizer_L2Decay`. If a parameter has set regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. Default None, meaning there is no regularization. grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of some derived class of ``GradientClipBase`` . There are three cliping strategies ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` , :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping. name (str, optional): This parameter is used by developers to print debugging information. For details, please refer to :ref:`api_guide_Name`. Default is None. Examples: .. code-block:: python import paddle inp = paddle.rand([10,10], dtype="float32") linear = paddle.nn.Linear(10, 10) out = linear(inp) loss = paddle.mean(out) rmsprop = paddle.optimizer.RMSProp(learning_rate=0.1, parameters=linear.parameters(), weight_decay=0.01) out.backward() rmsprop.step() rmsprop.clear_grad() #Note that the learning_rate of linear_2 is 0.01. linear_1 = paddle.nn.Linear(10, 10) linear_2 = paddle.nn.Linear(10, 10) inp = paddle.uniform(shape=[10, 10], min=-0.1, max=0.1) out = linear_1(inp) out = linear_2(out) loss = paddle.mean(out) rmsprop = paddle.optimizer.RMSProp( learning_rate=0.1, parameters=[{ 'params': linear_1.parameters() }, { 'params': linear_2.parameters(), 'weight_decay': 0.001, 'learning_rate': 0.1 }], weight_decay=0.01) out.backward() rmsprop.step() rmsprop.clear_grad() momentumZ mean_squareZ mean_gradffffff?ư>FNc s|durtd|durtd|durtd|dur tdd|ks(tdd|ks0tdd|ks8tdtt|j||||| d d |_||_||_||_||_||||d |_ dS) Nzlearning_rate is not set.zrho is not set.zepsilon is not set.zmomentum is not set.r z.Invalid value of epsilon, expect epsilon >= 0.z0Invalid value of momentum, expect momentum >= 0.z&Invalid value of rho, expect rho >= 0.) learning_rate parameters weight_decay grad_clipnameZrmsprop)rhoepsilonrcentered) ValueErrorsuperr__init__type_rho_epsilon _momentum _centered _default_dict) selfr rrrrr rrr __class__HD:\Projects\ConvertPro\env\Lib\site-packages\paddle/optimizer/rmsprop.pyrs>   zRMSProp.__init__cCs`t|tjs tdt|tr|d}|D]}||j|||j|||j |qdS)N)block is not instance of framework.Block.params) isinstancerBlock TypeErrordictgetZ_add_accumulator_momentum_acc_str_mean_square_acc_str_mean_grad_acc_str)rblockr pr r r!_create_accumulatorss   zRMSProp._create_accumulatorsc Cst|tjs tdt|tr||}||j|d}||j|d}||j |d}|j |j |d|d|||| |d|d|||d|j |j|j|jddd}|S) Nr"r)ParamZGradZMomentZ MeanSquareZMeanGradZ LearningRate)ZParamOutZ MomentOutZ MeanSquareOutZ MeanGradOut)rZdecayrrT)rZinputsZoutputsattrsZ stop_gradient)r$rr%r&r'_update_param_groupZ_get_accumulatorr)r*r+Z append_oprZ_create_param_lrrrrr)rr,Zparam_and_gradZ momentum_accZmean_square_accZ mean_grad_accZ rmsprop_opr r r!_append_optimize_opsF       zRMSProp._append_optimize_opcCs^|d|jd|_|d|jd|_|d|jd|_|d|jd|_|d}|S)Nrrrrr#)r(rrrrr)rr r r r!r2s   zRMSProp._update_param_group)r r r FNNNN) __name__ __module__ __qualname____doc__r)r*r+rr.r3r2 __classcell__r r rr!rs"v/ +rN) Z optimizerrZfluidrrZfluid.frameworkr__all__rr r r r!s