深度学习之自动微分

2.5.1 一个简单例子

import torch

# 1. 创建初始张量
x = torch.arange(4.0)  # 生成张量 [0., 1., 2., 3.]
print("初始 x:", x)
# 输出: tensor([0., 1., 2., 3.])

# 2. 启用梯度跟踪
x.requires_grad_(True)  # 设置 requires_grad=True
print("x.requires_grad:", x.requires_grad)
# 输出: True

# 3. 查看未计算时的梯度 (此时为None)
print("初始 x.grad:", x.grad)
# 输出: None

# 4. 前向计算
y = 2 * torch.dot(x, x)
print("y 的值:", y)
# 计算过程: dot(x,x) = 0² + 1² + 2² + 3² = 14 → y = 2*14 = 28
# 输出: tensor(28., grad_fn=<MulBackward0>)

# 5. 反向传播
y.backward()  # 自动计算 dy/dx

# 6. 查看计算后的梯度
print("计算后的 x.grad:", x.grad)
# 梯度计算: dy/dx = 4x → [4*0, 4*1, 4*2, 4*3] = [0,4,8,12]
# 输出: tensor([ 0.,  4.,  8., 12.])

# 7. 梯度清零（为后续计算准备，若需多次迭代）
x.grad.zero_()
print("清零后的 x.grad:", x.grad)
# 输出: tensor([0., 0., 0., 0.])

y = x.sum()  # 计算 y = 0.0 + 1.0 + 2.0 + 3.0 = 6.0
y.backward()  # 反向传播
print(x.grad)  # 输出梯度 [1.0, 1.0, 1.0, 1.0]

2.5.2 非标量变量的反向传播

x.grad.zero_()
y = x * x #[x₁² + x₂² + x₃² + x₄²]
y.sum().backward()#[2x₁ + 2x₂ + 2x₃ + 2x₄]
x.grad

2.5.3 分离计算

x.grad.zero_()  # 清空历史梯度，避免梯度累加影响当前计算‌
y = x * x       # 逐元素平方运算，生成 y_i = x_i²（跟踪梯度）‌
u = y.detach()  # 创建与 y 值相同但脱离计算图的张量 u（视为常数）‌
z = u * x       # 计算 z_i = u_i * x_i（仅 x 参与梯度计算）‌

z.sum().backward()  # 标量求和后反向传播，计算 x 的梯度‌
x, y, u, z,x.grad, x.grad == u # 验证 x.grad 是否等于 u 的值

x.grad.zero_()
y.sum().backward() # 非标量y上调用反向传播函数
x.grad == 2 * x

tensor([True, True, True, True])

2.5.4 Python控制流的梯度计算

def f(a):
    b = a * 2
    while b.norm() < 1000:
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c

a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

a,d,a.grad,d/a,a.grad == d / a