Pytorch_Autograd

Autograd：自动求导机制

Pytorch的核心是autograd包。autograd包为张量上的所有操作提供了自动求导，他是一个运行时定义的框架，意味着反向传播是根据代码来确定如何运行，并且每次迭代可以不同

张量(Tensor)

torch.Tensor这个包是核心类，如果设置.requires_grad为True，那么将会追踪所有对于该张量的操作。完成计算后调用.backward，自动计算所有梯度，这个张量的所有地图会自动更新到.grad属性
要阻止张量跟踪历史记录，可以调用.detach方法将其与计算历史记录分离，并禁止跟踪其将来的计算记录
为防止跟踪记录历史（和使用内存），可以将代码包装在with torch.no_grad()：中。

import torch
x = torch.ones(2, 2, requires_grad=True)
x

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

# 对张量进行操作
y = x + 2
y

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

# grad_fn已经自动生成
print(y.grad_fn)

<AddBackward0 object at 0x000001C9019DDAC8>

# 对y进行操作
z = y * y * 3
out = z.mean()
print(z, out)

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

# .requires_grad() 可以改变现有张量的requires_grad属性。默认为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 0x000001C9019ECA08>

梯度

反向传播 因为out是一个纯量(scalar), out.backward()等于out.backward(torch.tensor(1))

out.backward()

print(x.grad)

tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

x = torch.randn(3, requires_grad=True)

y = x * 2
while y.data.norm() < 100:
    y = y * 2
print(y)    

tensor([-23.7332,  42.4670, -88.6353], grad_fn=<MulBackward0>)

gradients = torch.tensor([0.1, 1.0, 0.001], dtype=torch.float)
y.backward(gradients)
print(x.grad)

tensor([ 12.8000, 128.0000,   0.1280])

print(x.requires_grad)
print((x**2).requires_grad)

with torch.no_grad():
    print((x**2).requires_grad)

True
True
False