转自：Pytorch中文网
接触了PyTorch这么长的时间，也玩了很多PyTorch的骚操作，都特别简单直观地实现了，但是有一个网络训练过程中的操作之前一直没有仔细去考虑过，那就是
loss.backward()
，看到这个大家一定都很熟悉，loss是网络的损失函数，是一个标量，你可能会说这不就是反向传播吗，有什么好讲的。
但是不知道大家思考过没有，如果loss不是一个标量，而是一个向量，那么
loss.backward()
是什么结果呢？
大家可以去试试，写一个简单的小程序
| 1 2 3 4 5 | import torch as t from torch.autograd import Variable as v x = v(t.ones(2, 2), requires_grad=True) y = x 1 y.backward() |
运行一下程序，恭喜你报错了，错误显示如下
我们来读一读这个错误是什么意思。backward只能被应用在一个标量上，也就是一个一维tensor，或者传入跟变量相关的梯度。
嗯，前面一句话很简单，backward应用在一个标量，平时我们也是这么使用的，但是后面一句话，with gradient w.r.t variable是什么鬼，传入一个变量相关的梯度。不理解啊不理解，看不懂没关系我们还可以做实验来解决这个问题，俗话说自己动手丰衣足食（我也想做个伸手党去看看别人写的，然后不幸地是并没有什么人写过这方面的东西）。
首先我们开始做一个简单的实验，就是复习一下标量的形式
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | # simple gradient a = v(t.FloatTensor([2, 3]), requires_grad=True) b = a 3 c = b * b * 3 out = c.mean() out.backward() print(\'*\'*10) print(\'=====simple gradient======\') print(\'input\') print(a.data) print(\'compute result is\') print(out.data[0]) print(\'input gradients are\') print(a.grad.data) |
很简单，我们把数学表达式写出来，传入的参数x1=2,x2=3
x1=2,x2=3
，特别注意
Variable
里面默认的参数
requires_grad=False
，所以这里我们要重新传入
requires_grad=True
让它成为一个叶子节点。
那么我们对其求偏导也很简单（分别为15,18） 这样依靠简单的微积分知识我们就能够算出他们的结果，运行一下程序，确保结果一致，ok。
下面我们研究一下如何能够对非标量的情况下使用backward，下面开始做实验（瞎试）。
| 1 2 3 4 | m = v(t.FloatTensor([[2, 3]]), requires_grad=True) n = v(t.zeros(1, 2)) n[0, 0] = m[0, 0] ** 2 n[0, 1] = m[0, 1] ** 3 |
第一想法就是里面这个参数是要求梯度的对象，我们这样调用
n.backward(m.data)
，有有报错诶，是不是成功了，我真的是个天才，这么难的东西都能想到，等等，我好想看到了一个很神奇的结果。
这是什么鬼，这跟说好的结果不一样啊，我们想要的结果是4和27,现在给我们的结果是8和81,为什么会出现这样神奇的结果呢，想不通啊。我们看看我们传入的参数是
m.data
，这是一个(2, 3)的向量，我们希望得到的梯度是(4, 27)，好像(4×2=8, 27×3=81)，我的内心毫无波动，甚至有点想笑，似乎backward将我传入的参数
m.data
乘上了得到的梯度，既然要乘上我传入的参数，那么我就给你传入1,这样总能得到我想要的结果了吧，
n.backward(t.FloatTensor([[1, 1]]))
，看看结果呢
哇，跟我们想要的结果一样诶，撒花，我们解决了一个大问题，就是这么简单，扔进去一个1就可以了，这个问题也没有那么难嘛，哈哈哈。
似乎又有一点不对，如果这么简单那么写PyTorch的人为什么不把这一步直接集成进去，那我们不就不会遇到这个问题了嘛。
我们来试试另外一种情况
| 1 2 3 4 5 6 | m = v(t.FloatTensor([[2, 3]]), requires_grad=True) j = t.zeros(2 ,2) k = v(t.zeros(1, 2)) m.grad.data.zero_() k[0, 0] = m[0, 0] ** 2 + 3 * m[0 ,1] k[0, 1] = m[0, 1] ** 2 + 2 * m[0, 0] |
么我们直接对k反向传播
k.backward(t.FloatTensor([[1, 1]])
，结果是什么呢？
首先我们手动算一算结果是什么:4,3,2,6，我们是希望能够得到上面四个结果，这个时候你可能已经开始怀疑了，能够得到这4个结果吗？我们可以输出结果来看看
非常遗憾，我们只得到了两个结果，并且数值并不对，这个时候你就会疑惑了，到底是哪里出了问题呢，为什么会得到这样的结果呢？
经过不断地尝试，我终于发现了其中的奥秘，
k.backward(parameters)
接受的参数
parameters
必须要和
k
的大小一模一样，然后作为
k
的系数传回去，什么意思呢，我们通过上面的例子来解释这个问题你就知道了。
我们已经知道我们得到的k=(k1,k2)
k=(k1,k2)
，以及传入的参数是1和1，那么是如何得到这6和9这两个结果的呢？
我们知道了这个操作具体是怎么完成的，我们就可以求求我们需要的这个jacobian矩阵了，非常简单。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | # jacobian j = t.zeros(2 ,2) k = v(t.zeros(1, 2)) m.grad.data.zero_() k[0, 0] = m[0, 0] ** 2 + 3 * m[0 ,1] k[0, 1] = m[0, 1] ** 2 + 2 * m[0, 0] k.backward(t.FloatTensor([[1, 0]]), retain_variables=True) j[:, 0] = m.grad.data m.grad.data.zero_() k.backward(t.FloatTensor([[0, 1]])) j[:, 1] = m.grad.data print('jacobian matrix is') print(j) |
我们可以得到如下结果
这里我们要注意
backward()
里面另外的一个参数
retain_variables=True
，这个参数默认是False，也就是反向传播之后这个计算图的内存会被释放，这样就没办法进行第二次反向传播了，所以我们需要设置为True，因为这里我们需要进行两次反向传播求得jacobian矩阵。
最后我们再举一个矩阵乘法的例子试验一下我们的结果
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | x = t.FloatTensor([2, 1]).view(1, 2) x = v(x, requires_grad=True) y = v(t.FloatTensor([[1, 2], [3, 4]])) z = t.mm(x, y) jacobian = t.zeros((2, 2)) z.backward(t.FloatTensor([[1, 0]]), retain_variables=True) # dz1/dx1, dz2/dx1 jacobian[:, 0] = x.grad.data x.grad.data.zero_() z.backward(t.FloatTensor([[0, 1]])) # dz1/dx2, dz2/dx2 jacobian[:, 1] = x.grad.data print('=========jacobian========') print('x') print(x.data) print('y') print(y.data) print('compute result') print(z.data) print('jacobian matrix is') print(jacobian) |
上面是代码，仔细阅读，作为一个小练习回顾一下本篇文章讲的内容，妈妈再也不用担心我不会用
backward
了。