1. 项目概述：当大模型推理遇上“堵车”，我们如何开辟“快车道”？

最近在折腾大模型部署和推理优化的朋友，估计没少被各种性能问题困扰。无论是用 vLLM 部署服务，还是用 Ollama 跑本地模型，一个绕不开的痛点就是： 推理速度慢，资源消耗大 。尤其是在处理长文本、复杂逻辑或者高并发请求时，那种“等待模型思考”的焦灼感，相信大家都深有体会。这背后的核心矛盾在于，大模型（LLM）的推理过程本质上是 串行且计算密集 的——每个新生成的 token 都依赖于前序所有 token 的计算结果，形成了所谓的“自回归”过程。这就好比一条只有单车道的盘山公路，车流（计算量）一大，必然堵得水泄不通。

传统的优化思路，比如量化、算子融合、KV Cache 优化，都是在“拓宽现有车道”或者“提升单车通行效率”上做文章。但今天要聊的 STOP（Structured Token Pruning with Learnable Internal Signals） 方法，思路更加激进：它试图在推理过程中， 动态识别并“剪掉”那些对最终输出贡献不大的“冗余”计算路径 ，从而在保证输出质量的前提下，显著提升推理速度。简单说，它不是让车跑得更快，而是 在车流中识别出那些可以提前下高速的车辆，为真正重要的车辆腾出道路 。这个方法尤其适合那些对实时性要求高，但又无法承受精度损失的场景，比如智能客服、代码补全、实时翻译等。

2. STOP 方法的核心设计思路：让模型学会“自我精简”

2.1 从“暴力计算”到“智能跳读”

要理解 STOP，首先要明白大模型在生成每个 token 时，内部到底发生了什么。以 Transformer 架构为例，模型在解码（生成）阶段，对于当前要预测的第 t 个 token，会经历以下关键步骤：

1. 输入嵌入 ：将上一个生成的 token 转换为向量。
2. 多层注意力与FFN计算 ：这个向量会依次流过模型的每一层（Layer）。在每一层中，它都会经过自注意力机制（Self-Attention）和前馈神经网络（FFN）的处理，与之前所有 token 的 Key-Value 缓存（KV Cache）进行交互，提取上下文信息。
3. 输出投影 ：最后一层的输出向量被投影到词表空间，通过 Softmax 得到下一个 token 的概率分布。

问题在于， 并不是每一层、每一个注意力头对当前 token 的生成都同等重要 。有些层的计算可能只是在做微调，或者处理一些与当前生成任务无关的通用特征。STOP 的核心思想就是： 能否在推理过程中，实时判断某一层（甚至某一层的部分计算）是否可以“跳过”（Prune），而不影响最终输出质量？

这听起来有点像我们人类阅读时的“跳读”技巧——快速扫过不重要的段落，聚焦于核心信息。STOP 就是试图让大模型也学会这种“跳读”能力。

2.2 可学习内部信号：模型的“自我感知”系统

那么，模型如何知道自己该在什么时候“跳读”呢？这就是 STOP 方法中 “可学习内部信号”（Learnable Internal Signals） 的精髓所在。

传统的剪枝方法（如权重剪枝、结构化剪枝）是静态的、离线的。它们在训练后或训练中一次性确定哪些神经元或连接不重要，然后将其永久移除。这种方法对于推理加速有效，但缺乏灵活性，无法根据当前输入动态调整。

STOP 则引入了一种 动态的、基于输入内容的决策机制 。具体来说，它在模型的某些关键位置（例如，每一层 Transformer Block 的输出之后）插入一个轻量级的、可学习的 决策网络 （通常是一个小型多层感知机 MLP 或线性层）。这个决策网络的任务是：

• 输入 ：接收当前层的输出特征（或其特征的某种摘要，如平均池化后的向量）。
• 输出 ：产生一个标量分数，或者一个二值化的决策信号（0/1）。
• 决策 ：这个信号用于判断是否应该跳过后续若干层的计算。例如，如果当前是第 L 层，决策网络输出“跳过”，那么模型将直接使用第 L 层的输出作为近似结果，绕过第 L+1 到第 N 层的计算，直接进行最后的输出投影。

这个决策网络就是“可学习内部信号”的载体。它需要在模型训练阶段（通常是微调阶段）与主模型 一同训练 。训练的目标是一个多任务目标：

1. 主任务损失 ：保证模型最终的预测精度（如语言建模的交叉熵损失）。
2. 效率损失 ：鼓励决策网络更多地输出“跳过”信号，以提升推理速度。这通常通过给“跳过”决策一个正奖励（或给“计算”决策一个负惩罚）来实现。
3. 一致性损失 （可选）：确保跳过某些层后的输出，与完整计算的输出在语义上尽可能接近，防止“跳读”导致输出偏离太远。

通过这种联合训练，决策网络学会了根据当前输入的语义内容和上下文，动态地做出“计算”或“跳过”的权衡，从而在精度和效率之间找到最优平衡点。

注意 ：这里的“跳过”并非完全不做任何事。一种更精细的实现是“早期退出”（Early Exit），即被跳过的层可能用一个极简的计算（如一个线性变换）来近似其功能，或者直接将前一层的输出传递下去。STOP 方法更侧重于对 并行推理路径 的剪枝，这涉及到对模型内部并行化计算图的优化。

3. 并行推理路径剪枝的深度解析

3.1 什么是“并行推理路径”？

在讨论剪枝之前，需要澄清“并行推理路径”的概念。这里说的“并行”并非指多GPU或分布式计算的数据/模型并行，而是指 模型内部计算图在逻辑上可以同时评估的多个分支或可能性 。

一个更贴近 STOP 原论文思想的解释是：在大模型解码的每一步，模型内部的状态可以看作在多个抽象的“推理路径”上演进。有些路径致力于深化对主题的理解，有些在处理语法结构，有些在积累常识。STOP 假设，对于给定的当前生成步骤， 只有一部分路径是活跃且必要的 。识别并剪除非活跃路径，就能节省计算。

从实现角度看，这可以映射到模型的不同组件：

• 注意力头剪枝 ：在多头注意力机制中，不同头捕获不同的依赖关系（如语法、语义、指代）。STOP 可以动态决定本次计算中哪些注意力头是冗余的。
• FFN 神经元子集激活 ：前馈网络通常维度很大。STOP 可以动态选择只激活 FFN 中一个稀疏的子集神经元。
• 层间跳跃 ：如前所述，直接跳过整个 Transformer 层。

STOP 方法中的“并行路径剪枝”，可以理解为 在每一个推理时间步，动态地为当前 token 选择一个最优的、稀疏化的子模型进行计算 。

3.2 剪枝决策的具体实现机制

决策网络的设计是核心。一个典型的实现方案如下：

1. 信号采集点 ：选择在每层 Transformer Block 的 LayerNorm 之后、残差连接之前的位置插入决策模块。因为这个位置的特征已经经过了本层核心计算（Attention + FFN）的加工，信息量比较丰富。

2. 决策模块结构 ：

   # 简化示例代码
   class StoppingDecisionModule(nn.Module):
       def __init__(self, hidden_size, bottleneck_size=64):
           super().__init__()
           # 一个轻量的瓶颈结构，减少计算开销
           self.compressor = nn.Linear(hidden_size, bottleneck_size)
           self.activ = nn.ReLU()
           # 决策头：输出一个标量logit
           self.decision_head = nn.Linear(bottleneck_size, 1)
           # 可选的补偿网络，用于修正跳过计算带来的偏差
           self.compensation = nn.Linear(bottleneck_size, hidden_size) if use_compensation else None
   
       def forward(self, layer_output):
           # layer_output: [batch_size, seq_len, hidden_size]
           compressed = self.activ(self.compressor(layer_output.mean(dim=1))) # 对序列维度做平均，得到样本级特征
           decision_logit = self.decision_head(compressed) # [batch_size, 1]
           decision = torch.sigmoid(decision_logit) # 得到0~1之间的“跳过概率”
           return decision
   

3. 决策执行 ：在推理时，设定一个阈值（如 0.5）。如果 decision > threshold ，则执行“跳过”操作。跳过操作的具体实现可以是：

   • 直接传递 ：将当前层的输出直接作为这一“块”的最终输出，绕过后续层。
   • 浅层补偿 ：通过决策模块中的 self.compensation 网络对当前输出做一个快速的线性变换，以模拟被跳过层的部分功能。
   • 路径累积 ：记录被跳过的层数，当累积跳过一定层数（如3层）后，强制执行一次完整计算，防止误差累积。

4. 训练策略 ：训练时需要引入稀疏性诱导。例如，在损失函数中加入决策概率的 L1 正则项 λ * |decision| ，鼓励 decision 趋近于0（跳过）。同时，需要平衡精度和效率。可以设计一个动态的目标函数： 总损失 = 任务损失 + β * (平均计算量 - 目标计算量)^2 ，其中平均计算量是决策信号的函数，通过调节 β 和目标计算量来控制加速比。

3.3 与现有加速技术的对比

为了更清晰地理解 STOP 的定位，我们将其与几种常见的大模型推理加速技术进行对比：

技术方法	核心原理	优化阶段	灵活性	额外开销	适用场景
量化 (Quantization)	降低权重/激活值的数值精度（如FP16 -> INT8）。	训练后/训练中	静态，对所有输入一致。	几乎无运行时开销，需适配算子。	通用场景，追求极致压缩与带宽节省。
算子融合/内核优化	合并多个计算操作，减少内核启动和内存访问。	编译/运行时	静态，依赖硬件和框架。	无额外模型开销。	底层优化，与其他方法互补。
KV Cache 量化与压缩	压缩自注意力中的 Key/Value 缓存，减少内存和带宽。	推理时	半动态，可根据序列长度调整。	极低。	长序列推理场景。
推测解码 (Speculative Decoding)	用小模型“草稿”多个token，大模型并行验证。	推理时	动态，依赖草稿模型质量。	需要额外草稿模型，并行验证有开销。	生成任务，追求单次生成多个token。
STOP (路径剪枝)	动态跳过模型中不重要的层或组件 。	推理时（决策网络需训练）	高度动态，输入依赖 。	有决策网络的计算开销，但远小于跳过的层。	计算密集型步骤，token级细粒度优化 。

可以看出，STOP 的优势在于其 输入自适应性 。它不像量化那样“一刀切”，而是根据当前处理的内容智能地分配计算资源。这与推测解码有相似之处，但 STOP 作用于模型内部，粒度更细（层/头级别），且不需要额外的草稿模型。

4. 实操部署与核心环节实现

4.1 环境准备与模型选择

假设我们基于 Hugging Face Transformers 库和 PyTorch 来实现一个 STOP 的概念验证。首先需要准备环境。

# 创建环境
conda create -n stop_experiment python=3.10
conda activate stop_experiment

# 安装核心依赖
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 根据CUDA版本调整
pip install transformers accelerate datasets evaluate peft
pip install wandb # 用于实验追踪（可选）

对于模型选择，为了快速实验，建议从较小的模型开始，比如 GPT-2 (small) 或 LLaMA-7B （需要授权）。这里以 GPT-2 为例，因为它结构清晰，易于修改。

4.2 修改模型架构：插入决策模块

我们需要修改 GPT-2 的 GPT2Block 结构。关键是在每个 Block 的末尾（输出给下一个 Block 之前）插入我们的决策模块。

import torch
import torch.nn as nn
from transformers import GPT2Model, GPT2Config

class StoppingDecisionModule(nn.Module):
    """轻量级决策模块"""
    def __init__(self, hidden_size, comp_size=128):
        super().__init__()
        self.hidden_size = hidden_size
        # 使用平均池化获取序列摘要，也可以使用CLS token或其它方式
        self.pool = nn.AdaptiveAvgPool1d(1)
        self.compress = nn.Sequential(
            nn.Linear(hidden_size, comp_size),
            nn.GELU(),
            nn.Dropout(0.1),
        )
        self.decision_head = nn.Linear(comp_size, 1)
        # 一个小的补偿网络，用于修正特征
        self.compensate = nn.Linear(comp_size, hidden_size)

    def forward(self, hidden_states):
        # hidden_states: [batch, seq_len, hidden]
        batch_size = hidden_states.size(0)
        # 池化： [batch, seq_len, hidden] -> [batch, hidden] -> [batch, comp_size]
        pooled = self.pool(hidden_states.transpose(1, 2)).squeeze(-1)
        compressed = self.compress(pooled)
        # 决策logit
        decision_logit = self.decision_head(compressed).squeeze(-1)  # [batch]
        # 补偿变换
        compensation = self.compensate(compressed).unsqueeze(1)  # [batch, 1, hidden]
        return decision_logit, compensation

class GPT2BlockWithStop(nn.Module):
    """带STOP决策的GPT2 Block"""
    def __init__(self, config, layer_id):
        super().__init__()
        # 原始的GPT2 Block
        self.block = GPT2Block(config)  # 这里需要从transformers导入并解构
        self.layer_id = layer_id
        # 决策模块
        self.stop_module = StoppingDecisionModule(config.n_embd, comp_size=64)
        self.stop_threshold = 0.5  # 可学习的阈值或固定值
        self.use_compensation = True

    def forward(self, hidden_states, **kwargs):
        # 1. 正常执行当前层
        output_states = self.block(hidden_states, **kwargs)
        # 2. 获取决策信号和补偿
        decision_logit, compensation = self.stop_module(output_states[0] if isinstance(output_states, tuple) else output_states)
        decision = torch.sigmoid(decision_logit)
        # 3. 训练和推理的不同行为
        if self.training:
            # 训练时，使用决策概率进行软性加权，使得梯度可以回传
            skip_prob = decision
            # 这里使用Gumbel-Softmax技巧来获得可微的“硬”决策近似，便于训练
            # 简化起见，我们可以将decision作为正则化目标，并让补偿始终生效但加权
            if self.use_compensation:
                final_output = output_states + skip_prob.unsqueeze(-1).unsqueeze(-1) * compensation
            else:
                final_output = output_states
            # 将决策值附加到输出，用于计算效率损失
            return final_output, decision
        else:
            # 推理时，硬决策
            skip = decision > self.stop_threshold
            batch_skip_mask = skip.unsqueeze(-1).unsqueeze(-1)  # [batch, 1, 1]
            if self.use_compensation:
                # 如果跳过，用补偿值替代原输出；否则用原输出
                final_output = torch.where(batch_skip_mask, compensation, output_states)
            else:
                # 如果跳过，直接传递输入？这太激进，通常需要补偿。这里仅作示例。
                final_output = torch.where(batch_skip_mask, hidden_states, output_states)
            return final_output, skip

# 注意：上述代码是高度简化的概念演示。实际中需要更精细地处理attention mask、position ids等，
# 并且需要集成到完整的GPT2模型中，管理多个Block的决策流。

4.3 训练策略与损失函数设计

训练是 STOP 方法成功的关键。我们需要设计一个联合损失函数。

class STOPTrainingLoss(nn.Module):
    def __init__(self, base_loss_fn, lambda_sparse=0.01, target_compute=0.7):
        super().__init__()
        self.base_loss_fn = base_loss_fn  # 通常是交叉熵损失
        self.lambda_sparse = lambda_sparse  # 稀疏性正则强度
        self.target_compute = target_compute  # 目标计算比例，希望平均有30%的层被跳过

    def forward(self, model_logits, labels, layer_decisions):
        """
        model_logits: 模型最终预测的logits
        labels: 真实标签
        layer_decisions: 列表，包含每个层返回的decision概率（训练时）或logits
        """
        # 1. 基础任务损失
        task_loss = self.base_loss_fn(model_logits.view(-1, model_logits.size(-1)), labels.view(-1))

        # 2. 稀疏性损失：鼓励决策为0（跳过）
        # layer_decisions 可能是每层每个样本的decision概率 [num_layers, batch_size]
        if isinstance(layer_decisions, list):
            all_decisions = torch.stack(layer_decisions, dim=0)  # [layers, batch]
        else:
            all_decisions = layer_decisions
        # 计算平均“计算概率”（1 - 跳过概率）。我们希望它接近 target_compute。
        compute_prob = all_decisions.mean()  # 这里decision是“跳过概率”，所以compute_prob = 1 - decision.mean()？需要根据定义调整。
        # 假设decision是“继续计算的概率”，那么：
        # sparse_loss = self.lambda_sparse * (compute_prob - self.target_compute).pow(2)
        # 更常见的做法是直接对decision值进行L1正则，鼓励其为0。
        sparse_loss = self.lambda_sparse * all_decisions.abs().mean()

        # 3. 一致性损失（可选）：确保跳过后的输出与完整计算输出接近。
        # 这通常需要在训练时进行两次前向传播（一次完整，一次带跳过），计算其隐藏状态的MSE。
        # 此处省略。

        total_loss = task_loss + sparse_loss
        return total_loss, task_loss, sparse_loss

训练流程要点 ：

1. 预热 ：先在不开启 STOP 决策（或固定不跳过）的情况下微调几个 epoch，让模型适应下游任务。
2. 联合训练 ：引入 STOP 决策模块和稀疏性损失，逐步增大 lambda_sparse ，让模型学会在保持性能的同时做出跳过决策。
3. 蒸馏引导 （可选）：使用原始完整模型作为教师，对插入 STOP 的学生模型进行知识蒸馏，用教师的中间层特征或输出分布来指导学生的决策，提升跳过后的输出质量。

4.4 推理部署与性能评估

训练完成后，我们需要一个支持动态跳过的推理引擎。

class STOPInferenceEngine:
    def __init__(self, model, tokenizer, max_len=128, threshold=0.5):
        self.model = model
        self.model.eval()
        self.tokenizer = tokenizer
        self.max_len = max_len
        self.threshold = threshold

    def generate(self, prompt_text):
        inputs = self.tokenizer(prompt_text, return_tensors="pt")
        input_ids = inputs.input_ids
        attention_mask = inputs.attention_mask
        past_key_values = None
        generated_ids = input_ids.clone()

        total_layers = len(self.model.transformer.h)  # 假设模型有transformer.h这个层列表
        layers_computed = 0
        layers_skipped = 0

        for step in range(self.max_len):
            with torch.no_grad():
                # 前向传播，收集每一层的决策
                outputs, skip_decisions = self.model(
                    input_ids=input_ids,
                    attention_mask=attention_mask,
                    past_key_values=past_key_values,
                    output_hidden_states=False,
                    use_cache=True
                )  # 假设model的forward返回了(logits, past_key_values, skip_info)
                next_token_logits = outputs[0][:, -1, :]
                past_key_values = outputs[1]
                skip_info = outputs[2]  # 假设是每层的跳过布尔值列表

                # 统计跳过情况
                for skip in skip_info:
                    if skip:
                        layers_skipped += 1
                    else:
                        layers_computed += 1

                # 采样下一个token
                next_token_id = torch.argmax(next_token_logits, dim=-1).unsqueeze(-1)
                generated_ids = torch.cat([generated_ids, next_token_id], dim=-1)
                input_ids = next_token_id
                attention_mask = torch.cat([attention_mask, torch.ones((1, 1), device=attention_mask.device)], dim=-1)

                if next_token_id.item() == self.tokenizer.eos_token_id:
                    break

        speedup_ratio = layers_computed / (layers_computed + layers_skipped) if (layers_computed + layers_skipped) > 0 else 1.0
        generated_text = self.tokenizer.decode(generated_ids[0], skip_special_tokens=True)
        return generated_text, speedup_ratio

# 使用示例
engine = STOPInferenceEngine(trained_model, tokenizer, threshold=0.6)
result, speedup = engine.generate("Once upon a time,")
print(f"生成结果: {result}")
print(f"计算层比例: {speedup:.2%} (加速约 {1/speedup:.2f}x)")

评估指标 ：

• 质量指标 ：在验证集上的 Perplexity (PPL)、任务特定指标（如翻译的BLEU，代码生成的EM）。
• 效率指标 ：
  • 计算量节省 ：实际执行的 FLOPs 或 Transformer 层数占总层数的比例。
  • 端到端延迟 ：生成固定长度文本的平均时间。
  • 吞吐量 ：每秒处理的 token 数。
• 权衡曲线 ：通过调整决策阈值，绘制“质量指标 vs. 计算量节省”的曲线，找到最佳操作点。

5. 常见问题、排查技巧与实战心得

5.1 决策模块引入的额外开销是否值得？

这是 STOP 方法面临的首要质疑。一个轻量的决策模块（如两个线性层）的计算量通常远小于一个完整的 Transformer 层（尤其是 FFN 部分）。例如，GPT-3 的一个 FFN 层有数万个神经元，而决策模块可能只有几百个。因此， 只要决策模块能成功预测“跳过”哪怕一层，其节省的计算量就足以覆盖自身的开销 。关键在于决策的准确率。如果决策模块总是预测“计算”，那么它就是纯开销。训练的目标就是最大化其“跳过的收益”。

实操心得 ：决策模块一定要设计得足够轻量。可以使用瓶颈结构，先降维再决策。在训练初期，可以给决策模块一个较高的学习率，让它快速适应。同时，稀疏性正则项 lambda_sparse 需要仔细调校，从一个很小的值开始逐步增加，观察任务损失和计算量的变化曲线。

5.2 如何防止“连锁跳过”导致的误差爆炸？

如果模型连续跳过太多层，中间表示的偏差可能会累积，导致最终输出完全错误。解决方案有几种：

1. 强制刷新 ：设定一个最大连续跳过层数（如3层）。达到这个限制后，下一层强制进行完整计算，以“校准”特征。
2. 自适应阈值 ：决策阈值不固定，而是根据已跳过的层数动态增加，越往后越难跳过。
3. 层次化决策 ：不是每层都做独立决策，而是将模型分成几个“块”（如每4层一个块），在块级别做决策。块内要么全算，要么全跳（用更复杂的补偿网络）。这减少了决策频率和误差累积点。

5.3 训练不稳定，任务损失和稀疏损失难以平衡

这是多目标优化的典型问题。

• 症状 ：任务损失飙升，或者稀疏损失降为零（模型从不跳过）。
• 排查 ：
  1. 检查梯度 ：分别查看决策模块和主干模型的梯度幅值。如果决策模块梯度消失，它就无法学习。
  2. 调整损失权重 ： lambda_sparse 是关键。可以尝试 课程学习 策略：前期 lambda_sparse=0 ，让决策模块先学会“观察”；中期逐步增加，引导它做稀疏决策；后期再微调。
  3. 引入辅助任务 ：除了最终输出损失，可以增加对中间层输出的约束（如一致性损失），为决策模块提供更丰富的学习信号。
  4. 使用 Gumbel-Softmax ：在训练时，使用 Gumbel-Softmax 技巧来近似离散的跳过/计算决策，使得梯度可以更好地回传通过决策步骤。

5.4 在不同任务和模型上泛化性如何？

STOP 决策模块是任务相关的。在一个任务（如代码生成）上训练好的 STOP 模型，直接用到另一个任务（如创意写作）上，效果可能会下降。因为不同任务对模型不同部分的依赖程度不同。

• 建议 ：如果要在多个任务上使用，可以考虑 多任务联合训练 决策模块，或者采用 元学习 的方式，让决策模块学会快速适应新任务。对于通用聊天模型，需要在海量、多样的数据上进行训练，以使决策模块获得泛化能力。

5.5 与现有推理框架（如 vLLM, TensorRT-LLM）如何集成？

这是工程化的关键。STOP 需要修改模型的前向传播逻辑，这与高度优化的推理内核可能存在冲突。

• 集成路径 ：
  1. 定制内核 ：最彻底但最复杂的方式。需要为支持 STOP 的模型编写定制的 CUDA 内核，在计算图中融合决策逻辑。
  2. Python/C++ 调度层 ：在框架的模型定义层面集成 STOP。例如，在 vLLM 中，可以修改 model_runner 或 model 的实现，在调用每个层之前检查决策。这会引入一些 Python 开销，但易于实现。
  3. 编译器支持 ：在深度学习编译器（如 TVM, MLIR）层面，将 STOP 的决策逻辑表示为计算图的条件分支，由编译器来优化执行。
• 当前现状 ：STOP 仍处于研究向工程落地的早期阶段。目前最可行的方式是在 Hugging Face 的 PreTrainedModel 基础上进行修改，利用 accelerate 进行推理。要融入 vLLM 等生产级框架，需要社区或框架开发者提供官方支持。

5.6 实战中的“踩坑”记录

1. 决策模块的位置至关重要 ：最初尝试将决策模块放在 Attention 之前，效果很差。因为 Attention 前的特征太“原始”，不足以做出好的跳过判断。放在 LayerNorm 之后、残差连接之前是经验上比较好的位置，这里的特征经过了本层加工，信息更丰富。
2. 批量推理的决策一致性问题 ：在一个 batch 中，不同样本的决策可能不同。这会导致张量形状不一致，无法进行批处理。解决方案是： 强制一个 batch 内所有样本执行相同的计算路径 （以最“昂贵”的样本为准），或者使用 掩码技术 来模拟跳过，但这会损失部分加速收益。这是动态稀疏化在推理时面临的主要工程挑战。
3. 校准阈值 ：训练时用的软决策，推理时用的硬阈值。这个阈值对性能影响巨大。 必须在验证集上进行网格搜索 ，找到在目标加速比下精度损失最小的阈值。不要想当然地用 0.5。
4. 对短序列不友好 ：STOP 的收益在生成长文本时更明显。对于非常短的 prompt 和生成，决策模块和跳过的收益可能无法覆盖其开销。在实际部署时，可以设置一个序列长度阈值，短于该阈值的请求走标准推理路径。

STOP 这类动态路径剪枝方法，代表了大模型推理优化从“静态压缩”向“动态智能调度”演进的重要方向。它不再把模型视为一个固定的计算图，而是一个可以根据输入内容动态调整的资源调配系统。虽然目前还存在训练复杂度高、工程集成难等问题，但其潜力是巨大的。对于有强烈实时推理需求，并且有能力进行模型微调的团队来说，现在正是开始探索和实验这类技术的好时机。从一个小模型（如 1B 参数）开始，在一个特定任务上尝试实现 STOP，你将会对大模型内部的计算动态有更深的理解，这份经验在未来模型越来越大、推理成本越来越高的背景下，会显得愈发珍贵。