Pytorch的自动求导模块

torch.autograd.backward()

该函数实现自动求导梯度，函数如下：

torch.autograd.backward(tensors, grad_tensors=None, retain_graph=False, create_graph=False, inputs=None)

参数介绍：

• tensors: 需要对其进行反向传播的目标张量（或张量列表），例如：loss。
  这些张量通常是计算图的最终输出。
• grad_tensors:与 tensors 对应的梯度权重（或权重列表）。
  如果 tensors 是标量张量（单个值），可以省略此参数。
  如果 tensors 是非标量张量（如向量或矩阵），则必须提供 grad_tensors，表示每个张量的梯度权重。例如：当有多个loss需要计算梯度时，需要设置每个loss的权值。
• retain_graph:是否保留计算图。
  默认值为 False，即反向传播后会释放计算图。如果需要多次反向传播，需设置为 True。
• create_graph: 是否创建一个新的计算图，用于高阶梯度计算。
  默认值为 False，如果需要计算二阶或更高阶梯度，需设置为 True。
• inputs: 指定需要计算梯度的输入张量（或张量列表）。
  如果指定了此参数，只有这些张量的 .grad 属性会被更新，而不是整个计算图中的所有张量。

基本用法

import torch  

# 定义张量并启用梯度计算  
x = torch.tensor(2.0, requires_grad=True)  
y = x ** 2  # y = x^2  

# 使用 torch.autograd.backward() 触发反向传播  
torch.autograd.backward(y)  

# 查看梯度  
print(x.grad)  # 输出：4.0 (dy/dx = 2x, 当 x=2 时，dy/dx=4)

非标量张量的反向传播

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)  
y = x ** 2  # y = [x1^2, x2^2, x3^2]  

# 指定 grad_tensors 权重  
grad_tensors = torch.tensor([1.0, 1.0, 1.0])  # 权重  
torch.autograd.backward(y, grad_tensors=grad_tensors)  

# 查看梯度  
print(x.grad)  # 输出：[2.0, 4.0, 6.0] (dy/dx = 2x)

保留计算图

如果需要多次调用反向传播，可以设置 retain_graph=True。

x = torch.tensor(2.0, requires_grad=True)  
y = x ** 3  # y = x^3  

# 第一次反向传播  
torch.autograd.backward(y, retain_graph=True)  
print(x.grad)  # 输出：12.0 (dy/dx = 3x^2, 当 x=2 时，dy/dx=12)  

# 第二次反向传播  
torch.autograd.backward(y, retain_graph=True)  
print(x.grad)  # 输出：24.0 (梯度累积，12.0 + 12.0)

指定输入张量

通过 inputs 参数，可以只计算指定张量的梯度，而忽略其他张量。

x = torch.tensor(2.0, requires_grad=True)  
z = torch.tensor(3.0, requires_grad=True)  
y = x ** 2 + z ** 3  # y = x^2 + z^3  

# 只计算 x 的梯度  
torch.autograd.backward(y, inputs=[x])  
print(x.grad)  # 输出：4.0 (dy/dx = 2x)  
print(z.grad)  # 输出：None (未计算 z 的梯度)

高阶梯度计算

通过设置 create_graph=True，可以构建新的计算图，用于计算高阶梯度。

x = torch.tensor(2.0, requires_grad=True)  
y = x ** 3  # y = x^3  

# 第一次反向传播，创建新的计算图  
torch.autograd.backward(y, create_graph=True)  
print(x.grad)  # 输出：12.0 (dy/dx = 3x^2)  

# 计算二阶梯度  
x_grad = x.grad  
x_grad.backward()  
print(x.grad)  # 输出：18.0 (d^2y/dx^2 = 6x)

与 y.backward() 的区别

• 灵活性：

  • torch.autograd.backward() 更灵活，可以对多个张量同时进行反向传播，并指定梯度权重。
  • y.backward() 是对单个张量的简单封装，适合常见场景。对多个loss求导时，需要指定gradient和grad_outputs相同作用。

• 梯度权重：

  • torch.autograd.backward() 需要显式提供 grad_tensors 参数（如果目标张量是非标量）。
  • y.backward() 会自动处理标量张量，非标量张量需要手动传入权重。

• 输入控制：

  • torch.autograd.backward() 可以通过 inputs 参数指定只计算某些张量的梯度。
  • y.backward() 无法直接控制，只会更新计算图中所有相关张量的 .grad。

torch.autograd.grad()

torch.autograd.grad() 是 PyTorch 中用于计算张量梯度的函数，与 backward() 不同的是，它不会更新张量的 .grad 属性，而是直接返回计算的梯度值。它适用于需要手动获取梯度值而不修改计算图中张量的 .grad 属性的场景。

torch.autograd.grad(  
    outputs,   
    inputs,   
    grad_outputs=None,   
    retain_graph=False,   
    create_graph=False,   
    only_inputs=True,   
    allow_unused=False  
)

参数介绍：

• outputs:
  目标张量（或张量列表），即需要对其进行求导的输出张量。
• inputs:
  需要计算梯度的输入张量（或张量列表）。
  这些张量必须启用了 requires_grad=True。
• grad_outputs:
  与 outputs 对应的梯度权重（或权重列表）。
  如果 outputs 是标量张量，可以省略此参数；如果是非标量张量，则需要提供权重，表示每个输出张量的梯度权重。
• retain_graph:
  是否保留计算图。
  默认值为 False，即反向传播后会释放计算图。如果需要多次计算梯度，需设置为 True。
• create_graph:
  是否创建一个新的计算图，用于高阶梯度计算。
  默认值为 False，如果需要计算二阶或更高阶梯度，需设置为 True。
• only_inputs:
  是否只对 inputs 中的张量计算梯度。
  默认值为 True，表示只计算 inputs 的梯度。
• allow_unused:
  是否允许 inputs 中的某些张量未被 outputs 使用。
  默认值为 False，如果某些 inputs 未被 outputs 使用，会抛出错误。如果设置为 True，未使用的张量的梯度会返回 None。

返回值：

• 返回一个元组，包含 inputs 中每个张量的梯度值。
• 如果某个输入张量未被 outputs 使用，且 allow_unused=True，则对应的梯度为 None。

基本用法

import torch  

# 定义张量并启用梯度计算  
x = torch.tensor(2.0, requires_grad=True)  
y = x ** 2  # y = x^2  

# 使用 torch.autograd.grad() 计算梯度  
grad = torch.autograd.grad(y, x)  
print(grad)  # 输出：(4.0,) (dy/dx = 2x, 当 x=2 时，dy/dx=4)

非标量张量的梯度

当目标张量是非标量时，需要提供 grad_outputs 参数：

x = torch.tensor([1.0, 2.0, 3.0], requires_grad=True)  
y = x ** 2  # y = [x1^2, x2^2, x3^2]  

# 指定 grad_outputs 权重  
grad_outputs = torch.tensor([1.0, 1.0, 1.0])  # 权重  
grad = torch.autograd.grad(y, x, grad_outputs=grad_outputs)  
print(grad)  # 输出：(tensor([2.0, 4.0, 6.0]),) (dy/dx = 2x)

高阶梯度计算

通过设置 create_graph=True，可以计算高阶梯度：

x = torch.tensor(2.0, requires_grad=True)  
y = x ** 3  # y = x^3  

# 第一次计算梯度  
grad = torch.autograd.grad(y, x, create_graph=True)  
print(grad)  # 输出：(12.0,) (dy/dx = 3x^2)  

# 计算二阶梯度  
grad2 = torch.autograd.grad(grad[0], x)  
print(grad2)  # 输出：(6.0,) (d^2y/dx^2 = 6x)

多输入、多输出的梯度计算

可以对多个输入和输出同时计算梯度：

x = torch.tensor(2.0, requires_grad=True)  
z = torch.tensor(3.0, requires_grad=True)  
y1 = x ** 2 + z ** 3  # y1 = x^2 + z^3  
y2 = x * z  # y2 = x * z  

# 对多个输入计算梯度  
grads = torch.autograd.grad([y1, y2], [x, z], grad_outputs=[torch.tensor(1.0), torch.tensor(1.0)])  
print(grads)  # 输出：(7.0, 11.0) (dy1/dx + dy2/dx, dy1/dz + dy2/dz)

未使用的输入张量

如果某些输入张量未被目标张量使用，需设置 allow_unused=True：

x = torch.tensor(2.0, requires_grad=True)  
z = torch.tensor(3.0, requires_grad=True)  
y = x ** 2  # y = x^2  

# z 未被 y 使用  
grad = torch.autograd.grad(y, [x, z], allow_unused=True)  
print(grad)  # 输出：(4.0, None) (dy/dx = 4, z 未被使用，梯度为 None)

保留计算图

如果需要多次计算梯度，可以设置 retain_graph=True：

x = torch.tensor(2.0, requires_grad=True)  
y = x ** 3  # y = x^3  

# 第一次计算梯度  
grad1 = torch.autograd.grad(y, x, retain_graph=True)  
print(grad1)  # 输出：(12.0,)  

# 第二次计算梯度  
grad2 = torch.autograd.grad(y, x)  
print(grad2)  # 输出：(12.0,)

与 backward() 的区别

• 梯度存储：
  • torch.autograd.grad() 不会修改张量的 .grad 属性，而是直接返回梯度值。
  • backward() 会将计算的梯度累积到 .grad 属性中。
• 灵活性：
  • torch.autograd.grad() 可以对多个输入和输出同时计算梯度，并支持未使用的输入张量。
  • backward() 只能对单个输出张量进行反向传播。
• 高阶梯度：
  • torch.autograd.grad() 支持通过 create_graph=True 计算高阶梯度。
  • backward() 也支持高阶梯度，但需要手动设置 create_graph=True。