\;j1VddlZddlmZddlmZddlmZddlmZgZ Gdd eZ y) N)_C_ops) framework)in_dygraph_mode) OptimizercReZdZdZdZdZdZ d fd ZdZdZ dZ xZ 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 parameter groups represents the scale of base learning_rate. The default value is None in static graph mode, at this time all parameters will be updated. weight_decay (float|WeightDecayRegularizer, optional): The strategy of regularization. It can be a float value as coeff of L2 regularization or \ :ref:`api_paddle_regularizer_L1Decay`, :ref:`api_paddle_regularizer_L2Decay`. If a parameter has set regularizer using :ref:`api_paddle_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 clipping strategy, it's an instance of some derived class of ``GradientClipBase`` . There are three clipping strategies ( :ref:`api_paddle_nn_ClipGradByGlobalNorm` , :ref:`api_paddle_nn_ClipGradByNorm` , :ref:`api_paddle_nn_ClipGradByValue` ). 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() momentum mean_square mean_gradc p| td| td| td| tdd|ks tdd|ks tdd|ks tdt | ||||| d |_||_||_||_||_d |_i|_ ||||d |_ y) Nzlearning_rate is not set.zrho is not set.zepsilon is not set.zmomentum is not set.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_clipnamermspropF)rhoepsilonr centered) ValueErrorsuper__init__type_rho_epsilon _momentum _centered_multi_precision_master_weights _default_dict) selfrrrr rrrrr __class__s aG:\00. PROJECTS\API\Inventory\templateJSON\kerjaOCR\Lib\site-packages\paddle/optimizer/rmsprop.pyrzRMSProp.__init__s  89 9 ;./ / ?23 3  34 4g~MN NhOP PczEF F '!%     !! %!   ct|tjs tdt|tr|j d}|D]}|j |jvr|jr|j|jr|j|}|j|j||j|j||j|j||jj!|j |j|jr!|jst#j$d|j|j||j|j||j|j||jj!|j y)N)block is not instance of framework.Block.paramszAccumulating with FP16 in optimizer can lead to poor accuracy or slow convergence.Consider using multi_precision=True option of the Lars optimizer.) isinstancerBlock TypeErrordictgetr_already_create_accumulaterr!_is_dtype_fp16_or_bf16dtype_create_master_weight_add_accumulator_momentum_acc_str_mean_square_acc_str_mean_grad_acc_straddwarningswarn)r$blockrpmaster_ps r&_create_accumulatorszRMSProp._create_accumulatorssc%1GH H j$ '#1JAvv999$$)D)DQWW)M55a8%%d&<&rFNNNN) __name__ __module__ __qualname____doc__r5r6r7rr>r]rQ __classcell__)r%s@r&r r sOun#($  / b9>JX r'r ) r9paddlerbaserbase.frameworkr optimizerr__all__r r'r&rjs), bibr'