Pytorch中的向前计算（autograd）、梯度计算以及实现线性回归操作

• 在整个Pytorch框架中, 所有的神经网络本质上都是一个autograd package(自动求导工具包)
  • autograd package提供了一个对Tensors上所有的操作进行自动微分的功能.

关于torch.Tensor

• torch.Tensor是整个package中的核心类, 如果将属性.requires_grad设置为True, 它将追踪在这个类上定义的所有操作. 当代码要进行反向传播的时候, 直接调用.backward()就可以自动计算所有的梯度. 在这个Tensor上的所有梯度将被累加进属性.grad中.
• 如果想终止一个Tensor在计算图中的追踪回溯, 只需要执行.detach()就可以将该Tensor从计算图中撤下, 在未来的回溯计算中也不会再计算该Tensor.
• 除了.detach(), 如果想终止对计算图的回溯, 也就是不再进行方向传播求导数的过程, 也可以采用代码块的方式with torch.no_grad():, 这种方式非常适用于对模型进行预测的时候, 因为预测阶段不再需要对梯度进行计算.

• 关于torch.Function:
  • Function类是和Tensor类同等重要的一个核心类, 它和Tensor共同构建了一个完整的类, 每一个Tensor拥有一个.grad_fn属性, 代表引用了哪个具体的Function创建了该Tensor.
  • 如果某个张量Tensor是用户自定义的, 则其对应的grad_fn is None.

1. 向前计算

        对于pytorch中的一个tensor，如果设置它的属性 .requires_grad为True，那么它将会追踪对于该张量的所有操作。或者可以理解为，这个tensor是一个参数，后续会被计算梯度，更新该参数。

1.1 计算过程

假设有以下条件（1/4表示求均值，xi中有4个数），使用torch完成其向前计算的过程

如果x为参数，需要对其进行梯度的计算和更新

那么，在最开始随机设置x的值的过程中，需要设置他的requires_grad属性为True，其默认值为False

import torch
x = torch.ones(2, 2, requires_grad=True)  # 初始化参数x并设置requires_grad=True用来追踪其计算历史
print(x)

运行结果：

import torch
x = torch.ones(2, 2, requires_grad=True)  # 初始化参数x并设置requires_grad=True用来追踪其计算历史
y = x + 2
print(y)

运行结果：

import torch
x = torch.ones(2, 2, requires_grad=True)  # 初始化参数x并设置requires_grad=True用来追踪其计算历史
y = x + 2
z = y * y * 3  #平方x3
print(z)

运行结果：

import torch
x = torch.ones(2, 2, requires_grad=True)  # 初始化参数x并设置requires_grad=True用来追踪其计算历史
y = x + 2
z = y * y * 3  # 平方x3
out = z.mean()  # 求均值
print(out)

运行结果：

从上述代码可以看出：

1. x的requires_grad属性为True

2. 之后的每次计算都会修改其grad_fn属性，用来记录做过的操作

   1. 通过这个函数和grad_fn能够组成一个和上一篇博客类似的计算图

1.2 requires_grad和grad_fn

import torch
a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)  # False
a.requires_grad_(True)  # 就地修改
print(a.requires_grad)  # True
b = (a * a).sum()
print(b.grad_fn)  # 
with torch.no_grad():  #  其中的操作不会被跟踪
    c = (a * a).sum()  # tensor(151.6830),此时c没有gard_fn

print(c.requires_grad)  # False

运行结果：

注意：

        为了防止跟踪历史记录（和使用内存），可以将代码块包装在with torch.no_grad():中。在评估模型时特别有用，因为模型可能具有requires_grad = True的可训练的参数，但是我们不需要在此过程中对他们进行梯度计算。

2. 梯度计算

对于1.1 中的out而言，我们可以使用backward方法来进行反向传播，计算梯度

out.backward(),此时便能够求出导数,调用x.gard能够获取导数值

得到

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

因为：

在等于1时其值为4.5

注意：在输出为一个标量的情况下，我们可以调用输出tensor的backword() 方法，但是在数据是一个向量的时候，调用backward()的时候还需要传入其他参数。

很多时候我们的损失函数都是一个标量，所以这里就不再介绍损失为向量的情况。

loss.backward()就是根据损失函数，对参数（requires_grad=True）去计算他的梯度，并且把它累加保存到x.gard，此时还并未更新其梯度

【获取梯度：x.grad，累加梯度， 所以：每次反向传播之前都要先把梯度置为0之后】

注意点：

1. tensor.data:

   • 在tensor的require_grad=False，tensor.data和tensor等价

   • require_grad=True时，tensor.data仅仅是获取tensor中的数据

2. tensor.numpy():

   • require_grad=True不能够直接转换，需要使用tensor.detach().numpy()  【tensor.detach().numpy()能够实现对tensor中的数据的深拷贝，转化为ndarray类型】

3. 线性回归实现

下面，使用一个自定义的数据，来使用torch实现一个简单的线性回归

        假设我们的基础模型就是y = wx+b，其中w和b均为参数，我们使用y = 3x+0.8来构造数据x、y，所以最后通过模型应该能够得出w和b应该分别接近3和0.8

1. 准备数据

2. 计算预测值

3. 计算损失，把参数的梯度置为0，进行反向传播

4. 更新参数

示例代码：

import torch
from matplotlib import pyplot as plt

#  1.准备数据y=3x+0.8 ,准备参数
x = torch.rand([50])
y = 3 * x + 0.8

w = torch.rand(1, requires_grad=True)
b = torch.rand(1, requires_grad=True)


def loss_fn(y, y_predict):
    loss = (y_predict - y).pow(2).mean()
    for i in [w, b]:
        #  每次反向传播前把梯度置为0
        if i.grad is not None:
            i.grad.data.zero_()
    loss.backward()
    return loss.data


def optimize(learning_rate):
    w.data -= learning_rate * w.grad.data
    b.data -= learning_rate * b.grad.data


for i in range(3000):
    #  2.计算预测值
    y_predict = x * w + b

    #  3.计算损失，把参数的梯度置为0，进行反向传播
    loss = loss_fn(y, y_predict)

    if i % 500 == 0:
        print(i, loss)

    #  4.更新参数w和b
    optimize(0.01)

#  绘制图形，观察训练结束的预测值和真实值
predict = x * w + b  # 使用训练后的w和b计算预测值

plt.scatter(x.data.numpy(), y.data.numpy(), c='r')
plt.plot(x.data.numpy(), predict.data.numpy())
plt.show()

print("w", w)
print("b", b)

运行结果：

图形效果如下：

可知，w和b已经非常接近原来的预设的3和0.8