技术原理

混合分辨率的核心动机 在传统的Transformer中，所有token都被平等对待——无论这个token是高频细节（如图像中的边缘像素）还是低频概览（如文档的整体结构）。混合分辨率（Mixture of Resolutions）打破了这一平等假设：不同的token使用不同的空间/时间分辨率进行处理。 这一思想在视觉-语言模型（VLM）中尤为重要。图像中的不同区域对理解的重要性不同——主体区域需要高分辨率，背景区域可以使用低分辨率。 多尺度Transformer的基本架构 分层Tokenization 将输入转换为不同尺度的token序列： def multi_scale_tokenize(image, scales=[1, 0.5, 0.25]): """ 将图像编码为多个尺度的token序列 scales: 不同尺度的缩放因子 """ token_sequences = [] for scale in scales: # 缩放图像 scaled = F.interpolate(image, scale_factor=scale) # 分块编码 patches = patchify(scaled, patch_size=16) tokens = vision_encoder(patches) token_sequences.append(tokens) # 拼接所有尺度的token return torch.cat(token_sequences, dim=1) 分辨率路由器 使用路由器将token分配到不同分辨率处理路径： class ResolutionRouter(nn.Module): def __init__(self, d_model, n_resolutions=3): super().__init__() self.router = nn.Linear(d_model, n_resolutions) self.resolution_embeddings = nn.Parameter( torch.randn(n_resolutions, d_model) ) def forward(self, x): """ x: [batch, seq_len, d_model] """ # 路由分数 router_logits = self.router(x) # [batch, seq_len, n_res] router_probs = F.softmax(router_logits, dim=-1) # 选择分辨率 resolution_ids = router_probs.argmax(dim=-1) # [batch, seq_len] # 添加分辨率嵌入 resolution_emb = self.resolution_embeddings[resolution_ids] x = x + resolution_emb return x, resolution_ids 视觉-语言模型中的应用 高分辨率区域识别 在VLM中，系统需要识别图像中哪些区域需要高分辨率处理： ...

序列并行：解决超长序列的显存瓶颈 张量并行（TP）将模型参数切分到多个GPU，流水线并行（PP）将模型层切分到多个GPU，但两者都没有解决序列长度带来的显存问题。 当序列长度达到128K甚至1M时，即使使用TP和PP，每个GPU上存储的激活值仍然是 O(seq_len × hidden_dim)。序列并行（Sequence Parallelism, SP）正是为了解决这个问题——将序列维度也切分到多个GPU上。 序列并行的核心思想 基本切分 将序列维度切分到N个GPU上，每个GPU只处理 seq_len/N 个token： 原始序列: [t0, t1, t2, ..., t_{L-1}] GPU 0: [t0, t1, ..., t_{L/N-1}] GPU 1: [t_{L/N}, ..., t_{2L/N-1}] ... GPU N-1: [t_{L-L/N}, ..., t_{L-1}] 通信需求 序列切分后，LayerNorm和Dropout等逐token操作可以独立进行（无需通信），但注意力计算需要完整的序列信息——每个token的Query需要与所有token的Key/Value计算注意力。 这是序列并行的核心挑战：如何在不重新聚合完整序列的前提下完成注意力计算？ DeepSpeed-Ulysses 原理 DeepSpeed-Ulysses使用All-to-All通信来实现序列并行注意力： class UlyssesAttention(nn.Module): def __init__(self, d_model, n_heads, n_gpus): super().__init__() self.n_gpus = n_gpus self.local_heads = n_heads // n_gpus # 每个GPU只存储部分注意力头的参数 self.W_q = nn.Linear(d_model, self.local_heads * (d_model // n_heads)) self.W_k = nn.Linear(d_model, self.local_heads * (d_model // n_heads)) self.W_v = nn.Linear(d_model, self.local_heads * (d_model // n_heads)) self.W_o = nn.Linear(self.local_heads * (d_model // n_heads), d_model) def forward(self, x): # x的形状: [batch, local_seq_len, d_model] # 每个GPU持有序列的一部分 # 1. 本地计算QKV Q_local = self.W_q(x) # [batch, local_seq, local_heads * head_dim] K_local = self.W_k(x) V_local = self.W_v(x) # 2. All-to-All通信：重新排列序列和头维度 # 从 [batch, local_seq, local_heads, head_dim] # 到 [batch, global_seq, local_heads, head_dim] Q_global = all_to_all(Q_local, split_dim=1, concat_dim=2) K_global = all_to_all(K_local, split_dim=1, concat_dim=2) V_global = all_to_all(V_local, split_dim=1, concat_dim=2) # 3. 本地注意力计算（现在每个GPU有完整的序列，但只有部分头） attn_out = flash_attention(Q_global, K_global, V_global) # 4. All-to-All通信：将结果按序列切分回去 attn_local = all_to_all(attn_out, split_dim=2, concat_dim=1) # 5. 输出投影 output = self.W_o(attn_local) return output 通信分析 Ulysses需要2次All-to-All通信（前向）+ 2次All-to-All（反向）。 ...

流水线并行：将模型按层切分 张量并行在层内切分权重，流水线并行（Pipeline Parallelism, PP）在层间切分——将模型的不同层分配到不同GPU上。GPU 0持有第1-8层，GPU 1持有第9-16层，依次类推。 这种切分方式让每个GPU只需存储部分层的参数和激活值，极大降低了单GPU显存需求。但它引入了一个新问题：流水线气泡——不同GPU之间需要等待数据传递。 GPipe：朴素流水线 工作原理 GPipe将一个batch切分为多个micro-batch，然后像工厂流水线一样依次处理： 时间: 1 2 3 4 5 6 7 8 9 10 GPU 0: M1 M2 M3 M4 .. .. .. .. .. .. GPU 1: .. M1 M2 M3 M4 .. .. .. .. .. GPU 2: .. .. M1 M2 M3 M4 .. .. .. .. GPU 3: .. .. .. M1 M2 M3 M4 .. .. .. ↑ 前向完成 GPU 3: .. .. .. .. .. .. .. M4' M3' M2' M1' ← 反向 GPU 2: .. .. .. .. .. .. M4' M3' M2' M1' ... M1-M4是4个micro-batch的前向传播，M1’-M4’是反向传播。 ...

为什么需要张量并行？ 当模型参数量超过单GPU显存容量时，模型并行成为必需。张量并行（Tensor Parallelism, TP）是最常用的模型并行方式——将单个层的权重矩阵切分到多个GPU上，每个GPU计算一部分结果，然后通过通信合并。 NVIDIA的Megatron-LM提出了张量并行的标准方案，成为2026年大模型训练的基础设施。 张量并行的核心原理 线性层的切分 一个标准线性层 Y = XW，其中 W ∈ ℝ^{d×h}。将W切分为两个子矩阵有两种方式： 列切分（Column Parallel） 将W按列切分：W = [W₁, W₂]，每个GPU持有 W_i ∈ ℝ^{d×h/N} GPU 1: Y₁ = XW₁ ∈ ℝ^{n×h/N} GPU 2: Y₂ = XW₂ ∈ ℝ^{n×h/N} Y = [Y₁, Y₂] ∈ ℝ^{n×h} 列切分后，每个GPU独立计算Y的一部分列，最终通过All-Gather合并。但更聪明的方式是——不需要显式合并，因为后续操作可以利用分块结构。 行切分（Row Parallel） 将W按行切分：W = [W₁; W₂]，每个GPU持有 W_i ∈ ℝ^{d/N×h} GPU 1: Y₁ = X₁W₁ (X₁是X的前d/N列) GPU 2: Y₂ = X₂W₂ (X₂是X的后d/N列) Y = Y₁ + Y₂ (All-Reduce) 行切分后需要All-Reduce求和。 ...

训练大模型的显存困境 训练一个70B参数的模型，仅模型参数（FP16）就需要140GB显存。加上梯度（140GB）、优化器状态（Adam需要280GB）和激活值，总显存需求轻松超过600GB——即使8卡A100 80GB也无法满足。 在这些显存消耗中，激活值是最容易被忽视的部分。在标准反向传播中，前向传播的所有中间激活值都需要保存下来供反向传播计算梯度使用。对于70B模型、batch_size=4、seq_len=4096，激活值占用可达100GB以上。 梯度检查点（Gradient Checkpointing）通过"以时间换空间"的策略，大幅减少激活值的显存占用。 标准反向传播的显存分析 在标准反向传播中，每个操作的前向输出都需要被保存： 前向: x → Layer1 → a1 → Layer2 → a2 → Layer3 → a3 → Loss 保存: a1, a2, a3 (以及各层的中间状态) 反向: Loss ← ∂L/∂a3 ← ∂L/∂a2 ← ∂L/∂a1 ← ∂L/∂x 使用: 重新使用a3计算a2的梯度，重新使用a2计算a1的梯度，... 对于N层Transformer，每层的激活值大小为 O(batch × seq_len × hidden_dim)。所有层的激活值总和为 O(N × batch × seq_len × hidden_dim)，与层数线性增长。 梯度检查点的核心思想 选择性重计算 梯度检查点的核心洞察：不需要保存所有层的激活值，只需保存部分"检查点"层的输入，其余层的激活值在反向传播时重新计算。 检查点设置（每2层一个检查点）: 保存: x, a2, a4, a6, ... 前向: x → L1 → a1 → L2 → a2* → L3 → a3 → L4 → a4* → ... (* = 保存的检查点) 反向: 从a6*出发，重新前向计算a5, a4→计算梯度 从a4*出发，重新前向计算a3, a2→计算梯度 ... 显存-计算权衡 假设N层Transformer，每隔k层设置一个检查点： ...

激活函数的角色 激活函数是神经网络中引入非线性的关键组件。没有激活函数，多层线性变换的堆叠等价于单层线性变换——网络的表达能力将被严重限制。激活函数的选择直接影响模型的训练动态、收敛速度和最终性能。 在LLM时代，激活函数的演进从ReLU到GELU再到SwiGLU，每一步都带来了可测量的性能提升。 ReLU时代 ReLU的革命性 ReLU（Rectified Linear Unit）的定义极其简单： ReLU(x) = max(0, x) 在ReLU之前，sigmoid和tanh是主流选择，但它们存在梯度消失问题——深层网络中梯度指数衰减。ReLU的梯度在正区间恒为1，有效解决了梯度消失问题，使得深层网络的训练成为可能。 ReLU的缺陷 Dead ReLU问题：当输入持续为负时，ReLU的梯度为零，神经元将永久"死亡"无法恢复。这在学习率设置不当时尤为严重。 非零中心化：ReLU的输出始终非负，导致后续层的输入分布偏向正方向，影响梯度下降效率。 Leaky ReLU与变体 为解决Dead ReLU问题，多种变体被提出： def leaky_relu(x, negative_slope=0.01): """Leaky ReLU: 负区间保留小梯度""" return torch.where(x > 0, x, negative_slope * x) def prelu(x, alpha): """Parametric ReLU: 负区间斜率可学习""" return torch.where(x > 0, x, alpha * x) def elu(x, alpha=1.0): """ELU: 负区间平滑过渡到指数""" return torch.where(x > 0, x, alpha * (torch.exp(x) - 1)) 这些变体在CV领域有一定应用，但在LLM中几乎未被采用——LLM的激活函数走上了另一条路。 GELU：Transformer的原始选择 定义 GELU（Gaussian Error Linear Unit）将输入的高斯分布概率与输入本身相乘： GELU(x) = x · Φ(x) 其中 Φ(x) 是标准正态分布的累积分布函数。实践中常使用近似： def gelu(x): """精确GELU""" return 0.5 * x * (1 + torch.erf(x / math.sqrt(2))) def gelu_tanh_approx(x): """tanh近似（更快）""" return 0.5 * x * (1 + torch.tanh(math.sqrt(2/math.pi) * (x + 0.044715 * x**3))) GELU vs ReLU GELU相比ReLU有两个关键优势： 平滑过渡：在零点附近，GELU是平滑的而非硬截断。这使得梯度更连续，训练更稳定 随机正则化：GELU隐含了一种随机dropout机制——输入越大，被保留的概率越高。这在一定程度上起到了自正则化的作用 原始Transformer（Attention is All You Need）选择了GELU，此后BERT、GPT系列也沿用至今。 ...

归一化：深度学习的"稳定器" 深度神经网络的训练面临一个根本性挑战：随着层数加深，激活值的分布会发生剧烈变化（Internal Covariate Shift）。这种分布偏移导致上层需要不断适应下层的输出分布变化，学习变得困难。归一化层通过将激活值"拉回"到稳定分布，有效缓解了这一问题。 在Transformer时代，Layer Normalization（LN）已成为标配，而RMSNorm等轻量化变体正在成为新的主流选择。 Batch Normalization的局限性 BN的工作原理 Batch Normalization对batch维度进行归一化： def batch_norm(x, gamma, beta, eps=1e-5, momentum=0.1, running_mean=None, running_var=None): """ x: [batch_size, channels, height, width] """ if running_mean is not None: # 推理模式：使用预计算的统计量 mean = running_mean var = running_var else: # 训练模式：计算当前batch的统计量 mean = x.mean(dim=(0, 2, 3), keepdim=True) var = x.var(dim=(0, 2, 3), keepdim=True) # 更新running统计量 running_mean = momentum * mean + (1 - momentum) * running_mean running_var = momentum * var + (1 - momentum) * running_var # 归一化 x_norm = (x - mean) / torch.sqrt(var + eps) # 仿射变换 return gamma.view(1, -1, 1, 1) * x_norm + beta.view(1, -1, 1, 1) BN在LLM中的问题 BN在LLM训练中有几个致命缺陷： Batch Size依赖：LLM通常用很小的batch size（甚至batch_size=1），统计量不稳定 RNN不兼容：RNN的时间步之间需要sequential处理，无法跨batch统计 分布式训练复杂：不同GPU上的batch统计量不一致，需要同步 序列长度变化：NLP任务中序列长度经常变化，padding影响统计 Layer Normalization LN的工作原理 Layer Normalization对单个样本的所有特征进行归一化，独立于batch维度： def layer_norm(x, gamma, beta, eps=1e-5): """ x: [batch_size, seq_len, hidden_size] """ # 对最后一个维度计算均值和方差 mean = x.mean(dim=-1, keepdim=True) var = x.var(dim=-1, keepdim=True) # 归一化 x_norm = (x - mean) / torch.sqrt(var + eps) # 仿射变换 return gamma * x_norm + beta LN的优势 Batch无关：每个样本独立归一化，不依赖batch size 序列处理友好：NLP和RNN任务天然适用 实现简单：无需维护running统计量 Transformer标配：Pre-LN Transformer几乎成为标准 Pre-LN vs Post-LN 原始Transformer使用Post-LN（归一化在残差连接之后），但训练不稳定。Pre-LN将归一化移到残差分支内部： ...

剪枝：去除冗余参数 神经网络的过参数化是公认的事实——大量参数对输出的贡献微乎其微。剪枝（Pruning）通过移除这些"冗余"参数来减少模型大小和计算量。 在LLM时代，剪枝面临新的挑战：模型规模巨大使得重新训练成本高昂，且LLM的参数分布与传统CNN有显著不同。2026年的剪枝研究集中在如何在不重训或少量微调的前提下实现高稀疏率。 非结构化剪枝 基本原理 非结构化剪枝将单个权重置零，不改变模型结构。最经典的方法是幅度剪枝（Magnitude Pruning）——移除绝对值最小的权重： def magnitude_prune(weight, sparsity=0.5): """幅度剪枝：将最小幅度的权重置零""" # 计算阈值 threshold = torch.quantile(weight.abs().flatten(), sparsity) # 创建掩码 mask = (weight.abs() > threshold).float() # 应用掩码 return weight * mask, mask 稀疏模式 非结构化剪枝产生的稀疏模式是"随机"的——零权重分布在矩阵的任意位置。这种模式虽然理论上能减少参数量，但在标准GPU上无法获得实际加速——因为稀疏矩阵的乘法效率远低于密集矩阵。 2:4稀疏 NVIDIA Ampere及以后架构支持2:4结构化稀疏——每4个连续元素中恰好2个为零。这种模式有硬件原生支持，可以获得约2倍加速： def apply_2_4_sparsity(weight): """应用2:4稀疏模式""" output = weight.clone() # 将权重重排为 [N, 4] 的块 blocks = output.view(-1, 4) for i in range(blocks.shape[0]): block = blocks[i].abs() # 保留最大的2个，其余置零 top2_indices = block.topk(2).indices mask = torch.zeros(4, device=weight.device) mask[top2_indices] = 1 blocks[i] *= mask return output.view_as(weight) 2:4稀疏是非结构化和结构化之间的折中——有一定的结构约束（硬件加速），但保持了一定的灵活性。 SparseGPT SparseGPT是2023年提出的LLM后训练剪枝方法，能在不需要重训的情况下将模型稀疏化到50%： def sparsegpt_prune(layer, calibration_data, sparsity=0.5): """SparseGPT单层剪枝""" W = layer.weight.data # [out, in] H = compute_hessian(layer, calibration_data) # [in, in] H += torch.eye(H.shape[0]) * 0.01 # 正则化 # 逐列处理 for i in range(W.shape[1]): # 计算每个权重的"重要性"分数 importance = W[:, i].abs() ** 2 / H[i, i] # 选择保留的权重 n_keep = int(W.shape[0] * (1 - sparsity)) keep_indices = importance.topk(n_keep).indices # 对非保留权重进行补偿 mask = torch.zeros(W.shape[0], device=W.device) mask[keep_indices] = 1 # 重建误差补偿 err = (W[:, i] * (1 - mask)) / H[i, i] W[:, i+1:] -= err.unsqueeze(1) @ H[i, i+1:].unsqueeze(0) # 应用掩码 W[:, i] *= mask layer.weight.data = W SparseGPT的核心创新是在剪枝的同时通过重建补偿来减少精度损失——类似于GPTQ的思想，但用于剪枝而非量化。 ...

为什么LLM需要蒸馏？ 训练一个超大模型（如700B）然后部署它，成本极其高昂。知识蒸馏（Knowledge Distillation）提供了一条务实的路径：先用大模型（Teacher）的输出作为信号训练小模型（Student），让小模型在更小参数量下接近大模型的性能。 2026年，蒸馏已经成为大模型工程化的标准环节。DeepSeek-V3、Qwen-3等模型都大量使用了蒸馏技术，将超大模型的能力迁移到可部署的尺寸。 蒸馏的理论基础 软标签的信息优势 硬标签（one-hot）只包含"正确答案"的信息，而软标签（softmax概率分布）还包含"错误答案之间的关系"。例如，在分类"猫"时，软标签可能同时给出"狗"的概率0.1——这告诉Student模型"猫和狗在某种特征上是相似的"。 这种"暗知识"（Dark Knowledge）是蒸馏有效性的核心。Teacher模型的输出分布包含了其学到的类别间关系，这些信息在硬标签中完全丢失。 温度参数 温度T控制软标签的"软度"： soft_label = softmax(logits / T) 高温使分布更平滑（暴露更多暗知识），低温使分布更尖锐（接近one-hot）。实践中T通常设置为2-10。 LLM蒸馏的主要方法 1. Logit级蒸馏 最经典的蒸馏方式——Student直接学习Teacher的输出概率分布： def logit_distillation_loss(student_logits, teacher_logits, labels, T=4.0, alpha=0.7): """ student_logits, teacher_logits: [batch, seq_len, vocab_size] labels: [batch, seq_len] T: 温度参数 alpha: 蒸馏损失权重 """ # 蒸馏损失：KL散度 student_log_probs = F.log_softmax(student_logits / T, dim=-1) teacher_probs = F.softmax(teacher_logits / T, dim=-1) distill_loss = F.kl_div( student_log_probs.reshape(-1, student_logits.size(-1)), teacher_probs.reshape(-1, teacher_logits.size(-1)), reduction='batchmean' ) * (T ** 2) # 梯度缩放补偿 # 任务损失：交叉熵 task_loss = F.cross_entropy( student_logits.reshape(-1, student_logits.size(-1)), labels.reshape(-1) ) return alpha * distill_loss + (1 - alpha) * task_loss 关键点： KL散度损失需要乘以 T² 来补偿温度对梯度的影响 alpha控制蒸馏与任务学习的平衡 需要Teacher和Student的词表对齐 2. 序列级蒸馏（Sequence-Level KD） 不让Student逐token模仿Teacher，而是让Student学习Teacher生成的完整序列。具体做法是先用Teacher生成大量数据，然后用这些数据训练Student： ...

量化：用更少的比特做更多的事 LLM的参数量从7B到671B不断增长，但GPU显存的增长速度远跟不上。量化是缓解这一矛盾最直接的技术——用更少的比特表示模型参数和激活值，在不修改模型架构的前提下减少显存占用和加速推理。 2026年，量化技术已经形成了从INT4到FP8的完整谱系，每种精度都有其适用场景和工程权衡。 量化的基本原理 对称量化 将浮点数映射到整数的固定范围。以INT8为例： x_int8 = round(x_fp / scale) scale = max(|x_fp|) / 127 反量化：x_fp ≈ x_int8 × scale 非对称量化 引入零点偏移，处理分布不对称的情况： x_int8 = round((x_fp - zero_point) / scale) scale = (max(x) - min(x)) / 255 zero_point = min(x) 量化粒度 逐张量（per-tensor）：整个张量共用一个scale，最简单但精度损失大 逐通道（per-channel）：每个输出通道一个scale，精度好但额外参数多 逐组（per-group）：将通道分组，组内共用scale，是精度和效率的折中 def per_group_quantize(x, group_size=128): """分组量化""" original_shape = x.shape # 重排为 [out_features // group_size, group_size, in_features] x_reshaped = x.view(-1, group_size, original_shape[-1]) # 每组计算独立的scale scales = x_reshaped.abs().max(dim=1, keepdim=True).values / 127 # 量化 x_int8 = (x_reshaped / scales).round().clamp(-128, 127).to(torch.int8) return x_int8, scales def per_group_dequantize(x_int8, scales, original_shape): """分组反量化""" x_fp = x_int8.float() * scales return x_reshaped.view(original_shape) INT8量化 适用场景 INT8是最成熟的量化方案，几乎所有推理框架都原生支持。适用于： ...