企业官网建设流程全解析

你背过Attention(Q, K, V) = softmax(QK^T / sqrt(d_k)) V，但面试官让你在白板上写出完整的多头注意力模块，并且解释为什么QK^T之后要除以sqrt(d_k)，你却卡住了——这不是个例。

过去两年，我看了大量大模型算法岗的面经和准备资料，最明显的感觉是：“Transformer”已经是所有大模型岗位绕不过去的核心考点，但它被考察的方式正在从“背公式”转向“要工程理解”。面试官不再满足于你背诵《Attention Is All You Need》里的那张架构图，而是会追问：

• 因果自注意力里的mask是怎么实现的？
• 位置编码为什么要用正弦函数？现在流行的 RoPE、ALiBi 又改了什么？
• 训练 7B 模型，单卡显存不够，DDP、ZeRO、模型并行到底怎么选？
• 一个 Transformer 层的参数量怎么估算？一次前向传播的 FLOPs 怎么量级估算？

这些问题的共同特点是：它们无法靠背题解决，需要你真正把一条链路走通。本文用六个阶段，带你从自注意力原理一直推到多卡训练，覆盖大模型算法岗的完整核心技能栈。

1. 为什么 Transformer 是大模型算法岗的必考题

先做一个判断：如果你把大模型面试准备时间分成 100 份，Transformer 至少要占 60 份。

原因很简单。所谓大模型，大部分是指基于 Transformer 架构的模型。无论是 GPT 系列的 decoder-only，还是 BERT 系的 encoder-only，亦或是多模态方向常用的 ViT、Swin Transformer，底座都是 Transformer 或其变体。

面试官考察 Transformer，其实不只是在考察“你会不会这个模型”，而是在考察三件事：

第一，你是否有扎实的深度学习基础。Transformer 里包含 Embedding、LayerNorm、FFN、残差连接、Attention 机制，几乎是所有现代深度学习组件的大集合。

第二，你是否有工程化思维。从单卡模型到多卡训练，涉及显存估算、通信开销、梯度同步、混合精度，这些东西不是背几个公式就能应付过去的。

第三，你是否理解大模型的训练和推理瓶颈。为什么KV Cache能加速生成？为什么BF16混合精度能省一半显存？为什么ZeRO-3会把参数切分到不同 GPU？这些问题的起点都是对 Transformer 前向/反向过程的掌握程度。

所以，与其说“六阶段吃透 Transformer”，不如说是“用一条主线打通从模型原理到分布式训练的全部关键知识”。下面我们直接进入正题。

2. 阶段一：Embedding 与位置编码，模型的输入到底是怎么来的

很多同学准备 Transformer 时，习惯直接从注意力机制看起，结果被Q、K、V绕晕。我的建议是先看输入侧，因为那里更贴近实际工程，能建立直觉。

2.1 从 Token 到向量：Token Embedding

在 Transformer 出现之前，NLP 领域更常用的是 Word2Vec、GloVe 这类静态词向量。它们的最大问题是一词一向量，比如“苹果”无论在哪一句话里，向量都是同一个，无法区分“苹果手机”和“吃苹果”。

Transformer 的做法是：先把文本用分词器切成 token，然后通过一个可学习的 Embedding 矩阵查表，得到每个 token 的向量。

在实际代码里，这一步通常就是一行：

import torch import torch.nn as nn vocab_size = 32000 # 词表大小 hidden_size = 768 # 隐藏层维度，BERT-base 的经典配置 token_embedding = nn.Embedding(vocab_size, hidden_size) # 假设输入是 shape = [batch_size, seq_len] 的 token id 序列 input_ids = torch.randint(0, vocab_size, (2, 10)) # 模拟 batch=2, seq_len=10 embedded = token_embedding(input_ids) print(embedded.shape) # torch.Size([2, 10, 768])

这里真正值得留意的是：Embedding 层本身是一个大参数量来源。词表 32000、维度 768，就有约 2400 万参数。到 GPT 这类大模型里，词表到了 50000、50000 甚至更大，Embedding 矩阵可能占模型总参数的 10% 以上。

2.2 为什么需要位置编码

RNN 天然按时间步处理序列，Token 的顺序信息隐含在“先处理谁、后处理谁”的流程里。但 Transformer 的自注意力是“并行计算”的，输入顺序被彻底打乱——如果让模型直接处理["我", "爱", "你"]和["你", "爱", "我"]，在注意力计算里是完全等价的。

这就必须显式告诉模型每个 token 在什么位置。原始 Transformer 论文里用的是正弦位置编码：

PE(pos, 2i) = sin(pos / 10000^(2i/d_model)) PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))

设计这个公式有两个考虑：

• 直接用周期函数，可以让不同位置的编码有规律可循。
• 因为有三角函数恒等式，任意位置pos+k的编码可以表示为pos编码的线性函数，理论上模型更容易学会“相对位置”。

常见的 PyTorch 实现如下：

import torch import math def positional_encoding(max_len, d_model): pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) return pe.unsqueeze(0) # shape = [1, max_len, d_model]

2.3 现在大模型用什么位置编码

如果只看 2017 年的原始论文，面试官会觉得你停留在表面。现在主流大模型里，位置编码已经演进了很多版本，面试高频的是这三个：

其中 RoPE 是当前面试的重灾区。它的核心变化是：不直接给 Embedding 加位置向量，而是在计算Q和K时对它们做旋转操作，让内积自然包含相对位置信息。这样做的好处是，模型训练时见过的序列长度可以相对短一些，推理时可以外推到更长序列。

面试结论：提到位置编码，绝不能只说“加一个向量”，要能把正弦编码的局限、RoPE 的旋转思路、ALiBi 的偏置思路讲出来，才算过关。

3. 阶段二：自注意力机制，大模型最核心的“记忆”单元

自注意力是整个 Transformer 的心脏，也是面试问题最密集的地方。这里我建议不要一上来就看多头，而是先把手写单头缩放点积注意力彻底弄明白。

3.1 Q、K、V 到底是什么

先放下概念术语，用一个更直观的场景理解。

假设你在会议室里参加一场讨论，每个人都要发言，但发言前要“看看别人在聊什么，决定自己说什么”。这时候：

• Q（Query，查询）：代表“我现在关心什么”的向量。
• K（Key，键）：代表“每条信息是什么主题”的向量。
• V（Value，值）：代表“这条信息实际内容是什么”的向量。

注意力计算的第一步是用Q去和所有K做点积，得到一个“每个位置跟当前词的相关性分数”。第二步用softmax把分数变成权重。第三步用权重对V做加权求和，得到当前词的新表示。

这个过程实际上是在做一件事：让每个 token 学会从整个序列里选择性“提取”信息。在看翻译任务时，某个词需要融合远距离的同名词信息，注意力机制就能把远距离位置的权重拉高；在视觉任务里，某个像素需要关注同物体的其他像素，也是同一套机制。

3.2 为什么除以 sqrt(d_k)

面试必问。Attention(Q,K,V) = softmax(QK^T / sqrt(d_k)) V里的sqrt(d_k)是为什么？

这是因为Q和K的元素如果都是均值为 0、方差为 1 的随机变量，那么它们的点积结果方差近似等于d_k（向量维度），而不是 1。维度越大，点积结果的方差越大，容易被推到softmax的饱和区，造成梯度极小，难以训练。

除以sqrt(d_k)之后，点积结果的方差被拉回 1 附近，softmax不会一开始就进入饱和区。这是一个非常实际的稳定训练设计。

如果面试官再追问“为什么是sqrt(d_k)而不是d_k”，你可以答：因为要从方差角度把点积结果归一化到单位方差，sqrt(d_k)是线性点积的标准差量级。

3.3 手写单头自注意力

下面是最简版实现。为了完整性和可运行性，直接用 PyTorch 完成：

import torch import torch.nn as nn import torch.nn.functional as F class ScaledDotProductAttention(nn.Module): def __init__(self, d_k): super().__init__() self.d_k = d_k def forward(self, q, k, v, mask=None): # q, k, v: [batch_size, seq_len, d_k] scores = torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k, dtype=torch.float32)) # scores: [batch_size, seq_len, seq_len] if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) attn_weights = F.softmax(scores, dim=-1) output = torch.matmul(attn_weights, v) return output, attn_weights

3.4 自注意力里的 Mask 到底怎么加

大模型面试里，Mask 几乎是必然会被追问的细节。实际上有两种 Mask，用途完全不同：

• Padding Mask：把<pad>位置遮住，避免无效 token 参与注意力。
• Causal Mask（因果掩码）：Decoder 生成时，当前位置只能看到之前的位置，不能看到未来。这个 Mask 是上三角矩阵，对未来的位置填-inf。

很多同学面试时容易混淆：做文本分类用 Padding Mask；做 GPT 式生成用 Causal Mask。做 Seq2Seq 的 Decoder 时，两者经常要一起用。

Causal Mask 的构造方式也很简单：

seq_len = 5 causal_mask = torch.tril(torch.ones(seq_len, seq_len)).bool() print(causal_mask)

输出是一个下三角矩阵，True的位置表示可以参与注意力。在实际计算中，把False的位置填上-inf，softmax之后权重就为 0。

面试结论：能白板写出手写缩放点积注意力，并且能准确说出缩放因子、掩码逻辑，这一阶段才算通过。

4. 阶段三：多头注意力，为什么一个头不够

如果自注意力只有一套Q/K/V，就像团队里只有一个视角看问题，表达力有限。多头注意力的核心思想是：用多组 Q/K/V，让模型在不同的表示子空间里并行关注不同维度的信息。

以 8 个头为例，hidden_size = 768，每个头的维度d_k = 768 / 8 = 96。输入经过线性投影后，拆成 8 组，分别做注意力，最后拼回去再过一次线性层。

4.1 完整的多头注意力实现

import torch import torch.nn as nn import torch.nn.functional as F import math class MultiHeadAttention(nn.Module): def __init__(self, d_model, n_heads, dropout=0.1): super().__init__() assert d_model % n_heads == 0, "d_model 必须能被 n_heads 整除" self.d_model = d_model self.n_heads = n_heads self.d_k = d_model // n_heads self.w_q = nn.Linear(d_model, d_model) self.w_k = nn.Linear(d_model, d_model) self.w_v = nn.Linear(d_model, d_model) self.w_o = nn.Linear(d_model, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): batch_size, seq_len, _ = x.size() # 1. 线性投影后拆成多头 Q = self.w_q(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2) K = self.w_k(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2) V = self.w_v(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2) # 2. 缩放点积注意力 scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k) if mask is not None: scores = scores.masked_fill(mask == 0, float('-inf')) attn_weights = F.softmax(scores, dim=-1) attn_weights = self.dropout(attn_weights) context = torch.matmul(attn_weights, V) # 3. 拼接所有头，再经过输出投影 context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model) output = self.w_o(context) return output

这里要特别强调一句：

context = context.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)

很多新手在这步少写.contiguous()，然后报维度错误，因为transpose之后 Tensor 在内存中不是连续排布的，直接view会失败。

4.2 面试追问：多头并行效率

面试官经常问：多头既然相互独立，为什么不在 PyTorch 里用循环计算 8 次？

实际工程里，我们会把多头合并成一个维度更大的矩阵运算，用一次张量乘法完成所有头的计算。上面代码里的view + transpose其实就是这个思路：[batch, seq_len, d_model]先变成[batch, seq_len, n_heads, d_k]，再通过transpose变成[batch, n_heads, seq_len, d_k]，让注意力计算发生在最后两个维度上。这样 GPU 矩阵乘法是高度并行的，速度远快于 Python 循环。

4.3 面试追问：为什么多头能提升效果

不是简单的“参数更多所以更强”。多头让模型可以在不同子空间里学到不同类型的关系。比如在机器翻译里，某个头可能更多关注语法依赖，另一个头可能更多关注指代关系。多头的本质是增加表示能力的“多样性”，而不是单纯加深模型。

5. 阶段四：Transformer 完整结构，Pre-Norm 还是 Post-Norm

手写了注意力，接下来要把注意力放回完整的 Transformer Block 里。这一阶段的核心考点是残差连接、LayerNorm 和 FFN。

5.1 Encoder Block 的完整结构

一个标准的 Transformer Encoder Block 包含：

• 多头自注意力子层
• 残差连接 + LayerNorm
• 前馈神经网络（FFN）子层
• 残差连接 + LayerNorm

用代码表示就是：

import torch import torch.nn as nn class FeedForward(nn.Module): def __init__(self, d_model, d_ff, dropout=0.1): super().__init__() self.linear1 = nn.Linear(d_model, d_ff) self.linear2 = nn.Linear(d_ff, d_model) self.dropout = nn.Dropout(dropout) def forward(self, x): return self.linear2(self.dropout(F.gelu(self.linear1(x)))) class TransformerEncoderLayer(nn.Module): def __init__(self, d_model, n_heads, d_ff, dropout=0.1): super().__init__() self.self_attn = MultiHeadAttention(d_model, n_heads, dropout) self.ffn = FeedForward(d_model, d_ff, dropout) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): # Post-Norm 结构（原始 Transformer 论文里的结构） attn_output = self.self_attn(x, mask) x = self.norm1(x + self.dropout(attn_output)) ffn_output = self.ffn(x) x = self.norm2(x + self.dropout(ffn_output)) return x

5.2 Pre-Norm 和 Post-Norm：大模型面试的高频分水岭

原始 Transformer 用的是Post-Norm，也就是先残差相加再 LayerNorm。但后来的 GPT、LLaMA 等大模型几乎都改成了Pre-Norm，也就是先 LayerNorm 再做注意力/FFN，最后残差相加。

两者的差异：

面试官喜欢问：为什么现在大模型都用 Pre-Norm？

用直觉解释：Post-Norm 把恒等映射路径（残差连接）下方的输出也做了一次归一化，路径上没有“干净”的恒等连接；而 Pre-Norm 中残差支路的输入是原始向量，梯度更容易从深层直接传到浅层，训练更稳定。

5.3 FFN 的作用是什么

FFN 在 Transformer 里占了大约三分之二的参数，核心逻辑是对每个 token 的表示做非线性变换和维度扩展：

hidden_size=768, d_ff=3072 第一层线性变换：768 -> 3072 激活函数：GELU 第二层线性变换：3072 -> 768

这个“先升维再降维”的结构，可以理解为让每个位置的表示先映射到高维空间，再做非线性筛选，最后压缩回原维度。它给模型引入了注意力之外的表达能力，没有 FFN 的 Transformer 在实验里效果会明显下降。

5.4 为什么用 LayerNorm 而不是 BatchNorm

BatchNorm 在 NLP 里有三个问题：

• 文本序列长度不定，batch内有效 token 数量不稳定，统计均值和方差波动大。
• 训练和推理时 BatchNorm 行为不一致，推理时需要维护全局统计量。
• 对 batch size 敏感，小 batch 时效果差。

LayerNorm 不依赖 batch 维度，它是在每个 token 自己的隐藏维度上做归一化，无论序列长度和 batch 大小怎么变，计算都稳定。这也是为什么 Transformer 结构全用 LayerNorm。

6. 阶段五：从单卡到多卡训练，大模型算法岗的分水岭

前面的阶段主要围绕模型结构，到了这里才是真正的“大模型”考点。算法岗面试如果只考到 Transformer 结构，那还是“深度学习岗”；一旦聊到多卡训练、显存优化，才算进入“大模型岗”的范畴。

6.1 为什么单卡训不动大模型

以常见的 7B 参数模型为例：

• 参数用 FP16 存储，大约需要7B * 2 bytes = 14GB。
• 训练还需要保存梯度，同样约 14GB。
• Adam 优化器还要额外保存一阶动量（momentum）和二阶动量（variance），每个跟参数同尺寸，FP32 下大约7B * 4 bytes * 2 = 56GB。
• 还要加上激活值、临时变量等中间状态。

也就是说，仅仅训练一个 7B 模型，光优化器状态和梯度就有七八十 GB，单张 24GB 显存的 3090/4090 根本放不下。这还不算前向/反向计算的临时内存。

面试时常考的估算方式：

• 参数：参数量 * 字节数
• 梯度：同参数
• Adam 状态：参数量 * 字节数 * 2
• 激活值：跟 batch size、序列长度、层数强相关，通常用 activation checkpointing 来压缩

6.2 数据并行 DDP：最简单也最基础

DDP 的思路非常直接：每个 GPU 上复制一份完整的模型和优化器，各自计算梯度，再用 all-reduce 通信把梯度求和取平均，保证每张卡上的模型同步更新。

通信瓶颈在于每次迭代都要把所有梯度同步一次。整体通信量跟模型参数量成正比，不会因为卡数增多而减少。

6.3 ZeRO：把显存压力从“每卡”变成“全局”

ZeRO 是微软 DeepSpeed 的核心技术，解决的核心问题就是：每张卡都存一份完整参数和优化器状态的浪费。

它分三个阶段：

用一张通俗的图理解：DDP 是每个图书馆都存一套完整百科，ZeRO-3 是把百科拆成很多卷，每个图书馆只存自己负责的卷，查资料时再从其他馆借阅。

代价是通信量增加。参数和梯度需要在 forward 和 backward 过程中动态 gather。

6.4 张量并行与流水线并行

数据并行解决不了“单卡放不下模型”的问题，因此还需要模型并行：

• 张量并行（Tensor Parallelism）：把单个 Transformer 层按列或行切分到多张卡上。比如 768 维的 Linear 可以切成两块 384 维，分别放在两张卡上，计算结果再拼接。这种方式通信非常频繁，适合卡间通信带宽高的场景（如 NVIDIA NVLink）。
• 流水线并行（Pipeline Parallelism）：把模型的层分成多段，每张卡负责一段。比如 32 层 Transformer，4 张卡各负责 8 层。通信频率低，但存在“流水线气泡”（部分卡空闲等待）问题。

面试回答建议：先判断是显存容量不足还是训练速度不够，再选择方案。7B 模型单卡放不下但 8 卡很宽裕，用 ZeRO 或张量并行；百B 以上模型层数太多，流水线并行几乎是必须的。

6.5 一个最小 DeepSpeed 配置示例

如果项目里用 DeepSpeed，配置文件通常是这样的：

# ds_config.json { "train_batch_size": 32, "gradient_accumulation_steps": 4, "fp16": { "enabled": true }, "zero_optimization": { "stage": 2, "offload_optimizer": { "device": "cpu" } }, "optimizer": { "type": "AdamW", "params": { "lr": 1e-5, "betas": [0.9, 0.999], "eps": 1e-8, "weight_decay": 0.01 } } }

当显存仍然不足时，可以用 ZeRO-Offload 把优化器状态放到 CPU 内存里，但代价是训练速度下降，因为 CPU 和 GPU 之间有大量数据搬运。

面试时不需要逐项背配置，但要能说清每个关键字段的作用，尤其是zero_optimization.stage、offload_optimizer.device、gradient_accumulation_steps，这些直接关系到显存和速度的取舍。

6.6 混合精度训练总结

大模型训练基本都用混合精度，核心是：

• FP16/BF16 前向和反向：减少显存占用、显著加速计算。
• FP32 参数更新：避免小梯度被 FP16 精度丢失，保证训练稳定。
• Loss Scaling：防止梯度下溢到 0。

BF16 是当前大模型训练的主流，因为它和 FP16 相比有更大的指数范围，不容易出现梯度下溢，更适合大模型训练。

7. 阶段六：面试实战，把知识转成答题能力

前五个阶段是“懂”，第六阶段是“能答题”。大模型算法岗的面试考察题型通常是：手撕代码 + 原理追问 + 场景设计。

7.1 高频手撕题

• 手写 Scaled Dot-Product Attention
• 手写多头注意力模块
• 手写 Transformer Encoder 层
• 手写 Causal Mask
• 手写 RoPE 或解释其实现思路
• 给定参数量，估算训练所需显存

这些题目不会因为代码简单而不考。面试官真正想考察的是：你能不能在没有 IDE 的情况下写对reshape和transpose的维度推导，能不能注意到masked_fill的位置和float('-inf')的使用。

7.2 高频原理追问

7.3 关于 KV Cache 的一道经典题

生成任务里，每生成一个新 token，都需要重新计算之前所有 token 的Q/K/V。如果不缓存，序列长度每增加 1，计算量会线性增长，推理速度极慢。

KV Cache 的做法是：把历史 token 的 K 和 V 缓存起来，生成新 token 时只计算当前 token 的 Q/K/V，然后与缓存拼接去算注意力。代价是显存随序列长度线性增长，这也是长上下文推理的主要瓶颈。

面试里如果提到 KV Cache，最好能继续说一句：这也是为什么大模型推理通常比训练更敏感于显存容量。单看参数可能 13B 模型用 24GB 显卡也能推理，但序列稍微一长，KV Cache 直接爆显存。

8. 常见问题与排查思路

下面整理一些实践过程中高频出现的报错和排查方向，建议收藏备用。

9. 最佳实践与工程建议

9.1 动手训练一个小 Transformer

光学不练没有意义。建议先写一个最小 GPT 训练脚本，用莎士比亚作品或者随便一个英文语料，在单卡上跑一个小模型（2 层，4 头，128 hidden）。跑通一遍完整流程，你才能把“维度”真正搞清楚。

9.2 复现一个开源大模型的训练配置

可以选一个 7B 级别的开源模型，阅读它的训练配置代码。重点看：

• 位置编码用的是 RoPE 还是 ALiBi
• 架构是 Pre-Norm 还是 Post-Norm
• 训练用了什么并行策略，ZeRO 开到了第几阶段
• 学习率调度和周数设置

9.3 建立“参数-显存”计算直觉

面试和工程里，这都是一项硬技能。平时训练时随手估算：

• 这个模型多少参数量？
• 如果用 FP16 存参数，要多少显存？
• 用 Adam 训练，优化器状态额外要多少？
• 如果卡数增加一倍，ZeRO-3 下每卡显存大概降多少？

这类问题没有太多技巧，多算几次，直觉就出来了。

9.4 注意安全与授权边界

如果你打算在自己公司的 GPU 集群上做多卡训练实验，记得先确认机器资源、数据权限和模型授权。不要拿未知来源的模型权重直接上生产环境，也不要对未授权的数据进行训练。涉及分布式集群操作时，先在单机单卡环境下验证脚本，再逐步扩展到多卡。

10. 总结与后续学习路线

六个阶段，对应的是六层能力：

• 阶段一：Embedding 和位置编码，理解输入表示
• 阶段二：自注意力原理，理解 QKV 和缩放点积
• 阶段三：多头注意力实现，理解维度变换
• 阶段四：完整 Transformer 结构，理解 Pre-Norm/Post-Norm 和 FFN
• 阶段五：多卡训练，理解 DDP、ZeRO、混合精度和显存估算
• 阶段六：面试实战，把知识变成答题能力

这套路线不需要太多前置条件，只要会 PyTorch 基本张量操作，就能逐步推进。每一阶段都有明确的可验证产出：阶段二能写代码，阶段三能跑通，阶段五能看懂训练配置，阶段六能过面试。

下一步可以做的三件事：

第一，翻出 PyTorch 官方nn.Transformer源码，对照本文代码逐行读一遍，重点看官方实现里不同之处。

第二，找一份开源的 7B 模型配置，用transformers库加载并看它的config.json，把hidden_size、num_attention_heads、num_hidden_layers这些字段全部对应到本文讲的结构上。

第三，如果条件允许，在一台多卡机器上实际跑一次accelerate或 DeepSpeed 的示例，亲眼观察显存占用和训练速度变化。

大模型算法岗的面试题每年都在变，但底层知识的复利效应是稳定的。把 Transformer 这条线吃透，后面再看 Flash Attention、PagedAttention、MoE 这些进阶话题，你会发现它们都是在这条主线上长出来的枝叶。