走进GPU这座繁忙的工厂，你看到一条条流水线。神经网络的每一层都是一道工位：卷积工位的工人负责提取特征，ReLU工位的工人负责修剪数值，归一化工位的工人负责对齐数据范围。可工厂产量总是上不去——调度员（CPU）每让一道工位开工，都要扯着嗓子喊一声指令，这个“喊话”本身就要花掉几微秒；而每道工位做完的半成品，还要先搬去仓库（显存）存起来，下一道工位要用时再搬回来。喊话和搬运消耗了大量时间，工人们真正干活的工夫反而没剩下多少。 层融合（Layer Fusion）的思路，就是把相邻工位合并成一个“超级工位”：调度员只需喊一次口令，所有工序一气呵成；半成品不用进出仓库，直接在工位间手递手传递。喊话少了、搬运没了，GPU工厂的产量自然大幅提升。这篇文章就从这条流水线讲起，带你理解层融合的来龙去脉——它解决什么问题、靠什么机制工作、又能带来多大的性能收益。

岗位关联

掌握层融合原理是理解推理引擎优化的第一课。它能帮你剖析推理延迟的构成、预判模型的可优化空间，让GPU算力真正花在计算上，而不是空转在等待中。

目录
  1. 可视化演示
  2. 层融合是什么
  3. Kernel启动开销
  4. 中间结果存储
  5. 融合器识别
  6. 融合后优化
  7. 性能提升收益
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示垂直融合将相邻算子合并为单kernel的过程、融合前后计算与内存开销的代价模型对比以及寄存器压力约束。

本节配有交互动效（进入视口后自动加载，约 3KB）。

垂直融合(Vertical Fusion) 未融合：MatMul→Add→ReLU各为独立kernel，中间结果写回全局内存 融合后：三算子合并为单kernel，中间数据保留在寄存器 T_total = T_compute + T_memory_access 减少6次全局内存访问降至2次，加速约3倍

层融合是什么

走进一间GPU工厂，你会看到一条条流水线。每条线上摆着许多独立工位：这个工位负责“切料”，那个工位负责“打磨”，再下一个负责“抛光”。每道工序之间，半成品都要放到中转架上，等下一道工位的工人来取。工业工程师发现：如果两个工位挨得特别近、工序又衔接紧密，完全可以把它们合成一个“一体化工位”——工人不用来回走动，半成品也不用搬上搬下。层融合（Layer Fusion），就是神经网络里的“工位合并”。

神经网络推理时，模型被编译器表示成一张计算图（Computation Graph）：图上的节点是算子（也叫层），例如卷积、偏置、ReLU、归一化；节点之间的有向边代表张量数据流动的方向。推理引擎按拓扑顺序逐个执行这些算子，每个算子都要以 kernel 的形式提交给 GPU 运行。层融合要做的，就是把计算图中满足条件的相邻节点合并成一个节点，让多个算子的计算在同一个 kernel 内完成。

以最常见的组合“卷积+偏置+ReLU”为例：融合前需要三次 kernel 启动、两回中间结果写回显存；融合后变成 TensorRT 中的 CBR 融合核，一次启动、零中间访存。更一般地，一次推理的总耗时可以写成：

所以层融合的本质，就是“工位合并”。它不改变产品本身——计算结果保持数学等价，只改变生产方式——原本要分五次喊话的工序变成一次完成，原本要搬进仓库的半成品直接留在工位上。流水线的节拍变快了，GPU 工厂的每一分钟都花在了刀刃上。

T推理=∑i=1N(T启动(i)+T计算(i)+T存储(i))\displaystyle T_{\text{推理}} = \sum_{i=1}^{N} \left( T_{\text{启动}}^{(i)} + T_{\text{计算}}^{(i)} + T_{\text{存储}}^{(i)} \right)
总耗时 = 每一层的“启动开销 + 计算时间 + 存储开销”之和。融合的目标，就是尽可能消除启动和存储这两大项。
  1. N 表示网络总层数模型里算子的个数，N 越大模型越深，累加的项越多。
    N=计算图节点总数\displaystyle N = \text{计算图节点总数}
  2. i 是层索引从 1 遍历到 N，把每一层的时间逐项累加起来。
    i=1,2,…,N\displaystyle i = 1, 2, \ldots, N
  3. T_启动 是第 i 层的 Kernel 启动开销CPU 向 GPU 下发一条执行指令的固定时延，与这层算多少无关。
    T启动=CPU 调度 GPU 的固定耗时\displaystyle T_{\text{启动}} = \text{CPU 调度 GPU 的固定耗时}
  4. T_计算 是实际执行计算的时间GPU 计算单元完成该算子数学运算的耗时。
    T计算=该层算子在 GPU 上的执行耗时\displaystyle T_{\text{计算}} = \text{该层算子在 GPU 上的执行耗时}
  5. T_存储 是中间结果读写显存的时间每层输出写回显存、下一层再读回，画出的开销。
    T存储=中间张量写回 + 读出的访存开销\displaystyle T_{\text{存储}} = \text{中间张量写回 + 读出的访存开销}

Kernel启动开销

想象工厂里的调度员。每道工位开工前，调度员都要吹一声哨子：“工位1，开工！”工位1干完，半成品放上货架；调度员又吹哨：“工位2，开工！”哨声本身不生产任何东西，但每一道工序都要花时间等哨声。哨声吹得越勤，工人们真正动手干活的时间就越少。

在 GPU 推理中，这个“吹哨”就是 kernel 启动（Kernel Launch）。CPU 通过 CUDA 驱动把 kernel 指令写入命令队列，GPU 前端解析指令、分配资源、调度执行——整个过程大约要花 3 到 10 微秒。更关键的是，这是固定成本：不管你这一层是算一分钟还是一微秒，启动都要花同样的时间。如果算子本身很小（比如逐元素的 ReLU 只需几微秒就算完），启动开销甚至比计算时间还长。

我们把单层的启动开销占比记作 η：

当 η 接近 1 时，意味着 GPU 大部分时间在“等哨声”而不是在干活。深层网络有几十上百层，每一层都来这么一次，累计的空等时间非常可观。

融合之后，原本要吹五次哨子的工序，现在只吹一次。调度员的声音不再占据流水线的主旋律，工人们也能把全部精力集中在真正的加工动作上。这就是层融合对“哨声开销”的治理之道。

η=TlaunchTlaunch+Tcompute\displaystyle \eta = \frac{T_{\text{launch}}}{T_{\text{launch}} + T_{\text{compute}}}
启动占比 = 启动时间 ÷（启动时间 + 计算时间）。对逐元素类小算子，启动占比可超过 50%，融合正是要消灭这些“空等”。
  1. T_launch 是单次 Kernel 启动耗时从 CPU 下发指令到 GPU 真正开始执行之间的固定延迟。
    Tlaunch≈3∼10 μs\displaystyle T_{\text{launch}} \approx 3 \sim 10 \, \mu s
  2. T_compute 是实际计算耗时GPU 计算单元执行该算子需要的微秒数，小算子往往只有几微秒。
    Tcompute=算子实际执行耗时\displaystyle T_{\text{compute}} = \text{算子实际执行耗时}
  3. η 表示启动开销占比越接近 1，说明 GPU 越“闲”——大部分时间都在等待指令到达。
    η→1⟺GPU 大部分时间空等\displaystyle \eta \rightarrow 1 \quad \Longleftrightarrow \quad \text{GPU 大部分时间空等}

中间结果存储

工厂里最费时的工作往往不是加工，而是搬运。半成品做完一道工序，要装车（写回显存）、开到仓库（全局内存）、卸货；下一道工序要用时，再装车、开回来。一趟趟运输，既费油（带宽）又费时（时延），仓库门口还常常“堵车”。

神经网络每两个相连的算子之间，都会产生一个中间张量（Intermediate Tensor）。未融合时，每个中间张量都要完整地写回全局显存，再由下一个 kernel 读回来。显存带宽是 GPU 最宝贵的资源之一，而中间张量的读写恰恰是带宽消耗的大户。更糟的是，许多算子处在“内存密集”区——它们本身计算量很小，却要搬运海量数据，访存时间比计算时间还长。这就像工位上只加工了一秒钟，却要花五分钟把零件运去仓库再运回来。

设计算图的边集合为 E，第 e 条边上的中间张量大小为 S_e 字节，则一次前向推理的中间张量总读写量为：

其中"×2"是因为每份数据都要经历一次写入和一次读出。

融合后的“一体化工位”里，半成品再也不用装车去仓库了——它们直接在工位间手递手传递，数据待在 GPU 芯片内部的寄存器和共享内存里。仓库门口不再堵车，带宽压力大幅缓解，推理速度自然水涨船高。

M=∑e∈ESe×2\displaystyle M = \sum_{e \in E} S_e \times 2
中间张量总读写量 = 每条边上张量字节数 × 2（写一次读一次）。融合把这些读写搬到芯片内部的寄存器与共享内存，带宽压力骤减。
  1. E 是计算图的边集合每条边代表一层输出流向下一层的一次数据传递。
    E={e1,e2,…,em}\displaystyle E = \{ e_1, e_2, \ldots, e_m \}
  2. S_e 是第 e 条边上的张量字节数由该层输出的特征图尺寸×通道数×数据类型字节数共同决定。
    Se=H×W×C×bytes\displaystyle S_e = H \times W \times C \times \text{bytes}
  3. 乘以 2 表示写一次读一次写回显存算一次访问，下一个 kernel 读回又算一次，一共两次。
    每边访问次数=2\displaystyle \text{每边访问次数} = 2

融合器识别

工业工程师在改造流水线前，必须做一件重要的事：判断哪些工位能安全合并。打磨工位和抛光工位合并没问题，但焊接工位和喷漆工位合并就可能有安全隐患。这个“判断”的过程，靠的是工程师头脑里的规则库。

TensorRT 里也有这样一位“工业工程师”——融合引擎。推理引擎在构建优化图时，会遍历计算图，用模式匹配的方式扫描每个节点及其相邻节点，与内部的融合规则库逐一比对。规则库里记录了大量经过实验验证的安全融合模式，例如：卷积+偏置、卷积+偏置+ReLU、全连接+偏置、缩放+激活、归一化+激活+残差相加等。只有命中规则的组合才会被合并。

形式化地说，融合器对相邻层对 (L_i, L_{i+1}) 的决策可以写成：

其中 t_i 是第 i 层的算子类型。

工程师的规则书越厚，能合并的工位组合就越多，流水线就越精简。但每一页规则都经过严苛的安全测试——工位合并可以改变加工顺序，但绝不能明显改变最终成品的质量与精度。这份“安全至上”的谨慎，正是融合技术能够稳定落地的根本前提。

f(Li,Li+1)={1,(ti,ti+1)∈Rfuse0,otherwise\displaystyle f(L_i, L_{i+1}) = \begin{cases} 1, & (t_i, t_{i+1}) \in \mathcal{R}_{\text{fuse}} \\ 0, & \text{otherwise} \end{cases}
融合决策 = 查规则库：相邻两个算子的类型组合如果命中“可融合白名单”，就合并；否则保持原样。这份白名单由无数实验验证得出，安全第一。
  1. L_i 与 L_{i+1} 是相邻层计算图中存在直接数据依赖关系的两个算子节点。
    Li→Li+1数据流向\displaystyle L_i \rightarrow L_{i+1} \quad \text{数据流向}
  2. t_i 是第 i 层的算子类型例如 Conv、Bias、ReLU、LayerNorm 等。
    ti∈{Conv,Bias,ReLU,Norm,⋯ }\displaystyle t_i \in \{ \text{Conv}, \text{Bias}, \text{ReLU}, \text{Norm}, \cdots \}
  3. R_fuse 是融合规则库TensorRT 内置的已验证安全的算子组合集合。
    Rfuse={(Conv,Bias),(Conv,ReLU),⋯ }\displaystyle \mathcal{R}_{\text{fuse}} = \{ (\text{Conv}, \text{Bias}), (\text{Conv}, \text{ReLU}), \cdots \}
  4. 返回 1 表示融合，返回 0 表示不融合只有命中规则才合并，绝不破坏语义正确性。
    f=1⇒合并为单 kernel\displaystyle f = 1 \Rightarrow \text{合并为单 kernel}

融合后优化

超级工位建成后，里面的工人不再各干各的，而是组成一个紧密协作的小组：上一道工序的成品直接递到下一道工序手上，工具、材料都摆在触手可及的地方，不用再满车间跑动。

融合后的单个 kernel 正是如此。它内部串联了多个算子的计算逻辑，启动一次，就在 GPU 芯片内部依次完成所有步骤。中间数据被存放在寄存器（Register）和共享内存（Shared Memory）中——它们的读写速度比显存快一到两个数量级。计算完成之前，数据根本不会离开芯片；只有最终结果才会写回全局显存。这样一来，内存访问量大幅减少，数据局部性（Data Locality）极大改善。

从计算图的角度看，合并后图的节点数从 N 降到 M（M 远小于 N），图结构大幅简化，节省的启动时间为：

同时，算子聚合（Operator Fusion）会把计算模式进一步提炼，例如把“卷积+偏置+激活”压缩进同一个 kernel 的指令流，硬件只需一次加载权重、一次读取输入，计算和激活在寄存器里连续完成。

流水线变得又短又顺，产品从第一道工序到出厂，中间不需要任何等待和搬运。工人们的工作节奏更紧凑，机器的每一寸空间都被充分利用——这就是“超级工位”给 GPU 工厂带来的脱胎换骨。

ΔT=∑i=1NTlaunch(i)−∑j=1MTlaunch(j)\displaystyle \Delta T = \sum_{i=1}^{N} T_{\text{launch}}^{(i)} - \sum_{j=1}^{M} T_{\text{launch}}^{(j)}
融合后节省的时间 ≈ 被合并掉的（N−M）次 kernel 启动时间之和。图越深、算子越小，收益越明显。
  1. N 是融合前的算子层数也就是融合前需要启动的 kernel 个数。
    N=融合前节点数\displaystyle N = \text{融合前节点数}
  2. M 是融合后的 Kernel 数多个被合并的算子收敛成一个 kernel，M 明显小于 N。
    M≪N\displaystyle M \ll N
  3. ΔT 是省下的总启动时间前后启动开销相减，就是融合的直接时间收益。
    ΔT>0⇒启动开销减少\displaystyle \Delta T > 0 \quad \Rightarrow \quad \text{启动开销减少}

性能提升收益

改造完成后，工厂的产量报表让人眼前一亮：同样八小时的班次，产出的产品数量多了好几成，每件产品的出厂时间也大幅缩短。

具体到 GPU 推理，融合带来两方面的可量化收益。其一是单次推理延迟（Latency）降低：由于启动和访存被大量消除，数据在芯片内的流动路径更短，端到端的推理时间更快。其二是吞吐量（Throughput）提升：GPU 计算单元的利用率直接反映在单位时间内处理的请求数量上，利用率越高，同一时刻能并行处理的推理请求就越多。

如果融合前单次推理延迟为 T_before，融合后为 T_after，加速比可以写作：

实践中，含大量小算子的 CNN 模型经过层融合后，S 常常能达到 1.5 ~ 3 倍；对以卷积+激活为主体的检测、分割模型，收益尤为明显。这个提升直接转化为部署成本下降：同样的 GPU 能扛住更高的线上流量，或者用更少的机器支撑同样的服务。

工厂交付的产品更快、更稳，客户满意度提升了，运营成本反而降下来了。这也是为什么在真实的 AI 推理部署中，层融合几乎是必开的一项优化——它用最小的配置改动，换来最直观的产量提升。

S=TbeforeTafter\displaystyle S = \frac{T_{\text{before}}}{T_{\text{after}}}
加速比 = 融合前延迟 ÷ 融合后延迟。S > 1 说明推理更快；对算子密集的模型，融合通常能带来 1.5~3 倍的端到端加速。
  1. T_before 是融合前的单次推理延迟完整执行一遍计算图的总时间。
    Tbefore=融合前推理总耗时\displaystyle T_{\text{before}} = \text{融合前推理总耗时}
  2. T_after 是融合后的单次推理延迟优化后计算图执行的总时间。
    Tafter=融合后推理总耗时\displaystyle T_{\text{after}} = \text{融合后推理总耗时}
  3. S 是加速比S > 1 表示融合带来正向收益，S 越大收益越显著。
    S>1⇔融合后速度更快\displaystyle S > 1 \quad \Leftrightarrow \quad \text{融合后速度更快}

AI 应用场景

在线推荐系统推理服务

阶段：模型部署与推理优化

解决的问题：推荐排序模型由大量小算子组成（Embedding 后接多层 MLP+激活），直接部署时 GPU 利用率低、p95 延迟超标。传统方式是堆更多 GPU 硬扛流量，成本高昂。利用层融合将 MLP+激活+归一化合并，kernel 启动次数从上百次降到几十次，中间张量也不再频繁进出显存。

具体案例：某广告推荐平台将 DeepFM 排序模型用 TensorRT 部署，开启层融合后单请求 p95 延迟从 15ms 降到 7ms，GPU 利用率从 35% 提升到 68%，同一批 GPU 能承载双倍流量，服务器采购成本直接减半。

边缘端自动驾驶感知

阶段：边缘端模型部署

解决的问题：车载域控 GPU 算力有限，检测模型的卷积+归一化+激活层多且小，kernel 启动开销占比高。传统方案只能降低模型分辨率来保实时性，牺牲了感知精度。层融合后启动和访存开销被压缩，让边缘设备在不降精度的前提下跑满帧率。

具体案例：某 L4 自动驾驶公司用 TensorRT 优化 YOLOv8 检测模型，层融合+FP16 后单帧推理从 32ms 降到 18ms，GPU 峰值占用下降 40%，既满足了实时性要求，又为激光雷达点云处理等其他感知模块留出了充足算力。

大语言模型服务优化

阶段：生成式 AI 推理加速

解决的问题：Transformer 的 MLP 块由矩阵乘、偏置、GELU 激活、残差相加、LayerNorm 等多个算子组成，每生成一个 token 都要完整执行一遍。传统逐算子执行意味着每 token 都要经历多次 kernel 启动，解码吞吐被严重拖累。层融合把这些算子合并成少数几个 kernel，大幅降低每 token 的启动开销。

具体案例：某 AI 公司部署 70B 参数 LLM 服务，在 TensorRT-LLM 中启用算子融合（QKV 投影合并、MLP+激活融合）后，单卡 decode 吞吐从 1200 tokens/s 提升到 2100 tokens/s，服务成本下降近一半。

Python 演示

python56 行
"""模拟层融合对GPU推理延迟的影响""" import random KERNEL_LAUNCH_MS = 0.5   # 每次kernel启动的固定开销(毫秒)MEM_WRITE_MS = 0.15      # 中间结果写回显存的开销(毫秒)  class Layer:    """模拟神经网络中的一层"""     def __init__(self, name, compute_ms):        self.name = name        self.compute_ms = compute_ms     def forward_ms(self, value):        return value + self.compute_ms  def run_unfused(layers, value):    """融合前：逐层调度，每层都有启动+写回开销"""    total_ms = 0.0    cur = value    for layer in layers:        total_ms += KERNEL_LAUNCH_MS        cur = layer.forward_ms(cur)        total_ms += MEM_WRITE_MS    return cur, total_ms  def run_fused(layers, value):    """融合后：一次启动，中间数据留在片上，只写回最终结果"""    total_ms = KERNEL_LAUNCH_MS    cur = value    for layer in layers:        cur = layer.forward_ms(cur)    total_ms += MEM_WRITE_MS    return cur, total_ms  def main():    random.seed(42)    layers = [Layer("L%d" % i, random.uniform(0.2, 1.2))              for i in range(12)]    value = 0.0    _, t_old = run_unfused(layers, value)    _, t_new = run_fused(layers, value)    speedup = t_old / t_new    print("融合前总耗时: %.2f ms" % t_old)    print("融合后总耗时: %.2f ms" % t_new)    print("加速比: %.2fx" % speedup)    assert speedup > 1.0  if __name__ == "__main__":    main()
目的：用简单的数学累加模拟 12 层网络在“逐层调度”与“融合调度”下的耗时差异，直观理解 kernel 启动开销如何累积成推理延迟。
  1. KERNEL_LAUNCH_MS = 0.5模拟每次 CPU 调度 GPU 的固定启动成本，无论算子多小都要付这笔账。
  2. total_ms += KERNEL_LAUNCH_MS融合前每执行一层就累加一次启动开销。
  3. total_ms += MEM_WRITE_MS每层输出都要写回显存，这笔访存开销也在逐层累积。
  4. cur = layer.forward_ms(cur)模拟算子计算，把耗时加到当前数值上，值越大代表数据路径越长。
  5. total_ms = KERNEL_LAUNCH_MS融合后整个网络只启动一次 kernel，启动开销从 12 次变 1 次。
  6. speeding = t_old / t_new计算加速比，输出结果会显示融合后耗时显著低于融合前。

常见误区

误区“层融合不就是把几个算子写进一个函数里吗？省掉那几次调用能省多少时间？我觉得对深层网络影响不大。”

正解融合的核心不是省函数调用，而是消除 GPU kernel 启动延迟（每次 3~10 微秒）和中间张量的显存读写（带宽瓶颈）。对包含几十上百个小算子的网络，累计省下的是毫秒级的时间；而且访存减少往往比启动减少带来更关键的收益——就像流水线改造里，省掉“搬货进仓库”比省掉“喊一次口令”更值钱。

为何常见：用 CPU 编程的思维去理解 GPU 执行模型，忽略了 kernel 启动延迟和显存带宽这两个 GPU 特有的开销来源。

误区“反正都是计算，把相邻几层随便拼在一起不就行了？为什么还要一套规则库来挑三拣四？”

正解融合必须满足语义等价且通过规则库验证。比如 Conv+ReLU 可以融合，但卷积与卷积之间是否融合要考察内存访问模式、数值精度约束；动态 shape、含控制流的算子根本无法安全合并。盲目合并甚至可能因为寄存器溢出而让 kernel 变得更慢——就像把焊接工位和喷漆工位硬凑在一起，结果反而互相干扰。

为何常见：只看到融合的收益，不理解融合引擎背后基于模式匹配的安全决策逻辑，误以为“相邻即合法”。

误区“既然是官方优化，开了肯定更快，不用再分析了。”

正解融合对大计算量的层（如大卷积核、大矩阵乘）收益有限，因为这类算子的计算时间远大于启动开销，启动占比很低；少数极端情况下，过度融合会增加寄存器压力、降低 GPU 占用率（occupancy），甚至不升反降。性能工程的铁律是“实测优先”——用 profiling 数据说话，而不是想当然。

为何常见：把“优化”二字绝对化，忽略了性能优化本质上是一个权衡与验证的过程。

误区“TensorRT 加速主要就是转 INT8，层融合只是顺便做的，两者差不多。”

正解两者是独立的优化维度。层融合减少 kernel 启动和访存开销，不改变数值精度；量化（FP16/INT8）则通过降低数据精度换取更快的运算。TensorRT 的优化管线先做图优化（含层融合），再做精度校准与量化，是前后衔接的两道工序，不能混为一谈。

为何常见：把最终推理提速笼统归因于单一技术，没有理清推理引擎优化管线中各项技术的职责边界。

面试题

Q1. TensorRT层融合的核心目标是什么？

单选题 · easy

  • A.提高模型推理精度
  • B.减少启动与存储开销← 正确答案
  • C.减少训练数据规模
  • D.增大模型参数量

答案：B。层融合通过合并相邻算子来减少 kernel 启动次数和中间结果显存读写，不改变精度与参数量。就像工厂合并工位是为了减少喊话和搬运，而不是为了改变产品。

Q2. 计算图中“相邻层”是指什么？

单选题 · easy

  • A.参数数值接近的层
  • B.数据直接相连的层← 正确答案
  • C.代码位置相邻的层
  • D.内存地址相邻的层

答案：B。相邻层指计算图中存在直接数据依赖关系的两个节点，即一层的输出张量是另一层的输入。这与参数大小、代码书写位置或内存地址都无关。

Q3. 对于逐元素类小算子（如ReLU），其性能瓶颈主要在？

单选题 · mid

  • A.实际计算耗时长
  • B.kernel启动开销← 正确答案
  • C.训练收敛速度慢
  • D.模型容量不够大

答案：B。小算子计算只有几微秒，而 kernel 启动固定要 3~10 微秒，启动占比可超过 50%。这就像工位加工只要一秒，但调度员喊话要三秒——瓶颈在喊话，不在加工。

Q4. 层融合能带来的收益有哪些？

多选题 · mid

  • A.减少kernel启动← 正确答案
  • B.减少中间显存读写← 正确答案
  • C.提高GPU利用率← 正确答案
  • D.降低模型参数量

答案：ABC。层融合能消掉多余的 kernel 启动、减少中间张量进出显存、让 GPU 计算单元更饱和地运转。参数量是模型结构属性，融合只改执行方式不改参数。

Q5. 融合器判断两个算子能否合并主要靠什么？

单选题 · mid

  • A.采用随机采样
  • B.规则模式匹配← 正确答案
  • C.人工逐层测试
  • D.依据训练梯度

答案：B。TensorRT 融合引擎在计算图上做模式匹配，只有命中融合规则库的组合才会被合并。就像工程师翻规则手册决定工位能否合并，而不是靠猜或靠试。

Q6. 关于融合的安全约束，下列说法正确的是？

单选题 · hard

  • A.只要相邻即可合并
  • B.必须保持语义等价← 正确答案
  • C.融合忽略数据依赖
  • D.融合可改变拓扑

答案：B。融合的前提是变换前后的数学结果等价，或数值误差在允许范围内，同时必须尊重原计算图的数据依赖关系。相邻只是必要条件，不是充分条件。

Q7. 融合后的单个Kernel通常具备哪些特点？

多选题 · hard

  • A.一次启动执行多算子← 正确答案
  • B.数据保留在片上缓存← 正确答案
  • C.计算图节点数减少← 正确答案
  • D.需要反复同步主机

答案：ABC。融合 kernel 一次启动完成多个算子的计算，中间数据放在寄存器/共享内存里，计算图节点数随之减少。反复同步主机是融合前逐层调度的老毛病，融合后恰恰被消除了。

Q8. 推理吞吐量提升的直接体现是什么？

单选题 · easy

  • A.单位时间请求数增加← 正确答案
  • B.模型文件体积变小
  • C.训练轮数大幅减少
  • D.显存容量自动变大

答案：A。吞吐量定义为单位时间内完成的推理请求数。融合后单次推理更快、GPU 利用率更高，同一段时间能处理更多请求，就像工厂同样的班次产出了更多产品。

Q9. 层融合对部署服务的收益体现在哪些方面？

多选题 · mid

  • A.降低端到端延迟← 正确答案
  • B.提升单位时间吞吐← 正确答案
  • C.降低显存带宽压力← 正确答案
  • D.减少网络参数量

答案：ABC。融合后推理路径更短、访存更少，端到端延迟下降、吞吐上升、带宽压力减小。参数量由模型结构决定，融合并不改变网络权重，所以 D 不正确。

Q10. 若某层T_launch=5μs、T_compute=2μs，则该层启动开销占比约为？

单选题 · extreme

  • A.百分之四十左右
  • B.百分之七十左右← 正确答案
  • C.百分之九十左右
  • D.百分之百开支

答案：B。启动占比 = 5 ÷ (5+2) ≈ 71%。这说明该算子大部分时间花在等待 kernel 启动上，真正计算的时间不足三成——这正是层融合要治理的“调度员哨声”问题。