在神经网络的训练过程中，反向传播算法（Backpropagation）是优化模型参数的核心手段。而自动微分（Automatic Differentiation）则是实现该算法的技术基础。它不同于数值微分和符号微分，能够将复杂的数学函数分解为一系列基本运算，通过链式法则精确、高效地计算导数。MindSpore 采用了函数式自动微分的设计范式，提供了更贴近数学表达的 grad 和 value_and_grad 等接口。

基础环境准备

在开始之前，确保环境中已安装兼容版本的 MindSpore。以下示例基于 MindSpore 执行环境：

import numpy as np
import mindspore
from mindspore import nn, ops, Tensor, Parameter

# 初始化基础数据
input_data = ops.ones(5, mindspore.float32)  # 输入张量
labels = ops.zeros(3, mindspore.float32)     # 目标标签
weight_matrix = Parameter(Tensor(np.random.randn(5, 3), mindspore.float32), name='w') 
bias_vector = Parameter(Tensor(np.random.randn(3,), mindspore.float32), name='b')

计算函数与逻辑流

计算图是深度学习模型计算过程的图形化表示。我们可以通过编写一个简单的线性变换加损失计算的函数来模拟这一过程。这里使用带有 Logits 的二元交叉熵作为损失函数。

def compute_loss(inputs, targets, w, b):
    # 线性映射：z = x * w + b
    prediction = ops.matmul(inputs, w) + b
    # 计算损失
    loss_val = ops.binary_cross_entropy_with_logits(prediction, targets, ops.ones_like(prediction), ops.ones_like(prediction))
    return loss_val

current_loss = compute_loss(input_data, labels, weight_matrix, bias_vector)
print(f"Initial Loss: {current_loss}")

梯度函数生成

为了更新模型参数，需要计算损失函数对参数 $w$ 和 $b$ 的偏导数。MindSpore 的 grad 函数可以接收一个 Python 函数并返回其导数函数。通过指定参数索引（如 2 和 3 分别对应 w 和 b），可以精确控制对哪些变量求导。

# 获取微分函数，指定对第2和第3个参数求导
derivative_fn = mindspore.grad(compute_loss, grad_position=(2, 3))
gradients = derivative_fn(input_data, labels, weight_matrix, bias_vector)
print(f"Weight Gradients: {gradients[0]}")
print(f"Bias Gradients: {gradients[1]}")

梯度阻断操作

在某些复杂的神经网络架构中，我们可能不希望梯度流经特定的计算分支。此时可以使用 ops.stop_gradient 来截断梯度回传。

def loss_with_truncation(inputs, targets, w, b):
    prediction = ops.matmul(inputs, w) + b
    # 阻断 prediction 的梯度传播
    frozen_output = ops.stop_gradient(prediction)
    loss_val = ops.binary_cross_entropy_with_logits(frozen_output, targets, ops.ones_like(frozen_output), ops.ones_like(frozen_output))
    return loss_val

truncated_grad_fn = mindspore.grad(loss_with_truncation, (2, 3))
truncated_grads = truncated_grad_fn(input_data, labels, weight_matrix, bias_vector)
# 由于梯度被阻断，输出将为 0
print(f"Truncated Gradients: {truncated_grads}")

辅助数据输出

在求导的同时，有时需要获取前向计算的中间结果（如 Accuracy 或中间层的特征图）。通过设置 has_aux=True，可以让梯度函数同时返回计算结果和辅助数据。

def loss_with_aux(inputs, targets, w, b):
    logits = ops.matmul(inputs, w) + b
    loss_val = ops.binary_cross_entropy_with_logits(logits, targets, ops.ones_like(logits), ops.ones_like(logits))
    return loss_val, logits

aux_grad_fn = mindspore.grad(loss_with_aux, (2, 3), has_aux=True)
grads_result, logits_output = aux_grad_fn(input_data, labels, weight_matrix, bias_vector)
print(f"Auxiliary Logits: {logits_output}")

面向对象模型的梯度计算

在实际工程中，通常使用 nn.Cell 封装网络。结合 value_and_grad 接口，可以方便地计算模型输出值以及相对于可训练参数的梯度。

class LinearRegressor(nn.Cell):
    def __init__(self, w, b):
        super().__init__()
        self.w = w
        self.b = b

    def construct(self, x):
        return ops.matmul(x, self.w) + self.b

# 实例化模型与损失函数
net = LinearRegressor(weight_matrix, bias_vector)
criterion = nn.BCEWithLogitsLoss()

def training_step(x, y):
    output = net(x)
    loss = criterion(output, y)
    return loss

# 使用 weights 参数指定对所有可训练参数求导
train_grad_fn = mindspore.value_and_grad(training_step, None, weights=net.trainable_params())
loss_val, model_grads = train_grad_fn(input_data, labels)
print(f"Final Training Loss: {loss_val}")
print(f"Model Parameter Gradients: {model_grads}")

核心 API 概览

算子/接口	功能描述
mindspore.grad	高阶导数生成函数，支持指定位置求导。
value_and_grad	同时返回函数计算值和梯度值，常用于训练循环。
ops.stop_gradient	在计算图中插入断点，阻止梯度向后传播。
Parameter	特殊的张量，代表模型中需要被更新的权重或偏置。
has_aux	参数选项，允许微分函数返回额外的辅助数据。