“别去试着理解它，去感受它。”
—— 《信条》 (2020)
主角在实验室第一次接触“逆向子弹”。当他做出接子弹的动作时，子弹违背物理常识，从墙上倒飞回弹夹。在这个世界里，时间可以逆流，因果可以倒置。
在深入学习 R torch 的自动微分机制之前，我们需要先解决一个 R 语言老手最常见的困惑：我们为什么要通过编写循环、设置学习率来“训练”模型，而不是像调用 lm() 那样直接算出一个结果？
要回答这个问题，我们需要重新审视统计建模与深度学习在求解方法上的本质差异。
无论是经典的线性回归，还是最先进的深度神经网络，在回归任务中，我们的核心目标往往是一致的：最小化残差平方和（Residual Sum of Squares, RSS）。
也就是找到一组参数 \(w\)，使得预测值与真实值之间的误差最小：
\[ \text{Minimize } L(w) = \sum_{i=1}^{N} (y_i - \hat{y}_i)^2 = \sum_{i=1}^{N} (y_i - X_i w)^2 \]
既然目标一致，为什么解决问题的方法会发生如此剧烈的变化？这取决于我们的目标函数有多复杂。
在 lm() 的世界里，我们可以直接通过数学推导找到最优解。
回忆一下微积分：函数的极值点通常出现在导数为 0 的位置。对于线性回归 \(L(w)\) 这样一个完美的凸函数，我们可以直接对 \(w\) 求导，并令其等于 0：
\[ \frac{\partial L}{\partial w} = -2X^T(y - Xw) = 0 \]
解这个方程，我们不仅不需要迭代，反而能直接得出一个完美的公式，也就是正规方程 (Normal Equations)：
\[ w = (X^T X)^{-1} X^T y \]
这就是解析解 (analytical solution)，也被称为闭式解 (Closed-form solution) 。它就像是拥有了“瞬间移动”的能力——只要数据 \(X\) 和 \(y\) 给定，我们不需要试错，直接把数字代入公式，一步就能算出那个让 Loss 最小的完美的 \(w\)。这正是 R 语言中 lm()、solve() 背后的逻辑1：精确、直接、一步到位。
我们以 R 内置的 mtcars 数据集为例，通过汽车的车重 (wt) 和 马力 (hp) 来预测 油耗 (mpg)。
\[ \text{mpg} = w_1 \cdot \text{wt} + w_2 \cdot \text{hp} + b \]
为了确保后续手动实现的梯度下降算法能够快速收敛，数据标准化（Scaling） 是至关重要的一步。如果特征之间的尺度差异过大（例如 wt 约为 3，而 hp 约为 100），梯度下降会在寻找最优解时走弯路（Zigzag），导致训练极其困难。
matplotlib.r
# 选取特征与目标
x_raw <- mtcars[, c("wt", "hp")]
y_raw <- mtcars$mpg
# 标准化特征 (Z-score normalization)
x_scaled <- scale(x_raw)
# 设计矩阵：加上截距列
X <- cbind(1, x_scaled) # 1 是截距项
y <- y_raw
# OLS 解析解：beta = (X^T X)^(-1) X^T y
beta_hat <- solve(t(X) %*% X) %*% t(X) %*% y
print(beta_hat)
# [,1]
# 20.090625
# wt -3.794292
# hp -2.178444
# 等价于实现了
# fit_lm <- lm(y_raw ~ x_scaled)
# print(coef(fit_lm))运行上述代码，我们可以得到截距项约为 20.09，wt 系数约为 -3.79，hp 系数约为 -2.18）。
既然解析解这么好，为什么深度学习不用？主要有两个原因阻断了这条路：
因此，深度学习被迫放弃了“瞬间移动”，选择了数值优化（Numerical Optimization）。
我们不再试图一步算出 \(w\)，而是采用迭代更新的策略。这就是著名的梯度下降 (Gradient Descent) 算法：
\[ w_{t+1} = w_t - \eta \cdot \nabla_w L(w_t) \]
这个公式描述了一个动态的修正过程：
整个训练过程变成了一个循环：
这种方法，需要我们手动推导均方误差（MSE）关于参数的导数公式：
\[ \frac{\partial L}{\partial w} = \frac{2}{N} X^T (Xw + b - y) \]
\[ \frac{\partial L}{\partial b} = \frac{2}{N} \sum (Xw + b - y) \]
写成 R 代码：
set.seed(123)
# w: 对应 wt 和 hp 的权重 (2行1列)
w <- matrix(rnorm(2), nrow = 2)
b <- 0
# 超参数
learning_rate <- 0.1
epochs <- 100
n_samples <- nrow(x_scaled) # 样本数量 N
# 开始训练循环
for (i in 1:epochs) {
# 1. 前向传播 (Forward Pass)
y_pred <- x_scaled %*% w + b # 使用 %*% 进行矩阵乘法
# 2. 计算误差 (Residuals)
error <- y_pred - y_raw
# 计算 Loss (仅用于观察，不参与运算)
loss <- mean(error^2)
# 3. 手动计算梯度 (The Hard Part!)
# 对应公式：(2/N) * X^T * error
w_grad <- (2 / n_samples) * (t(x_scaled) %*% error)
b_grad <- (2 / n_samples) * sum(error)
# 4. 更新参数 (Gradient Descent)
# 向梯度的反方向移动
w <- w - learning_rate * w_grad
b <- b - learning_rate * b_grad
if (i %% 10 == 0) {
cat(sprintf("Epoch %d: Loss = %.4f\n", i, loss))
}
}
cat(b, t(w))
# 20.09062 -3.793605 -2.179132运行这段代码，你会惊讶地发现，经过 100 轮简单的加减乘除，我们得到的系数与 lm() 的结果惊人地相似（w 约为 -3.7934 和 -2.1793）。
既然 Base R 也能做，为什么我们需要 Torch？
请注意上面代码中的第 3 步——手动计算梯度。对于简单的线性回归，导数公式还是高中数学水平。但想象一下，如果我们要构建一个拥有 100 层、包含各种非线性激活函数（Sigmoid, ReLU, Tanh）的复杂网络，手动推导并编写每一个参数的导数公式将是一场噩梦。只要有一个公式推导错误，整个模型就会崩溃。
这就是深度学习框架存在的意义。接下来，我们将看到 Torch 最核心的魔法——自动微分（Automatic Differentiation）。它将把我们从繁琐的导数推导中彻底解放出来。
优化理论中有众多算法，为什么深度学习几乎完全被“一阶梯度下降”统治？
既然必须计算梯度，我们该如何计算？计算机科学主要有三种流派：
D() 函数那样，推导解析公式。缺点是表达式膨胀 (Expression Swell)。复杂神经网络展开后的导数公式长度可能会撑爆内存。这意味着：只要你能算得起 Loss，你就能算得起梯度。
很多初学者最大的困惑在于：Torch 到底是怎么在“不知道”函数全貌的情况下算出导数的？
其实，自动微分（Autograd）并不是对着一个长长的公式 \(y = f(g(h(x)))\) 去推导全局导数。它采用的是“盲人摸象”策略：Torch 的 C++ 底层预先写好了所有基本算子（加法、乘法、指数、对数等）的“局部导数规则”。
Torch 不需要知道公式，它只需要把这一路上的“局部导数”连乘起来，最终结果就是我们要的全局梯度。回忆一下高中数学的定理——链式法则 (Chain Rule)。
对于复合函数 \(y = f(g(x))\)，如果我们令 \(u = g(x)\)，那么：
\[ \frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx} \]
Torch 的 Autograd 系统本质上就是在这个链路中自动执行乘法运算。在深度学习框架中，每一次数学运算不仅是数值的计算，更是图结构的构建。R torch 采用的是动态计算图 (Dynamic Computational Graph)，即“运行时定义 (Define-by-Run)”模式。
从图论的角度看，神经网络是一个有向无环图 \(G = (V, E)\)：
当我们执行一段 R 代码时，torch 在后台同时维护着两套逻辑：
为了实现这一机制，torch_tensor 对象在 C++ 底层维护了一个关键指针：grad_fn。
grad_fn 为 NULL。让我们通过代码，像调试器一样逐层检查这个结构。
library(torch)
# 1. 定义叶子节点
# requires_grad = TRUE 是构建图的开关
# 只有开启它，torch 才会分配内存去记录后续的操作
w <- torch_tensor(2.0, requires_grad = TRUE)
b <- torch_tensor(5.0, requires_grad = TRUE)
x <- torch_tensor(3.0) # 输入数据通常不需要梯度
# 2. 执行运算（构建图）
# 步骤 A: 乘法
u <- w * x
# 步骤 B: 加法
v <- u + b
# 步骤 C: 平方
loss <- v ^ 2
# 3. 计算图结构分析：追踪 grad_fn
# Level 0: 输出层
print(loss$grad_fn)
# 输出: <PowBackward0>
# 解释: 这是一个“幂运算”的反向函数对象
# Level 1: 中间层
# 我们可以通过 next_functions 访问图的上一层
# 注意：这是 R torch 暴露出来的底层接口，用于调试图结构
# loss 是由 v 算出来的，所以它的上一级应该是 AddBackward (v 的生成逻辑)
print(loss$grad_fn$next_functions)
# 输出 list 中包含: <AddBackward0>
# Level 2: 更深层
# AddBackward0 (v) 是由 u 和 b 算出来的
# 所以它的 next_functions 应该包含 MulBackward0 (u) 和 AccumulateGrad (b)
v_grad_fn <- loss$grad_fn$next_functions[[1]]$fn
print(v_grad_fn$next_functions)在执行前向计算 loss <- v^2 的瞬间，torch 并不是只算出了 121 这个数，而是在内存中生成了一个 PowBackward0 对象，并让这个对象持有了一个指向 AddBackward0 的指针。
这一系列对象构成了一个单向链表。当我们调用 loss$backward() 时，torch 的引擎只是简单地遍历这个链表，依次调用每个节点的 Apply 方法计算偏导数。
因为是动态图，所以 R 语言的 if 或 for 可以用来改变网络结构的拓扑结构：
dynamic_op <- function(x, w) {
if (as.numeric(x$mean()) > 0) {
# 路径 A: 包含 Log 和 Mul 运算
return(torch_log(x) * w)
} else {
# 路径 B: 包含 Abs 和 Add 运算
return(torch_abs(x) + w)
}
}
w <- torch_tensor(1.0, requires_grad = TRUE)
y1 <- dynamic_op(torch_tensor(2.0), w) # 输入为正
y1$grad_fn$print()
# MulBackward0
y2 <- dynamic_op(torch_tensor(-2.0), w) # 输入为负
y2$grad_fn$print()
# AddBackward0在 R torch 中，不存在一个“固定的”全局图。每次前向传播，都是在创建一张全新的图。这虽然带来了一定的 R 运行时开销，但换来了极致的灵活性，使得处理变长序列（RNN）和图神经网络（GNN）变得符合直觉。
动态图的还有一个很大工程优势在于调试。因为图的构建是与 R 代码的执行同步发生的，你可以直接在模型的前向传播函数中暂停程序：
custom_layer <- nn_module(
"CustomLayer",
initialize = function() {
self$linear <- nn_linear(10, 5)
},
forward = function(x) {
x <- self$linear(x)
# --- 调试断点 ---
# 检查是否有 NaN (Not a Number) 出现
if (torch_isnan(x)$any()) {
warning("检测到 NaN，进入调试模式...")
browser()
# 在此处，你可以查看 x 的值，检查权重 self$linear$weight
# 甚至可以手动运行 x$mean() 来诊断问题
}
# ----------------
return(torch_relu(x))
}
)在深度学习的训练循环中，梯度的生命周期遵循严格的“三部曲”：开启追踪 -> 反向传播 -> 梯度清零。
一、开启追踪 (requires_grad)
在 R torch 中，张量被创建时默认是不分配梯度内存的。这是为了最大化工程效率——输入数据（Features）和标签（Labels）通常不需要更新，如果对它们也分配梯度内存，显存占用将翻倍。
我们必须显式地声明哪些张量是“参数（Parameters）”。
# 普通数据张量 (Default)
x <- torch_tensor(3.0)
# 模型参数张量
w <- torch_tensor(2.0, requires_grad = TRUE)
# 或者后期原地修改 (In-place)
b <- torch_tensor(5.0)
b$requires_grad_(TRUE) 当你使用 nn_linear 或 nn_conv2d 等标准层时，torch 已经自动将其内部的 weight 和 bias 设置为了 requires_grad = TRUE。
二、反向传播(backward)
loss$backward() 是 Autograd 引擎的启动键。需要特别注意的是，这个函数没有返回值。
在 R 的常规函数中，我们习惯 grad <- calculate_grad(loss)。但在 torch 中，梯度是被“写入”到计算图叶子节点的 $grad 属性中的。我们可以看一个例子,设函数 \(y = 3x^2 + 2\)，当 \(x=2\) 时：
x <- torch_tensor(2.0, requires_grad = TRUE)
(y <- 3 * x^2 + 2) # 前向传播，打印 y
# torch_tensor
# 14
# [ CPUFloatType{1} ][ grad_fn = <AddBackward1> ]
y$backward() # 遍历计算图，计算梯度，并将结果写入 x$grad
print(x$grad) # 检查反向传播后的结果
# torch_tensor
# 12
# [ CPUFloatType{1} ]为了让你彻底放心 torch 的数学能力，我们来看一个多元微积分例子。假设函数 \(z = x^2 + y^3\)。我们要计算在点 \((x=2, y=3)\) 处的梯度。
x <- torch_tensor(2.0, requires_grad = TRUE)
y <- torch_tensor(3.0, requires_grad = TRUE)
z <- x^2 + y^3
z$backward()
cat("x 的梯度 (2x -> 4): ", x$grad$item(), "\n")
cat("y 的梯度 (3y^2 -> 27): ", y$grad$item(), "\n")看到代码输出精确地吻合数学推导，是不是有一种掌控感？我们完全不需要像第一节一样，将每个数学推导都来一遍，这正是“可微编程（Differentiable Programming）”的魅力所在。
三、梯度的累加机制(Accumulation)
这是 R torch 设计中最反直觉的地方。当你再次调用 backward() 时，新计算出的梯度不会覆盖旧的梯度，而是会“加”在旧梯度上。即：
\[ \text{grad}_{\text{new}} = \text{grad}_{\text{old}} + \frac{\partial L}{\partial w} \]
可以做个小实验：
library(torch)
# 定义一个变量 w = 2
w <- torch_tensor(2.0, requires_grad = TRUE)
# 假设函数 y = 3 * w
# 导数 dy/dw = 3
# 理论上，无论我们算多少次，导数都应该是 3
y1 <- 3 * w # 第 1 次反向传播
y1$backward()
cat("第 1 次 backward 后，w$grad =", w$grad$item(), "\n")
y2 <- 3 * w # 第 2 次反向传播，我们没有清空梯度，直接再算一次
y2$backward()
cat("第 2 次 backward 后，w$grad =", w$grad$item(), "\n")
y3 <- 3 * w # 第 3 次反向传播
y3$backward()
cat("第 3 次 backward 后，w$grad =", w$grad$item(), "\n")返回的结果：
# 第 1 次 backward 后，w$grad = 3
# 第 2 次 backward 后，w$grad = 6
# 第 3 次 backward 后，w$grad = 9 但这并非设计缺陷，而是为了工程上的灵活性。假如 GPU 显存塞不下 Batch Size = 64 的数据，我们可以把数据切成 4 个 Batch Size = 16 的小块，分别 Backward，梯度会自动累加，最后 Update 一次。这等价于训练了 Batch Size = 64。
这种机制意味着，在常规的训练循环中，我们必须手动干预，显式地把梯度归零。否则，第 100 轮训练时的梯度，将包含前 99 轮所有梯度的总和，这会导致更新步长过大，模型瞬间发散。
在底层 API 中，我们需要调用张量的原地操作 zero_()：
# 手动清空梯度
w$grad$zero_()
cat("清空后，w$grad =", w$grad$item(), "\n")
# 输出: 0在 R torch 中，只要输入张量的 requires_grad = TRUE，系统就会默认你正在进行模型训练，从而不惜一切代价记录操作历史。但在验证（Validation）或预测（Inference）阶段，我们需要暂停这个机制，这就是 with_no_grad 上下文管理器的作用。 在 with_no_grad 代码块内，即便声明了张量的 requires_grad = TRUE，torch 也不会为它们构建计算图。
w <- torch_randn(100, 100, requires_grad = TRUE)
x <- torch_randn(100, 100)
# 训练模式
start_time <- Sys.time()
for (i in 1:5000) {
y <- torch_matmul(w, x)
}
Sys.time() - start_time
# Time difference of 0.2006299 secs
# 推断模式
start_time <- Sys.time()
with_no_grad({
for (i in 1:5000) {
y <- torch_matmul(w, x)
}
})
Sys.time() - start_time
# Time difference of 0.06900597 secs推断模式下不构建计算图，所以速度会更快。同 with_no_grad() 经常一起出现的还有 model$eval()，它的主要作用是改变层的数学行为：比如训练的时候有 dropout，但 eval 时就不要做 dropout 动作了。
另外，R 用户非常习惯使用 list 或者 data.frame 来存储循环中的结果，但在 torch 中会造成内存泄露。
history <- list()
# 假设我们在训练循环中
for (i in 1:1000) {
# Forward ...
loss <- (w * x)^2 # 假设这是一个复杂的计算图终点
# [错误做法]
# history[[i]] <- loss
# loss 对象身上挂着整个计算图（grad_fn 链表）。
# 只要 list 引用了 loss，整个图及其所有中间变量就无法被垃圾回收（GC）。
# 跑几千轮后，内存将被撑爆。
# [正确做法 A]：只存数值
# item() 将 0-dim 张量转换为 R 的原生数值 (numeric)
history[[i]] <- loss$item()
# [正确做法 B]：剥离张量
# detach() 创建一个新的张量，数据共享，但切断了与图的联系
detached_loss <- loss$detach()
# history[[i]] <- detached_loss
}如果你需要将 Tensor 转化为 R 的原生数据（如用于 ggplot2 绘图），或者需要将 Tensor 存起来供下一轮使用（如 RNN 的隐藏状态），务必使用 detach() 或 item()。
回到前面的案例，我们重新用张量实现一遍。
首先我们需要定义模型参数 \(W\) 和 \(b\)，并告诉 Torch：“请帮我盯着这几个变量，我要对它们求导。”这就是 requires_grad = TRUE 的用武之地。
torch_manual_seed(123) # torch 的随机数种子
# --- 数据转换 ---
x_tensor <- torch_tensor(x_scaled, dtype = torch_float())
y_tensor <- torch_tensor(y_raw, dtype = torch_float())
y_tensor <- y_tensor$view(c(-1, 1)) # 转为 (N, 1) 形状
# 权重 W (形状: 2行1列)
# 开启 requires_grad = TRUE，让 Autograd 记录对 W 的所有操作
w <- torch_randn(c(2, 1), dtype = torch_float(), requires_grad = TRUE)
# 偏置 b (形状: 1)
b <- torch_zeros(c(1, 1), dtype = torch_float(), requires_grad = TRUE)
print(w) # 看下 w 长什么样
# torch_tensor
# -0.1115
# 0.1204
# [ CPUFloatType{2,1} ][ requires_grad = TRUE ]设置学习率和迭代次数
learning_rate <- 0.1
epochs <- 100前面开启了梯度追踪，紧跟着是反向传播 loss$backward() 和梯度清零：
for (epoch in 1:epochs) {
# Forward，建立计算图：y = XW + b
y_pred <- torch_matmul(x_tensor, w) + b
# 计算均方误差 (MSE)
loss <- (y_pred - y_tensor)$pow(2)$mean()
# 反向传播 (Backward Pass) - Autograd 的魔力
# 这一行代码会自动计算 loss 关于 w 和 b 的梯度，
# 并将结果存储在 w$grad 和 b$grad 中。
loss$backward()
# 参数更新 (Update Weights)
# 必须在 with_no_grad() 中进行，防止更新操作被记录到计算图中
with_no_grad({
# 使用原地减法 sub_ (substract in-place)
w$sub_(learning_rate * w$grad)
b$sub_(learning_rate * b$grad)
# 手动清空梯度！
# 否则下一轮的梯度会叠加在这一轮的梯度上
w$grad$zero_()
b$grad$zero_()
})
if (epoch %% 10 == 0) {
cat(sprintf("Epoch: %d, Loss: %.4f\n", epoch, loss$item()))
}
}对比解析解、R 原生梯度下降、Torch_Autograd 三个版本的结果。
| Term | 解析解 | R 原生梯度下降 | Torch_Autograd |
|---|---|---|---|
| Intercept | 20.090625 | 20.09062 | 20.0906 |
| wt | -3.794292 | -3.793605 | -3.7936 |
| hp | -2.178444 | -2.179132 | -2.1792 |
三种方法的计算结果基本没什么差异。
仔细观察上一节的代码，你会发现参数更新的步骤略显繁琐：我们需要手动通过 with_no_grad 暂停追踪，手动做减法更新，还要手动清空梯度。
# 手动更新的繁琐写法
with_no_grad({
w$sub_(learning_rate * w$grad)
b$sub_(learning_rate * b$grad)
w$grad$zero_()
b$grad$zero_()
})如果模型有 100 层，每层都有权重和偏置，手动写这几行代码将是灾难。
R torch 提供了一个更高层的抽象——优化器 (Optimizer)。优化器本质上是一个通过“托管”参数来自动化更新流程的对象。它将上述的样板代码封装成了两个标准方法：
optimizer$step(): 替代了手动的减法更新。optimizer$zero_grad(): 替代了手动的 grad$zero_()。让我们用 optim_sgd（随机梯度下降优化器）来重构之前的线性回归代码。你会发现，无论模型多么复杂，训练循环的代码结构永远保持不变。
# 定义优化器
optimizer <- optim_sgd(params = list(w, b), lr = learning_rate)
# 训练循环
for (epoch in 1:epochs) {
y_pred <- torch_matmul(x_tensor, w) + b
loss <- (y_pred - y_tensor)$pow(2)$mean()
# 1. 清空过往梯度
# 必须在 backward 之前调用，否则梯度会累加
optimizer$zero_grad()
# 2. 反向传播
# 计算当前梯度，填入 w$grad 和 b$grad
loss$backward()
# 3. 执行更新
# 根据 w$grad 和学习率，自动修正 w 的值
optimizer$step()
if (epoch %% 10 == 0) {
cat(sprintf("Epoch: %d, Loss: %.4f\n", epoch, loss$item()))
}
}这段代码展示了深度学习工程中最通用的范式。此时，optimizer 就像是一个仅仅执行命令的工兵，我们告诉它用最简单的 SGD 算法（仅仅是减去梯度）。