有向无环图DAG：d-分离判据

可视化演示

家族通讯网（DAG 语言入门）

想象一份家族通讯录：每个人是图里的一个“节点”，一条从 A 指向 B 的箭头，表示“A 的消息会直接传给 B”。如果 A 是 B 的爸爸，B 是 C 的妈妈，那消息就会沿着 A→B→C 这条“链式路线”一路传下去。家族里有一条铁规矩：没有人能成为自己的祖先，否则消息就会在时间上倒流，形成循环。这条铁规矩，就是“有向无环”的含义。

在因果推断中，变量就是家族成员，有向边就是“一个变量对另一个变量的直接因果作用”。d-分离不关心两个变量之间有没有一条“完美的因果路线”，它关心的是：从 X 出发，沿着箭头方向或逆着箭头方向，能不能走到 Y。这样的任意路线叫作“通路（trail）”，哪怕方向不完全一致，也算一条信息通道。

1. 节点集合：\(\mathcal{V}\) 是全部家族成员，对应现实里的随机变量。

$$\mathcal{V}=\{X_1,X_2,\dots,X_n\}$$

2. 有向边集合：\(\mathcal{E}\subseteq\mathcal{V}\times\mathcal{V}\) 是一组有顺序的“父子对”，箭头方向代表信息传播方向。

$$\mathcal{E}\subseteq\{(A,B)\mid A\in\mathcal{V},B\in\mathcal{V}\}$$

3. 无有向环约束：图中不存在一条路径让某个节点沿着箭头方向回到自己。

$$\forall v\in\mathcal{V}:\ v\notin \operatorname{desc}(v)$$

有了这张“家族通讯网”，我们就能把复杂的因果假设画成一张图，然后像查地图一样回答：哪条路通、哪条路不通。

$$\mathcal{G}=(\mathcal{V},\mathcal{E}),\quad\mathcal{E}\subseteq\mathcal{V}\times\mathcal{V},\quad\text{无有向环}$$

三种路型（基本结构）

家族里任意两位亲戚之间的消息传播，绕来绕去最后都可以拆成三种基本路型。第一种叫“链式管道”，形状是 \(A\to B\to C\)：爷爷把消息传给爸爸，爸爸再传给孙子。第二种叫“分岔共祖”，形状是 \(A\leftarrow B\to C\)：B 是 A 和 C 共同的祖先，同一个长辈分别向两个晚辈发消息。第三种叫“碰撞汇合”，形状是 \(A\to B\leftarrow C\)：A 和 C 是两个各不相干的长辈，但他们的消息都汇入同一个孩子 B。

三种路型里，前两种看起来都只是“消息路过 B”，但第三种有一个独一无二的性质：两个箭头在 B 处“撞车”。碰撞节点会让原本没有血缘互动的 A 和 C，在 B 被观察时产生一种说不清道不明的关联——就像两个互不相识的家长，因为共同孩子的一个异常表现，突然开始互相猜疑。

任何复杂的 DAG 通路，都是由这三种路型首尾拼接而成的。看懂它们，就掌握了 d-分离的“语法”。

阻断规则（信息什么时候传不过去）

现在家族里多了一件事：你“知道”了某些人的信息，也就是对变量做了“条件化”，记作 \(Z\)。“知道”这件事本身，会改变信息通路的开关状态。

对于链式 \(A\to B\to C\)：如果你已经知道 B 的动向，A 再传来消息也不会给 C 增加新信息，所以通路被阻断。对于分岔 \(A\leftarrow B\to C\)：既然共同祖先 B 的情况已知，A 和 C 之间就不再需要互传消息，通路也被阻断。这两种情况里，B 都是“非碰撞节点”，被 \(Z\) 盯住后，它就成了一个尽职的守门员。

碰撞结构恰恰相反：\(A\to B\leftarrow C\) 在没有观察 B 时，A 和 C 本来互不相通，碰撞节点 B 自动阻断通路；可一旦你观察了 B，或者观察了 B 的某个后代，这条原本安静的路反而被打开。这就是“观察反而开口”的反直觉规则。

“知道得太多”有时比“知道得少”更危险：把碰撞节点拉进条件集，等于亲手打开一扇原本紧闭的门。

判据定义（什么是 d-分离）

把前面的规则拼在一起，就是 d-分离的全貌：给定条件集 \(Z\) 后，如果 X 到 Y 的每一条通路都被阻断，我们就说 X 与 Y 在给定 Z 下 d-分离。这里的“d”代表“有向（directional）”，强调判断过程依赖箭头的方向。

d-分离之所以重要，是因为它连接了“图世界”和“概率世界”。在因果马尔可夫性质下，图上的 d-分离可以推出概率上的条件独立：

\[

X \perp\!\!\!\perp_{\mathcal{G}} Y \mid \mathcal{Z}

\ \Longrightarrow\

P(X,Y\mid \mathcal{Z})=P(X\mid \mathcal{Z})\,P(Y\mid \mathcal{Z})

\]

也就是说，当 Z 把所有信息通道都堵死后，知道 Y 不会让 X 的概率分布产生任何额外变化，X 和 Y 就像两个互不通话的独立房间。反过来，图的“马尔可夫等价类”告诉我们：链式 \(A\to B\to C\) 和分岔 \(A\leftarrow B\to C\) 可能编码同样的条件独立关系，不能单靠数据区分谁是因谁是果。

判别算法（怎样系统判断 d-分离）

手工作业时，你可以用“贝叶斯球”算法来理解：从 X 处抛出一颗球，让它沿着通路滚动。遇到非碰撞节点时，如果该节点不在 Z 中，球能穿过；如果它在 Z 中，球被挡住。遇到碰撞节点时，规则反过来：如果碰撞节点本身或它的后代在 Z 中，球才能通过；否则球永远撞墙。

正式做法是先枚举 X 到 Y 的所有简单通路，再逐条检查。为了快速判断碰撞节点是否因为“观察了后代”而打开，可以提前计算所有 Z 中节点的祖先集合。一个路径“开放”的数学条件如下：

最后，只要开放路径集合为空，就说明 d-分离成立；只要还剩一条开放路径，结论就是不成立。

实战工具箱（d-分离能做什么）

d-分离不是书斋里的理论玩具，而是工程实践里的“因果听诊器”。第一个用途是混杂因子侦测：如果 X 与 Y 之间存在一条后门路径 \(X\leftarrow C\to Y\)，那么 X 和 Y 的观察相关性会被 C 污染。用 d-分离检查 C 是否阻断了所有后门路径，就能决定要不要把 C 放进调节集。

第二个用途是条件独立性检验：如果我们从领域知识画出一张 DAG，d-分离会给出“X 与 Y 在给定 Z 下应当独立”的预测。把这个预测拿到数据里检验，能帮助我们发现图结构是否画错、模型是否漏掉了关键变量。第三个用途是因果特征选择：在大量特征里，优先保留那些与目标变量在给定候选特征后仍然“不 d-分离”的变量，同时剔除只在条件集下才独立的冗余变量。

不过，d-分离给出的结论有一个重要前提——忠实性。在忠实性假设下，图上的 d-分离和概率分布中的条件独立完全等价：

真实数据中可能出现“两段因果路径恰好抵消”的极端情况，让变量看起来独立但图上并不 d-分离。所以使用时，永远要保持对忠实性假设的警觉。

AI 应用场景

Python 演示

def descendants(start, children):    seen = set()    stack = [start]    while stack:        node = stack.pop()        for nxt in children.get(node, []):            if nxt not in seen:                seen.add(nxt)                stack.append(nxt)    return seen  def build_index(adj):    children = {n: set() for n in adj}    parents = {n: set() for n in adj}    for p, cs in adj.items():        for c in cs:            children[p].add(c)            parents[c].add(p)    return children, parents  def all_paths(start, end, visited, skeleton):    if start == end:        return [[start]]    result = []    for nxt in skeleton[start]:        if nxt not in visited:            visited.add(nxt)            for p in all_paths(nxt, end, visited, skeleton):                result.append([start] + p)            visited.remove(nxt)    return result  def is_collider(path, i, children):    pv, node, nx = path[i - 1], path[i], path[i + 1]    return node in children.get(pv, set()) and node in children.get(nx, set())  def path_is_open(path, Z, children, desc_cache):    for i in range(1, len(path) - 1):        v = path[i]        if is_collider(path, i, children):            if v not in Z and not (desc_cache[v] & Z):                return False        else:            if v in Z:                return False    return True  def is_d_separated(adj, X, Y, Z):    children, parents = build_index(adj)    skeleton = {n: set(children[n]) | set(parents[n]) for n in adj}    desc_cache = {n: descendants(n, children) for n in adj}    visited = {X}    paths = all_paths(X, Y, visited, skeleton)    return not any(path_is_open(p, Z, children, desc_cache) for p in paths)  def main():    # A -> B -> C, B -> D, C -> E, D -> E    adj = {        "A": ["B"],        "B": ["C", "D"],        "C": ["E"],        "D": ["E"],        "E": []    }    tests = [        (set(), False),        ({"B"}, True),        ({"E"}, False),        ({"B", "E"}, False)    ]    for Z, expected in tests:        got = is_d_separated(adj, "C", "D", Z)        print("Z =", sorted(Z), "d-separated =", got, "expected =", expected)  if __name__ == "__main__":    main()

1. children, parents = build_index(adj)同时记录每个节点的父节点和子节点，为后续识别碰撞节点做准备。
2. skeleton = {n: set(children[n]) | set(parents[n]) for n in adj}去掉方向得到无向骨架，用于枚举 X 到 Y 的所有通路。
3. paths = all_paths(X, Y, visited, skeleton)枚举家族通讯网中从 X 到 Y 的所有简单通路。
4. if is_collider(path, i, children)检查路径中间节点是不是“两个箭头同时指向它”的碰撞节点。
5. if v not in Z and not (desc_cache[v] & Z)碰撞节点既不在 Z 中、后代也不在 Z 中时，该路径被阻断。
6. return not any(path_is_open(p, Z, children, desc_cache) for p in paths)只要存在一条开放路径，X 与 Y 就不 d-分离。

常见误区

面试题