Pytorch: ऑप्टिमाइज़ में प्रयुक्त गति सूत्रीकरण के बारे में दस्तावेज़ों में एक नोट जोड़ें

मैं PyTorch में SGD + Momentum के कार्यान्वयन को देख रहा था और अन्य पैकेजों (और कागजात) द्वारा इसका वर्णन करने के तरीके से कुछ अलग देखा। फिलहाल, आइए केवल (शास्त्रीय) गति पर ध्यान दें, न कि नेस्टरोव के संस्करण पर।

लेखन के समय, कार्यान्वयन पढ़ता है:

```
यदि संवेग != 0:
परम_राज्य = स्वराज्य [पी]
अगर 'मोमेंटम_बफर' param_state में नहीं है:
buf = param_state ['मोमेंटम_बफ़र'] = d_p.clone ()
अन्यथा:
बफ = परम_स्टेट ['मोमेंटम_बफर']
buf.mul_(गति)। जोड़ें_(1 - भीगना, d_p)
अगर नेस्टरोव:
d_p = d_p.add (गति, buf)
अन्यथा:
d_p = बफ

            p.data.add_(-group['lr'], d_p)

Mathematically, if we denote the momentum buffer by `v` and assume that `dampening=0`, at every iteration, the buffer is updated as `v = m*v + g` and the step is `∆x = lr * v`. Notice that the learning rate `lr` hits the momentum term `v` as well as the gradient. To me, this is different from what classical momentum is, and also differs from how other packages implement SGD+M.

Let us contrast this with the Sutskever et. al. paper and other commonly used pacakges such as Lasagne, Keras, Neon, etc.

## [Sutskever et. al.](http://www.jmlr.org/proceedings/papers/v28/sutskever13.pdf)
The snippet of the relevant section is pasted below. 
![Sutskever et. al.](http://i.imgur.com/QJelodE.png)

Retaining the syntax from above, the algorithm updates `v` as `v = m*v - lr * g` with the step `∆x = v`. So, the learning rate `lr` only hits the gradient. It does not (explicitly) influence the effect of the momentum term which is in contrast with PyTorch's implementation. 

# [Lasagne](https://github.com/Lasagne/Lasagne/blob/master/lasagne/updates.py#L217)

Lasagne employs the same rule as suggested in Sutskever for momentum. 

for param in params:
    value = param.get_value(borrow=True)
    velocity = theano.shared(np.zeros(value.shape, dtype=value.dtype),
                             broadcastable=param.broadcastable)
    x = momentum * velocity + updates[param]
    updates[velocity] = x - param

# [Keras](https://github.com/fchollet/keras/blob/master/keras/optimizers.py#L141)

Same for Keras:

   for p, g, m in zip(params, grads, moments):
        v = self.momentum * m - lr * g  # velocity
        self.updates.append(K.update(m, v))

        if self.nesterov:
            new_p = p + self.momentum * v - lr * g
        else:
            new_p = p + v

# [Neon](https://github.com/NervanaSystems/neon/blob/master/neon/optimizers/optimizer.py#L520)

and Neon.

            velocity[:] = self.momentum_coef * velocity - lrate * grad

            # Nesterov accelerated gradient (NAG) is implemented the same
            # as in torch's "sgd.lua". It's a reformulation of Sutskever's
            # NAG equation found in "On the importance of initialization
            # and momentum in deep learning".
            if self.nesterov:
                param[:] = param + self.momentum_coef * velocity -\
                           lrate * grad
            else:
                param[:] = param + velocity

```
क्या असमानता सच है या क्या मुझे कुछ महत्वपूर्ण याद आ रहा है?

दो कार्यान्वयनों के बीच का अंतर महत्वहीन नहीं है और विशेष रूप से तब जब lr रास्ते में कम हो जाता है। अगर मेरा दावा सही है, तो शायद हम संदर्भ को अपडेट कर सकते हैं (मुझे यकीन नहीं है कि वह क्या होगा) या उपरोक्त संस्करण को एसजीडी कोड में शामिल कर सकते हैं (यदि आवश्यक हो तो मैं इसे ले सकता हूं)?