mindspore2022/docs/api/api_python/nn/mindspore.nn.Adagrad.rst

mindspore.nn.Adagrad
=====================

.. py:class:: mindspore.nn.Adagrad(*args, **kwargs)

    ʹ��ApplyAdagrad����ʵ��Adagrad�㷨��

    Adagrad��������ѧϰ������Ż���
    ���������`Efficient Learning using Forward-Backward Splitting <https://proceedings.neurips.cc/paper/2009/file/621bf66ddb7c962aa0d22ac97d69b793-Paper.pdf>`_��
    ��ʽ���£�

    .. math::
        \begin{array}{ll} \\
            h_{t+1} = h_{t} + g\\
            w_{t+1} = w_{t} - lr*\frac{1}{\sqrt{h_{t+1}}}*g
        \end{array}

    :math:`h` ��ʾ�ݶ�ƽ�����ۻ��ͣ�:math:`g` ��ʾ `grads` ��
    :math:`lr` ���� `learning_rate`��:math:`w` ���� `params` ��

    .. note::
        �ڲ���δ����ʱ���Ż������õ� `weight_decay` Ӧ�������ƺ���"beta"��"gamma"�����������ͨ�������������ɵ���Ȩ��˥�����ԡ�����ʱ��ÿ����������������� `weight_decay` ����δ���ã�������������ʹ���Ż��������õ� `weight_decay` ��

    **������**

    - **params** (Union[list[Parameter], list[dict]]) - ������ `Parameter` ��ɵ��б����ֵ���ɵ��б������б�Ԫ�����ֵ�ʱ���ֵ�ļ�������"params"��"lr"��"weight_decay"��"grad_centralization"��"order_params"��

      - **params** - �����ǰ����Ȩ�أ���ֵ������ `Parameter` �б���
      - **lr** - ��ѡ��������д���"lr"����ʹ�ö�Ӧ��ֵ��Ϊѧϰ�ʡ����û�У���ʹ���Ż��������õ� `learning_rate` ��Ϊѧϰ�ʡ�
      - **weight_decay** - ��ѡ��������д���"weight_decay"����ʹ�ö�Ӧ��ֵ��ΪȨ��˥��ֵ�����û�У���ʹ���Ż��������õ� `weight_decay` ��ΪȨ��˥��ֵ��
      - **grad_centralization** - ��ѡ��������д���"grad_centralization"����ʹ�ö�Ӧ��ֵ����ֵ����Ϊ�������͡����û�У�����Ϊ `grad_centralization` ΪFalse���ò����������ھ����㡣
      - **order_params** - ��ѡ����Ӧֵ��Ԥ�ڵIJ�������˳�򡣵�ʹ�ò������鹦��ʱ��ͨ��ʹ�ø�������� `parameters` ��˳�����������ܡ�������д���"order_params"�������Ը��������е���������"order_params"�еIJ���������ijһ�� `params` �����С�
    
    - **accum** (float) - �ۼ��� :math:`h` �ij�ʼֵ��������ڵ����㡣Ĭ��ֵ��0.1��
    - **learning_rate** (Union[float, Tensor, Iterable, LearningRateSchedule]) - Ĭ��ֵ��0.001��

       - **float** - �̶���ѧϰ�ʡ�������ڵ����㡣
       - **int** - �̶���ѧϰ�ʡ�������ڵ����㡣�������ͻᱻת��Ϊ��������
       - **Tensor** - �����DZ�����һά�����������ǹ̶���ѧϰ�ʡ�һά�����Ƕ�̬��ѧϰ�ʣ���i����ȡ�����е�i��ֵ��Ϊѧϰ�ʡ�
       - **Iterable** - ��̬��ѧϰ�ʡ���i����ȡ��������i��ֵ��Ϊѧϰ�ʡ�
       - **LearningRateSchedule** - ��̬��ѧϰ�ʡ���ѵ�������У��Ż�����ʹ�ò�����step����Ϊ���룬���� `LearningRateSchedule` ʵ�������㵱ǰѧϰ�ʡ�
    
    - **update_slots** (bool) - ���ΪTrue��������ۼ��� :math:`h` ��Ĭ��ֵ��True��
    - **loss_scale** (float) - �ݶ�����ϵ�����������0�����`loss_scale`��������������ת��Ϊ��������ͨ��ʹ��Ĭ��ֵ������ѵ��ʱʹ���� `FixedLossScaleManager` ���� `FixedLossScaleManager` �� `drop_overflow_update` ��������ΪFalseʱ����ֵ��Ҫ�� `FixedLossScaleManager` �е� `loss_scale` ��ͬ���йظ�����ϸ��Ϣ�������class��`mindspore.FixedLossScaleManager` ��Ĭ��ֵ��1.0��
    - **weight_decay** (Union[float, int]) - Ҫ����Ȩ�ص�Ȩ��˥��ֵ��������ڵ���0.0��Ĭ��ֵ��0.0��

    **���룺**

    **grads** (tuple[Tensor]) - �Ż����� `params` ���ݶȣ���״��shape���� `params` ��ͬ��

    **�����**

    Tensor[bool]��ֵΪTrue��

    **�쳣��**

    - **TypeError** - `learning_rate` ����int��float��Tensor��Iterable�� `LearningRateSchedule` ��
    - **TypeError** - `parameters` ��Ԫ���� `Parameter` ���ֵ䡣
    - **TypeError** - `accum` �� `loss_scale` ����float��
    - **TypeError** - `update_slots` ����bool��
    - **TypeError** - `weight_decay` ����float��int��
    - **ValueError** - `loss_scale` С�ڻ����0��
    - **ValueError** - `accum` �� `weight_decay` ��0��

    **֧��ƽ̨��**

    ``Ascend``  ``CPU``  ``GPU``

    **������**

    >>> net = Net()
    >>> #1) ���в���ʹ����ͬ��ѧϰ�ʺ�Ȩ��˥��
    >>> optim = nn.Adagrad(params=net.trainable_params())
    >>>
    >>> #2) ʹ�ò����鲢���ò�ͬ��ֵ
    >>> conv_params = list(filter(lambda x: 'conv' in x.name, net.trainable_params()))
    >>> no_conv_params = list(filter(lambda x: 'conv' not in x.name, net.trainable_params()))
    >>> group_params = [{'params': conv_params, 'weight_decay': 0.01, 'grad_centralization':True},
    ...                 {'params': no_conv_params, 'lr': 0.01},
    ...                 {'order_params': net.trainable_params()}]
    >>> optim = nn.Adagrad(group_params, learning_rate=0.1, weight_decay=0.0)
    >>> # conv_params�����齫ʹ���Ż����е�ѧϰ��0.1�������Ȩ��˥��0.01��������ݶ����Ļ�����True��
    >>> # no_conv_params�����齫ʹ�ø����ѧϰ��0.01���Ż����е�Ȩ��˥��0.0���ݶ����Ļ�ʹ��Ĭ��ֵFalse��
    >>> # �Ż�������"order_params"���õIJ���˳����²�����
    >>>
    >>> loss = nn.SoftmaxCrossEntropyWithLogits()
    >>> model = Model(net, loss_fn=loss, optimizer=optim)