计算图：控制流表达

可视化演示

展示词嵌入向量空间分布、正弦位置编码热力图及词间余弦相似度矩阵，交互切换查看嵌入与位置编码核心概念。

控制流概念

分拣中心最初的设计只考虑一件事：包裹从 A 送到 B。传送带直线铺开，每个工位加工完就传给下一个，所有包裹都被当成同一种。可现实很快给出难题——发往华东和华北的包裹要进不同分拣口，被压坏的包裹要送回返修间重新处理。如果只铺直线传送带，设计师根本没法表达“看情况走哪条路”和“绕回来再处理一次”。

计算图就像这套传送带系统：节点是工位（算子），边是传送带（数据依赖），数据张量是包裹。数据流图有一个先天局限：它只描述“数据从哪来、到哪去”，却不描述“要不要去、去几次”。另外还有一类控制依赖边，专门表达执行先后顺序，比如“必须先算出循环条件，再决定是否进入循环体”。一旦模型需要根据输入决定走向（比如只对包含行人的图片走检测分支），或需要反复处理（比如 RNN 逐词读句子），纯数据流就失灵了。这些“非数据流”的逻辑统称为控制流。

控制流表达在计算图里有两大形态：条件分支与循环。条件分支是“如果谓词 p 成立就执行 f，否则执行 g”；循环是“把某个状态反复送进循环体，直到满足退出条件”。RNN 的按时间步展开、动态网络按输入特征走不同子网、beam search 的终止判断，背后都是这两种形态。

所以分拣中心的蓝图里必须增加两种设备：会看标签的闸口（条件分支），以及把包裹送回加工区的循环传送带（循环）。有了它们，传送带系统才从“一条直线”升级成“四通八达的管网”，这正是计算图获得控制流能力后发生的变化。

图级控制原语

分拣中心的设计师很快发现，不能为每一条新线路定制一台特殊机器，否则维护成本会爆炸。正确做法是设计几种标准化设备：闸口负责分流、合流器负责汇合、循环轨道负责回流。任意复杂的分拣流程，都是这些标准设备拼出来的。

计算图同理，AI 编译器需要提炼“图级控制流原语”——图中承担决策、循环职能的最小标准节点。原语有两个设计目标：既要保持数据依赖清晰（算子之间谁等谁），又要让控制信息显式暴露（哪条路径可能不执行、哪段会重复），这样编译器和运行时才能读懂并优化。

核心原语有三类。条件执行：Switch 与 Merge 的组合，表达“二选一”。循环机制：Enter、NextIteration、Exit，表达“重复 K 次直到条件满足”。状态转移：循环中每一轮把旧状态变成新状态，形成环状数据依赖。所有控制流最终都要能被编译成这些原语的组合，例如 RNN 的一次时间步就是一个带循环状态的转移。

有了标准化设备，工程师画分拣流程图时只需关心“闸口、合流、回路怎么接”，而不用重复设计细节；编译器也只需要针对这几种原语做专门优化。这就是图级原语的力量：把无穷的控制逻辑，收敛为有限的几种模式。

Switch开关算子

分拣中心里最显眼的设备就是闸口：一个包裹滑过来，闸口看它的分拣码，抬杆放它进左道，或者拨盘送它进右道。一次只走一边，另一个方向的传送带安安静静，没有任何包裹经过。

TensorFlow 静态图里承担这个职责的是 Switch 算子。它接收两个输入：一个数据 x 和一个谓词 p（标量条件值），输出两个分支端口。执行时只有满足条件的那个分支端口有数据，另一个输出为空——就像闸口只放行一个方向。

Switch 的语义是：真端口输出 x（当 p>0），假端口输出空 ∅。这个“空”极其重要：它告诉编译器“未激活分支没有数据流”，于是编译器可以做死路径消除——把永远不会被数据触及的分支子图整体剪掉，既省内存又省计算。TF 的 while_loop 内部判断“继续循环还是退出”，最终也是靠 Switch 完成的。

闸口的精妙之处在于它不关心分支里是什么工位，只负责“放行哪一边”。Switch 也一样，它把“往哪走”的决策从计算中剥离出来，让编译器一眼看出哪些传送带永远不会有包裹经过，直接把那段拆掉。

Merge与循环模式

闸口把包裹一分为二，可包裹总要在某个出口重新汇入主流水线，否则分拣中心会变成一堆断头路。于是设计师加了合流器：两条传送带汇成一条，谁有包裹就放谁过去。

图里对应的是 Merge 算子：从两个输入端口取数据，输出其中“非空的那一路”。Switch 解决“怎么分”，Merge 解决“怎么合”，两者总是一起出现，形成完整的分支结构。真正的循环还需要第三组原语：Enter 把初始状态“装进”循环，NextIteration 把一轮加工的结果送回循环体入口，Exit 在循环条件不满足时放行最终状态。

TF 的 while_loop 正是这样实现的：循环变量经 Enter 初始化，进入循环体；每轮末尾用 Switch 判断条件，满足则走 NextIteration 回到循环体，不满足则走 Exit 离开。梯度计算时，因为每一轮迭代都是图中显式的节点，反向传播可以沿循环展开链逐轮回传，也可以按需重算中间值。

循环传送带是分拣中心处理返修的秘诀：包裹绕一圈，工位再加工一次，绕够了就放行。图的循环原语同样让“重复”在静态结构里显式可见，编译器由此知道哪里会反复执行，并针对它做循环优化或不变量提升。

动态图执行

另一种分拣中心完全不用蓝图：一位经验老到的分拣员站在传送带旁，包裹来了，他看一眼标签，手一指：“这个送 A 口，那个送返修间，转三圈。”现场判断、现场指挥，流程随着包裹变化而灵活调整。

PyTorch 的动态执行就是这位分拣员。它不预先构建整张图，而是逐行解释执行 Python 代码。你在模型 forward 里写 if/for，Python 本身就是控制流引擎——完全不需要 Switch/Merge 这些原语。变长序列、动态维度的中间结果、甚至每个样本走不同网络结构，都能直接表达。

动态的优点也是它的代价：每次前向都要重新“现场指挥”一遍。为了部署，PyTorch 提供了追踪式固化：torch.jit.trace 用一份真实输入把计算过程“拍张照片”，把执行过的算子序列存成静态图；但照片里的循环已被展开成固定步数的直线路径，换一个循环次数就失效。TorchScript 的 script 模式才能保留真正的循环结构。

分拣员的灵活性令人羡慕，代价是每次包裹来都要重新想一遍；而且如果分拣员退休了（进程重启），他的经验就没了。动态图同样难以把运行信息沉淀下来供编译器优化，这正是下一节要讲的权衡。

编译优化权衡

蓝图为主的分拣中心有一个隐藏优势：所有传送带都画在纸上之后，总设计师可以全局巡视——“这条支路永远不会被用到？拆掉！这两个工位挨着？合并成一个复合工位！”这些优化不需要运行任何包裹，光看图纸就能完成。

静态计算图天然拥有这种全局视野。编译器可以消除死路径（Switch 未激活分支）、做算子融合（把相邻小算子合成 kernel）、做常量折叠与公共子表达式消除，还能对循环做不变量提升。而在动态执行模式下，编译器每次看到的都是“刚刚跑过的路径片段”，无法建立全局视图；循环每绕一圈都要重复解释和调度，开销随迭代轮数线性放大。

更难的是图捕获：把动态代码转成静态图时，如果代码里既有动态分支又有循环，每次输入不同，捕获到的子图结构就不同，导致缓存失效、反复重编译。经典做法是“先试静态：能捕获就捕获；遇到动态控制流就回退解释执行”，这正是 tf.function 的 Autograph 机制向后端编译的妥协。

蓝图优化的魔力在循环多的模型（RNN、扩散模型的多步采样）上体现得淋漓尽致：图纸上拆掉一条死支路、合并两个工位，比现场分拣员每圈重复思考要省太多。前提是——你得愿意先画图纸，也就是接受静态图的开发约束。

选型与演进

分拣中心到底用“蓝图施工”还是“能人现场指挥”？答案取决于旺季还是淡季：淡季包裹形态复杂多变，人工分拣更灵活，不怕流程改动；旺季包裹洪峰固定，必须蓝图加自动化流水线才能扛住吞吐。

对应到 AI 工程：训练阶段追求快速试错，结构频繁改动，天然适合动态执行；部署阶段追求低延迟高吞吐，结构固定，一定要静态图加编译优化。现代框架普遍采用混合方案——前端保持 Python 动态体验，后端用 tf.function、torch.compile、JAX jit 把热路径编译成静态图，既享受动态的灵活，又拿到静态的性能。

演进趋势是“编译器接管更多控制流”：TorchScript 和 ONNX 导出时自动把 if/for 翻译成图原语；XLA 在静态子图上做循环融合；AI 编译器甚至能把动态 shape 的循环也静态化。选型核心就一句话：结构稳定、循环多的路径走静态；结构多变、交互性强的地方保持动态。

聪明的高级分拣中心早已不是二选一：平时让能人现场应变，旺季按蓝图上自动化线。AI 编译器也一样，在灵活性、性能与工程成本之间，用混合方案走出第三条路——这，就是控制流表达的完整图景。

AI 应用场景

Python 演示

"""迷你静态计算图 - 演示 Switch/Merge 控制流表达"""  class MiniGraph:    def __init__(self):        self.nodes = []     def add(self, name, op, a=None, b=None, cond=None):        self.nodes.append({'name': name, 'op': op, 'a': a, 'b': b, 'cond': cond})     def run(self, feeds):        v = dict(feeds)        for n in self.nodes:            op = n['op']            name = n['name']            if op == 'input':                continue            elif op == 'const':                v[name] = n['b']            elif op == 'switch':                # 条件成立只激活一个输出端口                x = v[n['a']]                p = v[n['cond']]                v[name + '_true'] = x if p > 0 else None                v[name + '_false'] = x if p <= 0 else None            elif op == 'merge':                # 从两个分支中取非空的那一路                t = v.get(n['a'])                f = v.get(n['b'])                v[name] = t if t is not None else f            elif op == 'add':                a, b = v.get(n['a']), v.get(n['b'])                v[name] = None if a is None or b is None else a + b            elif op == 'mul':                # 死路径上的算子不产生有效值, 类似死路径消除                a, b = v.get(n['a']), v.get(n['b'])                v[name] = None if a is None or b is None else a * b        return v  def build_abs_graph():    # y = (x > 0) ? 2*x : x + 100  ->  Switch + Merge 图    g = MiniGraph()    g.add('x', 'input')    g.add('two', 'const', b=2)    g.add('hundred', 'const', b=100)    g.add('sw', 'switch', a='x', cond='x')    g.add('mul', 'mul', a='sw_true', b='two')    g.add('add', 'add', a='sw_false', b='hundred')    g.add('out', 'merge', a='mul', b='add')    return g  def while_loop(init, cond_fn, body_fn, max_iters=8):    # 图级循环的表达模型: Enter -> 迭代 -> Exit    state = init    for _ in range(max_iters):        if not cond_fn(state):            break        state = body_fn(state)    return state  if __name__ == '__main__':    g = build_abs_graph()    for x in (-3, 0, 5):        y = g.run({'x': x})['out']        print('x =', x, '-> y =', y)     def cond(s):        return s < 8.0     def body(s):        return s * 0.9 + 1.0     final = while_loop(0.0, cond, body)    print('while_loop final =', round(final, 4))

1. v[name + '_true'] = x if p > 0 else NoneSwitch 真分支：条件成立才输出数据，否则为空
2. v[name] = t if t is not None else fMerge 汇合：取两个分支中非空的那一路
3. v[name] = None if a is None or b is None else a * b死路径上的算子不产生有效值，模拟死路径消除
4. g.add('mul', 'mul', a='sw_true', b='two')把 Switch 的真分支端口接到乘法算子的输入端
5. g.add('out', 'merge', a='mul', b='add')用 Merge 把真分支和假分支的结果合并成最终输出
6. g.run({'x': x})['out']喂入输入后按节点顺序执行，得到分支结构的计算结果
7. for _ in range(max_iters): if not cond_fn(state): break模拟 Enter→迭代→Exit 的图级循环控制语义

常见误区

面试题