Looped Transformer参数共享与循环次数调优实战

在实际动手改模型结构之前，很多人对 Looped Transformers 的第一印象是"把 Transformer 层跑几遍"。这个理解不算错，但离能用还差很远。真正值得弄清楚的是：为什么要把同一组权重反复使用、循环次数到底改变了模型的什么能力、训练时显存为什么突然不够、推理阶段改一下循环次数结果为什么会漂移。这类结构常被归到"参数共享的迭代深度模型"里，和 Universal Transformer、深度均衡模型（Deep Equilibrium）属于同一条思路谱系。标题里提到的 Neural Breakdown with AVB，指的是用逐块拆解、可视化中间状态的方式讲神经网络结构的那类内容，它的价值在于把"一层层堆叠"的直觉换成"同一个函数被反复调用"的直觉。下面按概念、数学形式、最小实现、参数调节、排错链路、工程落地六个部分展开，代码基于 PyTorch，读者只要有一个能跑通 torch 的环境，就能把文中示例完整复现一遍，并观察循环次数对损失和显存的实际影响。

1. 循环 Transformer 到底在循环什么

1.1 从"堆层数"到"重复用同一层"

标准 Transformer 的深度是靠堆不同的层实现的：第 1 层有自己的一套 Q/K/V 投影矩阵，第 2 层有另一套，第 32 层又是另一套。层数越多，参数越多，显存占用越大。这种做法的隐含假设是：网络的每一层需要学习不同的变换，浅层做局部特征，深层做语义组合，各司其职。

Looped Transformer 换了一个假设：如果每一层做的事情在抽象层面是相似的，那能不能只保留一套参数，然后让它反复作用在同一个隐状态上？形式化地讲，标准 Transformer 是

code复制h = f_L(f_{L-1}(...(f_1(x))))

而循环 Transformer 是

code复制h = f(f(...f(x)))

其中 f 是同一个函数，参数完全共享，调用次数 T 是一个可以独立于参数量调节的超参数。这个改动带来的直接结果是：模型的"参数量"和"计算深度"被解耦了。你可以用一个 6 层参数量的模型，跑出 24 层甚至 48 层的计算图。

这个解耦在工程上有很实际的意义。参数量决定了模型文件大小、加载内存和单步计算量；计算深度决定了模型在一次前向里能做多少轮"信息整合"。传统做法里这两者被绑定死了，想加深就必须加参数；而在循环结构里，你想加深只需要多跑几次循环，参数量不变。

这里有个容易误解的点：循环不等于简单地重复计算得到相同结果。因为每次循环的输入是上一次的输出，中间还有 LayerNorm、残差连接和注意力重算，所以第 2 次循环看到的是一个已经被变换过的隐状态，输出必然不同。真正"相同"的只有参数，不是数据流。

1.2 共享权重带来的参数量与计算量解耦

把这件事说得再具体一点。假设一个 Transformer 块的参数量是 P，堆 12 层就是 12P，堆 24 层就是 24P。改成循环结构后，无论循环 1 次还是 24 次，参数量始终是 P（外加嵌入层和输出头）。

我们用一个最小例子实测一下这个差异。下面这段代码统计两种结构的参数量，可以直接在 Python 里跑：

python复制import torch
import torch.nn as nn

class Block(nn.Module):
    def __init__(self, d_model=128, nhead=4, dim_ff=512, dropout=0.1):
        super().__init__()
        self.attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout, batch_first=True)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.ff = nn.Sequential(
            nn.Linear(d_model, dim_ff),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(dim_ff, d_model),
        )
        self.drop = nn.Dropout(dropout)

    def forward(self, x, attn_mask=None):
        h = self.norm1(x)
        a, _ = self.attn(h, h, h, attn_mask=attn_mask, need_weights=False)
        x = x + self.drop(a)
        x = x + self.drop(self.ff(self.norm2(x)))
        return x

def count(m):
    return sum(p.numel() for p in m.parameters())

print("stacked x6 :", count(nn.Sequential(*[Block() for _ in range(6)])))
print("looped  x1 :", count(Block()))

跑出来的结果会显示：堆叠 6 层的参数量大约是单个块的 6 倍，而循环结构的参数量就是单个块本身。但两者的前向计算量在循环 6 次时是接近的（循环结构每轮还多了一点归一化开销）。

这个对比说明了一个关键取舍：循环结构省的是参数，不是算力。如果你的瓶颈是显存装不下大模型，循环结构能帮上忙；如果你的瓶颈是推理延迟，循环结构反而可能更慢，因为同样的计算量要用更少的并行度去完成。判断标准很简单，先问自己"我缺的是参数容量还是计算预算"，答案不同，选型就不同。

1.3 与 Universal Transformer、深度递归模型的谱系关系

循环 Transformer 不是一个孤立的想法，它和几类结构共享同一套直觉，但在细节上差别不小。整理成表格更容易看清边界：

从表里能看出三者的核心差别在"怎么停下来"和"怎么反传"。Universal Transformer 引入了自适应计算时间（ACT），让每个位置自己决定什么时候停止；深度均衡模型干脆迭代到隐状态不再变化，然后用隐函数定理算梯度，完全不用保存中间层；Looped Transformer 一般是最朴素的一档——固定循环次数，老老实实展开反传。

选哪一档取决于你能接受多少实现复杂度。固定循环次数的版本改十几行代码就能跑起来，调试成本最低；ACT 要引入停机概率和额外正则项，调参敏感；DEQ 需要保证迭代收敛，还得处理不收敛时的兜底逻辑，通常只在显存极其紧张时才值得上。

注意：循环结构和"模型变深一定更强"不是等价关系。循环次数增加会放大数值误差，也可能让隐状态在反复变换中丢失细节。上线前一定要用固定循环次数做一次基线对比，而不是默认次数越多越好。

2. 数学形式与工作机制：一次循环里发生了什么

2.1 前向过程的状态更新公式

把循环 Transformer 的前向过程写清楚，后面调参和排错才有依据。设输入 token 序列为 x，嵌入维度为 d，位置编码为 Pos，则：

code复制h_0 = Embed(x) + Pos
h_{t+1} = Block(h_t; θ)        t = 0, 1, ..., T-1
y = Head(LayerNorm(h_T))

这里 θ 在所有 t 上共享，T 是循环次数，Block 内部包含多头自注意力、前馈网络、两次 LayerNorm 和残差连接。注意一个细节：残差连接是 x = x + Attn(LN(x)) 这种形式，意味着循环过程中信息的"主干道"一直在累加，这就是为什么即使循环很多次，隐状态也不会完全被冲掉——残差保证了原始信息有直达通道。

位置编码一般只在 h_0 注入一次。有些实现会在每一轮循环重新注入位置编码，效果上相当于每轮提醒模型"你现在处理的是哪个位置"，在长序列任务上更稳一些，但会增加一点计算。这个选择没有绝对优劣，取决于你的任务对位置信息的敏感程度。

还有一个常被忽略的细节：循环块内部是否共享 LayerNorm 参数。共享是默认做法，但如果发现训练不稳定，可以让每一轮循环使用独立的 LayerNorm 参数（参数量增加很少，只有 2×d 个），往往能缓解发散。这是一个成本低、收益明显的调整点。

2.2 三种停止条件：固定次数、自适应停机、不动点

停止条件决定了模型"什么时候算完"，这是循环结构里设计空间最大的部分。

第一种是固定循环次数。训练和推理都用同一个 T，简单直接，实现成本最低。缺点是所有输入都用同样的计算量，简单样本可能被过度计算，复杂样本可能算得不够。

第二种是自适应计算时间（ACT）。每一轮循环后，模块额外输出一个停机概率 p_t，把所有位置的累计停机概率加起来超过阈值 1-ε 就停止。为了让模型不要无脑多算，需要加一个 ponder cost 正则项，形式大致是 ponder = mean(剩余未停机的比例)，总损失变成 loss = task_loss + τ * ponder。τ 越大，模型越倾向于早停、少算。这个机制的好处是不同位置可以有不同深度，坏处是训练不稳定，τ 很难调。

第三种是不动点迭代。不停循环直到 ||h_{t+1} - h_t|| < ε，然后用隐函数定理算梯度。好处是显存占用与循环次数无关，坏处是必须保证迭代收敛，实际工程里要认真设计收敛判据和最大迭代上限，不然会出现推理时间不可控。

对大多数团队来说，从固定次数起步是最稳妥的路径：先跑通、拿到基线，再考虑要不要上自适应。

2.3 反向传播：BPTT 与循环带来的梯度问题

固定循环次数时，反向传播就是把计算图展开，和普通深层网络没区别，也就是常说的沿时间反向传播（BPTT）。问题在于显存：循环 T 次就要保存 T 份中间激活。T=8 时还好，T=32 时显存会成倍上涨，这就是很多人第一次跑循环模型时 OOM 的直接原因。

缓解手段主要有三种。一是梯度检查点（gradient checkpointing），只保存每轮的输入，反向时重算中间激活，用时间换显存，通常能省 50% 以上的激活内存。二是截断反传，只对最后 k 轮反传梯度，前面几轮 detach 掉，相当于承认"远期循环的梯度贡献不大"。三是改用隐式微分，彻底不保存中间态。

除了显存，梯度本身也有问题。共享参数在展开图里出现 T 次，等效于同一个参数收到 T 份梯度累加，这让有效学习率被放大了。实践中常见的做法是把学习率按循环次数适当调小，或者加更长的 warmup，让模型先在小梯度下找到方向。

3. 用 PyTorch 写一个最小可运行的循环 Transformer

3.1 环境准备与依赖版本

示例只依赖 PyTorch，不需要额外库。环境要求如下：

如果本地没有 GPU，把代码里的 device 全部改成 cpu 即可，示例的训练任务规模很小。安装命令：

bash复制pip install torch --index-url https://download.pytorch.org/whl/cpu
pip install numpy

如果有 CUDA 环境，按本机驱动版本选择对应的安装命令，装完后用下面这段代码确认环境和设备：

python复制import torch
print(torch.__version__)
print("cuda available:", torch.cuda.is_available())
print("device count:", torch.cuda.device_count())

检查点很明确：版本号打印出来不低于 2.0，cuda available 为 True 表示 GPU 可用。如果为 False 但机器有显卡，通常是装成了 CPU 版本，需要重装。

3.2 核心模块实现

下面给出完整的模型定义。设计上分成三部分：前置层（嵌入 + 位置编码）、循环块、输出头。前置层和输出头各只有一份参数，循环只发生在中间的块上，这是最常见的划分方式。

python复制import math
import torch
import torch.nn as nn

class LoopedBlock(nn.Module):
    """可复用的循环块：自注意力 + 前馈，Pre-LN 结构"""
    def __init__(self, d_model, nhead, dim_ff, dropout=0.1):
        super().__init__()
        self.attn = nn.MultiheadAttention(
            d_model, nhead, dropout=dropout, batch_first=True
        )
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.ff = nn.Sequential(
            nn.Linear(d_model, dim_ff),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(dim_ff, d_model),
        )
        self.drop = nn.Dropout(dropout)

    def forward(self, x, attn_mask=None):
        h = self.norm1(x)
        a, _ = self.attn(h, h, h, attn_mask=attn_mask, need_weights=False)
        x = x + self.drop(a)
        x = x + self.drop(self.ff(self.norm2(x)))
        return x


class LoopedTransformer(nn.Module):
    def __init__(self, vocab_size, d_model=128, nhead=4, dim_ff=512,
                 n_loops=4, max_len=128, dropout=0.1):
        super().__init__()
        self.n_loops = n_loops
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(max_len, d_model)
        self.block = LoopedBlock(d_model, nhead, dim_ff, dropout)
        self.norm_out = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size)
        self.d_model = d_model

    def forward(self, idx, n_loops=None, detach_every=None):
        B, T = idx.shape
        pos = torch.arange(T, device=idx.device).unsqueeze(0)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        mask = torch.triu(
            torch.full((T, T), float("-inf"), device=idx.device), diagonal=1
        )

        loops = self.n_loops if n_loops is None else n_loops
        for i in range(loops):
            x = self.block(x, attn_mask=mask)
            # 可选：每隔 detach_every 轮截断一次梯度
            if detach_every and (i + 1) % detach_every == 0:
                x = x.detach()
                x.requires_grad_(True)
        return self.head(self.norm_out(x))

几个关键点在代码里体现出来了：

• attn_mask 用的是上三角全负无穷的浮点掩码，保证因果性，训练语言模型时不能省。
• n_loops 在 forward 里是参数，可以覆盖初始化时的默认值。这一点很重要，它让"训练时随机循环次数"变得可行。
• detach_every 实现了截断反传。它不是必须的，但显存紧张时很有用。
• 前置层和输出头独立于循环块，这样嵌入和输出映射只学一次，循环块专注做变换。

3.3 训练脚本与随机循环次数

先准备一段小语料做字符级语言建模，这样不用下载数据集也能跑通。训练时用一个小技巧：每一批随机采样循环次数，让模型见过不同的深度。

python复制import random

text = (
    "the looped transformer reuses a single block many times. "
    "each pass refines the hidden state. deeper computation does not "
    "always mean better results, so the loop count must be tuned. "
    "a small model with shared weights can still behave like a deep one. "
) * 20

chars = sorted(set(text))
stoi = {c: i for i, c in enumerate(chars)}
itos = {i: c for c, i in stoi.items()}
data = torch.tensor([stoi[c] for c in text], dtype=torch.long)

vocab_size = len(chars)
block_size = 64
device = "cuda" if torch.cuda.is_available() else "cpu"

def get_batch(bs=32):
    ix = torch.randint(0, len(data) - block_size - 1, (bs,))
    x = torch.stack([data[i:i + block_size] for i in ix])
    y = torch.stack([data[i + 1:i + block_size + 1] for i in ix])
    return x.to(device), y.to(device)

model = LoopedTransformer(vocab_size, n_loops=4, max_len=block_size).to(device)
opt = torch.optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.01)
loss_fn = nn.CrossEntropyLoss()

for step in range(1, 401):
    x, y = get_batch()
    # 训练时随机循环 2~6 次，提升对不同深度的鲁棒性
    loops = random.randint(2, 6)
    logits = model(x, n_loops=loops)
    loss = loss_fn(logits.reshape(-1, vocab_size), y.reshape(-1))

    opt.zero_grad(set_to_none=True)
    loss.backward()
    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
    opt.step()

    if step % 50 == 0:
        print(f"step {step:4d} | loops {loops} | loss {loss.item():.4f}")

这里的随机循环次数不是装饰。如果训练时永远用 4 次，推理时改成 8 次，模型看到的是没见过的计算深度，输出分布会偏。随机采样让模型在训练阶段就见过 2 到 6 的各种深度，推理时在这个区间内调整才比较安全。

3.4 运行验证与预期输出

在 CPU 上跑几百步，应该能看到损失从 4.2 左右（ln(vocab_size) 的量级）稳定下降到 1.0 以下。输出类似：

code复制step   50 | loops 5 | loss 2.8713
step  100 | loops 3 | loss 1.9246
step  150 | loops 6 | loss 1.2308
step  200 | loops 4 | loss 0.8912
step  250 | loops 2 | loss 0.7405
step  300 | loops 5 | loss 0.6128
step  350 | loops 3 | loss 0.5482
step  400 | loops 6 | loss 0.4967

如果损失纹丝不动，先看学习率是不是太大导致前几步就发散了，再看 attn_mask 是否传对了位置。这两处是最常见的启动失败原因。

验证完成后，做一次固定循环次数的对比实验，观察不同深度的表现：

python复制@torch.no_grad()
def eval_loss(model, loops, iters=20):
    model.eval()
    total = 0.0
    for _ in range(iters):
        x, y = get_batch(bs=16)
        logits = model(x, n_loops=loops)
        total += loss_fn(logits.reshape(-1, vocab_size), y.reshape(-1)).item()
    model.train()
    return total / iters

for t in [1, 2, 4, 8, 16]:
    print(f"loops={t:2d} -> eval loss {eval_loss(model, t):.4f}")

典型的观察是：从 1 到 8 次，损失会明显下降；从 8 到 16 次，下降幅度变小甚至反弹。这条曲线的拐点，就是你这个问题上的合理循环次数。

4. 关键参数与训练策略

4.1 循环次数、宽度与参数量的取舍

循环模型的超参数里，最需要单独强调的是循环次数，因为它和其他参数的关系不是线性的。把常用参数整理成表：

其中一个常被低估的联动是：循环次数增加后，共享参数收到的梯度累加变多，等效学习率被抬高。所以从 n_loops=2 调到 n_loops=8 时，如果 lr 保持不动，很容易看到损失在几百步后开始抖动。稳妥的做法是把 lr 除以一个与循环次数相关的系数，或者拉长 warmup 步数。

另一个实用建议是让参数量的增长优先给 d_model，而不是给循环次数。加宽是每一轮都在受益，加循环只是多做了几轮同样的变换，边际收益下降得更快。

4.2 梯度控制：detach、梯度检查点与渐进式训练

循环次数一大，显存就成了主要约束。前面代码里已经预留了 detach_every，它在每 k 轮后切断一次计算图。对比一下不同策略的代价：

python复制# 策略一：完整展开，显存占用最高，梯度最准
logits = model(x, n_loops=8)

# 策略二：每两轮截断一次，显存约降一半
logits = model(x, n_loops=8, detach_every=2)

# 策略三：梯度检查点，用重算换显存
from torch.utils.checkpoint import checkpoint

策略三需要把循环体改成可以 checkpoint 的形式，示意如下：

python复制def forward_with_ckpt(model, x, n_loops):
    for _ in range(n_loops):
        x = checkpoint(model.block, x, use_reentrant=False)
    return model.head(model.norm_out(x))

use_reentrant=False 在新版本里是推荐写法，它支持更多场景（比如输入需要梯度、有随机性算子），也更省心。

还有一种是渐进式训练：先固定 n_loops=2 训到损失平稳，再切到 4，再切到 8。这样模型一开始不会因为展开太深、梯度太乱而卡住，后期再逐步加深。这个办法在循环次数超过 8 时特别有效。

4.3 学习率、warmup 与归一化位置

循环结构的训练稳定性对这两处特别敏感：学习率调度和归一化位置。

Pre-LN（先归一化再做注意力和前馈）几乎是必须的。Post-LN 在深堆叠时就要小心，在循环结构里更危险，因为残差主干上的数值会随着轮数不断放大，几轮之后激活值就可能爆掉。判断方法很简单，打印每轮循环后隐状态的范数：

python复制@torch.no_grad()
def trace_norm(model, x):
    B, T = x.shape
    pos = torch.arange(T, device=x.device).unsqueeze(0)
    h = model.tok_emb(x) + model.pos_emb(pos)
    for i in range(model.n_loops):
        h = model.block(h)
        print(f"loop {i + 1}: mean norm {h.norm(dim=-1).mean().item():.3f}")

正常情况下，范数应该在几轮内趋于稳定，而不是持续单调上涨。如果一路涨到几十上百，说明归一化位置或者初始化有问题。

学习率方面，推荐 warmup 至少占总步数的 5% 到 10%。循环模型在前几百步的梯度方向比普通 Transformer 更不稳定，warmup 给它一个缓冲期。梯度裁剪也别省，clip_grad_norm_ 设成 1.0 是个合理的起点。

注意：调循环模型时不要一次改多个量。先固定 d_model 和 lr，只动 n_loops 看损失曲线；确认深度收益之后，再回头动宽度。同时改两个以上参数，你无法判断收益来自哪一处。

5. 常见问题排查链路

5.1 损失不下降或训练早期发散

现象：训练了几百步，损失还在初始值附近抖动，或者前几十步就冲到 nan。

可能原因按排查顺序排：输入构造错误、掩码方向写反、学习率过大、Pre-LN 被误写成 Post-LN、循环次数超出模型承受范围。

检查方式从最小处入手。先确认输入和标签的错位关系是否正确，再打印前几批的损失，看初始值是不是接近 ln(vocab_size)：

python复制x, y = get_batch(bs=4)
logits = model(x, n_loops=2)
init = loss_fn(logits.reshape(-1, vocab_size), y.reshape(-1))
print("initial loss:", init.item(), "expected ~", math.log(vocab_size))

如果初始损失明显偏离 ln(vocab_size)，说明输出层的分布已经偏了，重点查初始化和最后一层归一化。如果初始值正常但很快发散，把 lr 降到 1e-4 再试，同时打开梯度裁剪。

错误写法与推荐写法对照：

python复制# 错误：Post-LN 写法，循环多轮时残差主干数值容易爆
x = self.norm1(x + attn_out)
x = self.norm2(x + ff_out)

# 推荐：Pre-LN 写法，归一化放在子层输入侧
x = x + attn_out(self.norm1(x))
x = x + ff_out(self.norm2(x))

为什么错：Post-LN 把归一化放在残差相加之后，每一轮都在压缩主干信号的尺度，循环次数一多，早期层的信息会被反复归一化掉，同时反向传播时梯度要穿过每一轮的归一化，数值稳定性差。Pre-LN 让残差主干保持"干净"的累加路径，深堆叠和循环结构都更稳。

5.2 显存随循环次数线性增长

现象：把 n_loops 从 4 改成 8，batch size 没变，直接 OOM。

原因很直接：展开反传要保存每一轮的中间激活，注意力部分的激活量还和序列长度平方相关。循环翻倍，激活基本翻倍。

排查方式先量化，用下面这段代码观察不同循环次数下的显存峰值：

python复制import torch

def peak_mem(n_loops, bs=8, T=64):
    if not torch.cuda.is_available():
        return None
    torch.cuda.empty_cache()
    torch.cuda.reset_peak_memory_stats()
    x = torch.randint(0, 100, (bs, T), device="cuda")
    logits = model(x, n_loops=n_loops)
    loss = logits.sum()
    loss.backward()
    return torch.cuda.max_memory_allocated() / 1024 ** 2

for t in [1, 2, 4, 8]:
    print(f"loops={t}: peak {peak_mem(t):.1f} MB")

处理方案按代价从小到大：先减小 batch size；再加 detach_every=2；再上梯度检查点；最后才考虑把循环次数降下来或者缩短序列长度。这里要提醒一点，detach_every 会削弱深层循环的梯度贡献，用它换显存之后要重新验证一遍效果，不能默认无损。

5.3 推理时改变循环次数导致输出漂移

现象：训练时固定 n_loops=4，推理时为了"效果更好"调到 8，结果生成质量反而下降，或者输出风格明显变了。

原因是分布外。模型在训练时只见过 4 轮的计算图，每一轮之后隐状态的数值分布都被这个深度塑造过；突然跑到 8 轮，隐状态进入了训练时没出现过的数值区间，后续的归一化和输出头就无法正确处理。

解决方案是在训练阶段就引入深度随机性，也就是 3.3 节里那个 random.randint(2, 6)。如果模型已经训完不方便重训，退一步的办法是把推理循环次数限制在训练时见过的区间内，并且在验证集上逐个试，选损失最低的那个，而不是凭直觉往上加。

python复制# 推理阶段：在训练见过的深度范围内搜索，而不是盲目加
best = None
for t in range(2, 7):
    l = eval_loss(model, t)
    print(f"loops={t} -> {l:.4f}")
    if best is None or l < best[1]:
        best = (t, l)
print("selected loops:", best[0])

这个排查链路的价值在于：它把"效果不好"这种模糊反馈，转成了"深度是否在训练分布内"这样一个可以量化验证的问题。

注意：循环次数不是推理时的免费旋钮。它和 dropout、温度系数一样，属于会改变输出分布的超参数，改动之后必须重新做一轮验证。

6. 工程落地建议与扩展方向

6.1 学习环境与生产环境的差异

学习环境里跑通一个循环 Transformer，和生产环境里上线，中间隔着一整套工程问题。把差异列清楚，比笼统地说"要注意生产环境"有用得多：

最容易被忽略的是"循环次数属于配置而非代码常量"这一条。一旦它写死在代码里，线上要临时降深度就得出新版本，成本很高。推荐把它做成启动参数或配置项，同时把实际使用的值打进日志，出问题时能立刻确认当时跑的是几轮。

另一条是推理延迟的可预测性。固定循环次数意味着延迟基本恒定；如果用了自适应停机，不同输入的延迟会不一样，P99 会明显高于平均值。容量规划时要按 P99 算，不能按平均值算。

6.2 上线前的可复用检查清单

下面这份清单可以直接放进项目的发布检查流程，逐条确认后再上线：

• 参数量与循环次数已记录在模型卡里，能说清"这个模型等效多少层"。
• 训练阶段使用了随机循环次数，或至少记录并固定了唯一的推理深度。
• 在验证集上完成了 n_loops 的扫描，保存了损失曲线，拐点位置有结论。
• 显存峰值已用最大 batch 和最大循环次数压测过，并留了至少 20% 余量。
• 梯度裁剪阈值、warmup 比例、学习率与循环次数的对应关系有文档。
• 截断反传（detach_every）如果开启，已做过开关对比实验，确认效果损失可接受。
• 推理服务的循环次数是可配置项，改动无需重新发版。
• 日志中记录了每次请求实际使用的循环次数和输入长度。
• 存在降级路径：显存不足或超时的情况下能自动降低循环次数而不是直接失败。
• 权重文件、配置文件、预处理脚本三者的版本号绑定发布。

清单里最容易被跳过的往往是倒数第三条。很多线上问题最后追到"当时循环次数被临时调过但没记录"，这类问题没有日志就只能靠猜。

6.3 还可以继续探索的方向

跑通固定循环次数之后，有几个方向值得继续深入。

第一个是自适应深度。把每轮的停机概率做出来，让简单输入少算几轮、复杂输入多算几轮。这对于输入难度差异大的场景（比如混合长短序列的批处理）收益明显，代价是训练调参成本上升。

第二个是循环块内部的结构改造。目前是"注意力 + 前馈"反复跑，可以试试在循环之间加入一个轻量的状态更新门控，让模型自己决定每一轮保留多少旧信息、吸收多少新信息。加门的参数量很小，但对深层循环的稳定性帮助不小。

第三个是和显存优化结合。如果目标是在单卡上跑很深的循环，深度均衡模型那条路值得研究——它把显存占用从"与深度成正比"变成"与深度无关"，虽然实现复杂，但在资源受限的场景下是真正解决问题的办法。

第四个方向是训练目标的设计。既然模型做了多轮计算，可以考虑在中间轮次也加辅助监督信号，比如第 2 轮、第 4 轮的隐状态也接一个轻量输出头算损失。这相当于给每一轮都提供梯度指引，能缓解深层循环梯度变弱的问题，做法简单，值得先试。

对新上手的人来说，最值得做的练习不是立刻去改结构，而是把第 4 节那组扫描实验认真跑一遍：固定其他所有参数，只改 n_loops，画出"循环次数 - 验证损失"和"循环次数 - 显存峰值"两条曲线。这两条曲线的形状，比任何结构讨论都更能告诉你循环 Transformer 在你的任务上到底值不值得用。