深度学习 – 梯度计算及上下文控制

---

一，自动微分

自动微分模块torch.autograd负责自动计算张量操作的梯度，具有自动求导功能。自动微分模块是构成神经网络训练的必要模块，可以实现网络权重参数的更新，使得反向传播算法的实现变得简单而高效。

1.1 基础概念

1. 张量

   Torch中一切皆为张量，属性requires_grad决定是否对其进行梯度计算。默认是 False，如需计算梯度则设置为True。

2. 计算图：

   torch.autograd通过创建一个动态计算图来跟踪张量的操作，每个张量是计算图中的一个节点，节点之间的操作构成图的边。

   在 PyTorch 中，当张量的 requires_grad=True 时，PyTorch 会自动跟踪与该张量相关的所有操作，并构建计算图。每个操作都会生成一个新的张量，并记录其依赖关系。当设置为 True 时，表示该张量在计算图中需要参与梯度计算，即在反向传播（Backpropagation）过程中会自动计算其梯度；当设置为 False 时，不会计算梯度。

• 计算依赖图
  
  叶子结点判断方式

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)  # 叶子节点
y = x ** 2  # 非叶子节点（通过计算生成）
z = y.sum()print(x.is_leaf)  # True
print(y.is_leaf)  # False
print(z.is_leaf)  # False

1.2 计算梯度

使用tensor.backward()方法执行反向传播，从而计算张量的梯度

1.2.1 计算标量梯度

import torchdef test01():x= torch.tensor(1.0,requires_grad=True)# requires_grad=True表示需要求导y=x**2# 操作张量y.backward() #计算梯度，也就是反向传播print(x.grad) # 打印梯度if __name__ == '__main__':test01()

1.2.2 计算向量梯度

def test002():# 1. 创建张量：必须为浮点类型x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)y = x ** 2loss = y.mean()loss.backward()print(x.grad)if __name__ == "__main__":test002()

调用 loss.backward() 从输出节点 loss 开始，沿着计算图反向传播，计算每个节点的梯度。

损失函数$$loss=mean(y)=\frac{1}{n}\sum _{i=1}^n{y}_i$$，其中 n=3。

对于每个 $y_i$，其梯度为 $\frac{\partial loss}{\partial y_i}=\frac{1}{n}=\frac{1}{3}$。

对于每个 $x_i$，其梯度为：
$$\frac{\partial loss}{\partial x_i}=\frac{\partial loss}{\partial y_i}\times \frac{\partial y_i}{\partial x_i}=\frac{1}{3}\times 2x_i=\frac{2x_i}{3}$$
所以，x.grad 的值为：$[\frac{2\times 1.0}{3},\frac{2\times 2.0}{3},\frac{2\times 3.0}{3}]=[\frac{2}{3},\frac{4}{3},2]\approx [0.6667,1.3333,2.0000]$

1.2.3 多标量梯度计算

#多标量梯度计算
def test03():x1= torch.tensor(1.0,requires_grad=True)x2=torch.tensor(3.0,requires_grad=True)y=x1**2+x2*7z=y.sum()z.backward()print(x1.grad,x2.grad)if __name__ == '__main__':test03()

1.2.4 多向量梯度计算

# 多向量梯度计算
def test04():x1 = torch.tensor([1.0, 2.0], requires_grad=True)x2 = torch.tensor([3.0, 4.0], requires_grad=True)y = x1 ** 2 + x2 * 7z = y.sum()z.backward()print(x1.grad, x2.grad)if __name__ == '__main__':test04()

二，梯度上下文控制

梯度计算的上下文控制和设置对于管理计算图、内存消耗、以及计算效率至关重要。下面我们学习下Torch中与梯度计算相关的一些主要设置方式。

2.1 控制梯度计算

简单的运算不需要梯度

import torchdef test01():x=torch.tensor(11.5,requires_grad=True)print(x.requires_grad)# Truey=x**2print(y.requires_grad)# Truewith torch.no_grad():z=x**2print(z.requires_grad)#使用装饰器@torch.no_grad()def test():return x**2y=test()print(y.requires_grad)if __name__ == '__main__':test01()

2.2 累计梯度

默认情况下，当我们重复对一个自变量进行梯度计算时，梯度是累加的

import torchdef test002():x = torch.tensor([1.0, 2.0, 5.3], requires_grad=True)# 2. 累计梯度：每次计算都会累计梯度for i in range(3):y = x**2 + 2 * x + 7z = y.mean()z.backward()print(x.grad)if __name__ == "__main__":test002()

2.3 梯度清零

大多数情况下是不需要梯度累加的

#梯度清零
def test002():x = torch.tensor([1.0, 2.0, 5.3], requires_grad=True)# 2. 累计梯度：每次计算都会累计梯度for i in range(3):y = x**2 + 2 * x + 7z = y.mean()# 2.1 反向传播之前先对梯度进行清零if x.grad is not None:x.grad.zero_()z.backward()print(x.grad)if __name__ == "__main__":test002()

三，案例一----求函数最小值

import torch
from matplotlib import pyplot as plt
import numpy as npdef test01():x = np.linspace(-10, 10, 100)y = x ** 2plt.plot(x, y)plt.show()def test02():# 初始化自变量Xx = torch.tensor([3.0], requires_grad=True, dtype=torch.float)# 迭代轮次epochs = 50# 学习率lr = 0.1list = []for i in range(epochs):# 计算函数表达式y = x ** 2# 梯度清零if x.grad is not None:x.grad.zero_()# 反向传播y.backward()with torch.no_grad():x -= lr * x.gradprint('epoch:', i, 'x:', x.item(), 'y:', y.item())list.append((x.item(), y.item()))# 散点图，观察收敛效果x_list = [l[0] for l in list]y_list = [l[1] for l in list]plt.scatter(x=x_list, y=y_list)plt.show()if __name__ == "__main__":test01()test02()

四，案例二----函数参数求解

import torchdef test02():x = torch.tensor([1, 2, 3, 4, 5], dtype=torch.float)y = torch.tensor([3, 5, 7, 9, 11], dtype=torch.float)a = torch.tensor([1.0], dtype=torch.float, requires_grad=True)b = torch.tensor([1.0], dtype=torch.float, requires_grad=True)lr = 0.05epochs = 1000for epoch in range(epochs):y_pred = a * x + bloss = ((y_pred - y) ** 2).mean()if a.grad is not None:a.grad.zero_()if b.grad is not None:b.grad.zero_()loss.backward()with torch.no_grad():a -= lr * a.gradb -= lr * b.gradif (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/{epochs}], Loss: {loss.item():.4f}')print(f'a: {a.item():.4f}, b: {b.item():.4f}')if __name__ == '__main__':test02()