计算图 Compute Graph 和自动求导 Autograd | PyTorch 深度学习实战

前一篇文章，Tensor 基本操作5 device 管理，使用 GPU 设备 | PyTorch 深度学习实战

本系列文章 GitHub Repo: https://github.com/hailiang-wang/pytorch-get-started

PyTorch 计算图和 Autograd

微积分之于机器学习
[Computational Graphs 计算图](#Computational Graphs 计算图)
[Autograd 自动求导](#Autograd 自动求导)
[一个训练过程及 no_grad 的使用](#一个训练过程及 no_grad 的使用)
更多计算图的知识
- 更为复杂点的计算图的样子
- 自动求导有关的参数
Links

微积分之于机器学习

机器学习的主要工作原理，就是万事万物存在规律，而我们使用机器来完成参数评估。参数评估的过程是随机梯度下降，也就是任意选择起点，然后使用微积分技术指导我们调优，找到一组最优参数值。

这就像我们爬山，面对众多的山峰，我们从不同的出发点出发，不断的朝着山顶前进，最终，我们即便起点不同，都可以达到山顶 - 通向山顶的路有多条。另外一方面，我们可能来到了不同的山顶。

在我们爬山的过程中，如何选择下一步呢？这时，就是微积分大显身手的时候了。

在机器学习中，对参数优化的过程，使用了大量微积分的运算，PyTorch 能成为通用性的机器学习框架，就在于不同的机器学习任务底层的数学原理是一致的，而 PyTorch 内置了这些标准化的数学运算，在 PyTorch 中，除了 Tensor 外，还有两个关键的概念：

计算图
自动求导

Computational Graphs 计算图

神经网络是由很多神经元组成的网络，最简单的神经网络就是只包含一个线性神经元的神经网络，理解这个最简单的神经网络，有助于理解任何复杂的神经网络。

z = x ∗ w + b z = x * w + b z=x∗w+b

注意：这里没有添加激活函数，这个神经元是一个简单的线性神经元。

计算过程：

加权输出 z 与理想输出 y 之间，使用交叉熵（CE）计算出损失（loss）
然后基于 loss 计算梯度 grad
基于梯度更新 w 和 b

这个计算过程，可以用一张图表达，一个图就是由节点以及边组成，边上定义操作符。同时，这个计算过程会在训练中发生多次，因为梯度下降算法是 SGD 迭代运算。

PyTorch 为了让每次运算可以更灵活，比如使用 Dropout 随机丢弃一些神经元，PyTorch 实现了每次运算动态的生成这张图 - 动态计算图^[1](#1)。也就是说，对于每次运算，PyTorch 会生成一个计算图并附着计算状态。

Autograd 自动求导

附着状态，最主要的目的就是实现自动求导。因为每个节点都是一个变量，变量和变量之间通过操作符相互依赖，而操作符和变量构成的函数式，就可以实现求导，根据链式法则，实现计算图中，每个变量的导数的计算。

在上图，只有一个线性神经元的情况下，PyTorch 的自动求导是如何工作的呢？参考下面的代码。

复制代码

import torch

# 定义输入和理想输出
x = torch.ones(5)   # input tensor
y = torch.zeros(3)  # expected output

# 定义参数
w = torch.randn(5, 3, requires_grad=True)
b = torch.randn(3, requires_grad=True)

# 定义模型，并进行一次运算
z = torch.matmul(x, w)+b

# 定义损失函数，并得到单次的损失
loss = torch.nn.functional.binary_cross_entropy_with_logits(z, y)

# 进行反向传播，并得到梯度
loss.backward()
print(w.grad)
print(b.grad)

如此一来，参数更新将变得非常简单。计算图允许每次迭代传入不同的操作符等，实现训练过程更灵活的配置。计算图保留了运算过程中的 Tensor、操作符、操作符对应的导函数。当 loss.backward() 调用时，顺序的调用自动求导变量的导函数，得到 .grad 梯度值。

一个训练过程及 no_grad 的使用

现在我们看一个例子，通过一个简单的模型，了解训练中，自动求导机制是如何工作的。

示例代码

复制代码

'''
autograd
'''
import plotly.graph_objects as go
import plotly.express as px
from torch import nn
import numpy as np
import torch
import math

# 输入变量 x，理想输出 yt（生成 y 的函数就是要拟合的模型） 
X  = torch.tensor(np.linspace(-10, 10, 1000))
y  = 1.5 * torch.sin(X) + 1.2 * torch.cos(X/4) # 真实的模型
yt = y + np.random.normal(0, 1, 1000)

# vis
def plotter(X, y, yhat=None, title=None):
    with torch.no_grad():
        fig = go.Figure()
        fig.add_trace(go.Scatter(x=X, y=y, mode='lines',    name='y'))
        fig.add_trace(go.Scatter(x=X, y=yt, mode='markers', marker=dict(size=4), name='yt'))
        if yhat is not None: fig.add_trace(go.Scatter(x=X, y=yhat, mode='lines', name='yhat'))
        fig.update_layout(template='none', title=title)
        fig.show()

plotter(X, y, title='Data Generating Process')

# 计算模型的实际输出，这里前提是假设知道变量 X 和函数 sin|cos, 而不知道参数 theta
def fit_model(theta:torch.tensor=torch.rand(3, requires_grad=True)):
    return theta[0] * X + theta[1] * torch.sin(X) + theta[2] * torch.cos(X/4)

# 随机初始化参数，开启自动求导
theta = torch.randn(3, requires_grad=True)

# 损失函数和优化器
loss_fn  = nn.MSELoss()                         # MSE loss
optimizer = torch.optim.SGD([theta], lr=0.01)   # build optimizer 

# 迭代训练
epochs = 500
for i in range(epochs):
    yhat = fit_model(theta)  # 计算实际输出
    loss = loss_fn(y, yhat)  # 将实际输出和理想输出传入损失函数，得到损失 loss
    loss.backward()          # 反向传播，完成 .grad 梯度的计算
    optimizer.step()         # 基于梯度完成参数更新 
    optimizer.zero_grad()    # 本轮计算完成，将梯度值归零，否则下次计算损失并调用 backward 导致梯度累计 
    if i % (epochs/10) == 0: # 验证及输出调试信息 
        msg = f"loss: {loss.item():>7f} theta: {theta.detach().numpy()}"
        yhat = fit_model(theta)
        plotter(X, y, yhat.detach(), title=f"loss: {loss.item():>7f} theta: {theta.detach().numpy().round(3)}")

执行结果

生成数据

创建了一个假数据：

分布在象限中的点就是 x，y
象限中的曲线，就是符合设想的模型，我们看最终的机器学习的模型，能否拟合这条曲线

第一轮后

初始化后，实际模型和理想模型差距很大。注意，此时 theta 和目标参数差距很大。

第二轮后

经过两次迭代，差距在缩小。

第十轮后

又经过了几轮训练，此时，我们发现图中已经分辨不出来，但是从 theta 的值，我们还可以看到一点差距，这已经证明，机器学习拟合上了目标空间。