Autograd：自动求导

import torch
# 创建张量并设置requires_grad=True来追踪其计算历史
x = torch.ones(2, 2, requires_grad=True)
print(x)

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)

y = x + 2
print(y)

tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)

print(y.grad_fn)

<AddBackward0 object at 0x0000000007BFC688>

z = y * y * 3
out = z.mean()
print(z, out)

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward1>)

Pytorch会自动追踪和记录对于张量的所有操作，当计算完成后调用.backward()方法自动计算梯度并且将计算结果保存到grad属性中。在张量进行操作后，grad_fn已经被赋予了一个新的函数，这个函数引用了一个创建了这个Tensor类的Function对象。

# .requires_grad_(...)可以改变现有张量的requires_grad属性，默认flag为False
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)

a.requires_grad_(True)
print(a.requires_grad)

b = (a * a).sum()
print(b.grad_fn)

False
True
<SumBackward0 object at 0x0000000007BEBFC8>

自动求导

x1 = torch.ones(2,2,requires_grad=True)
z1 = 3 * (x1 + 2) * (x1 + 2)
out = z1.mean()
# z1 = 3(x1+2)^2, out = mean(z1)
print("x1 = ", x1)
print("z1 = ", z1)
# out是一个标量(scalar)，out.backward()相当于out.backward(torch,tensor(1))
out.backward()
# x.grad 梯度d(out)/dx
print(x1.grad)
# 清零
x1.grad.data.zero_()

x1 =  tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
z1 =  tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>)
tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])





tensor([[0., 0.],
        [0., 0.]])

x = torch.eye(2, 2, requires_grad=True)
y = torch.ones(2, 2, requires_grad=True)
z = x ** 2 + y ** 3
print("z =", z)
# 由于返回值不是一个标量，因此需要输入一个大小相同的张量作为参数，
# 这里我们用ones_like函数根据x生成一个张量
gradient = torch.ones_like(x)
z.backward(gradient)
print("gradient =", gradient)
print("x.grad =", x.grad) # x.grad = (dz/dx) .* gradient 
print("y.grad =", y.grad) # y.grad = (dz/dy) .* gradient

z = tensor([[2., 1.],
        [1., 2.]], grad_fn=<AddBackward0>)
gradient = tensor([[1., 1.],
        [1., 1.]])
x.grad = tensor([[2., 0.],
        [0., 2.]])
y.grad = tensor([[3., 3.],
        [3., 3.]])

x = torch.randn(3, requires_grad=True)
y = x * 2
while y.data.norm() < 1000: # .data.norm() 张量L2范数
    y = y * 2
print("x =", x)
print("y =", y)
gradient = torch.tensor([1,0.1,0.01])
y.backward(gradient)
print("gradient =", gradient)
print("x.grad =", x.grad)

x = tensor([0.6344, 0.8409, 2.2294], requires_grad=True)
y = tensor([ 324.8004,  430.5210, 1141.4760], grad_fn=<MulBackward0>)
gradient = tensor([1.0000, 0.1000, 0.0100])
x.grad = tensor([512.0000,  51.2000,   5.1200])

print(x.requires_grad)
print((x ** 2).requires_grad)
# 将变量包裹在with torch.no_grad()中，可以暂时屏蔽autograd计算
with torch.no_grad():
    print((x ** 2).requires_grad)
print((x ** 2).requires_grad)

True
True
False
True

总结一下整个自动求导过程：

1.当我们执行z.backward()的时候。这个操作将调用z里面的grad_fn这个属性，执行求导的操作。
2.这个操作将遍历grad_fn的next_functions，然后分别取出里面的Function（AccumulateGrad），执行求导操作。这部分是一个递归的过程直到最后类型为叶子节点。
3.计算出结果以后，将结果保存到他们对应的variable 这个变量所引用的对象（x和y）的 grad这个属性里面。
4.求导结束。所有的叶节点的grad变量都得到了相应的更新

最终当我们执行完c.backward()之后，a和b里面的grad值就得到了更新。