Junction Tree algorithm(联结树)的思路整理

Posted 2023-04-23

参考技术A

当Graphical model不再是树形结构的时候，factor graph并不能保证有一致的解，我们需要将原本的概率图构造为一种树形结构的图，能够在这种数据结构上执行类似factor tree中的message passing，最终得到我们所感兴趣的分布。

通俗的说 ：原本的图有环(如果是长度大于3的环需要映入chord)，那么我们可以将几个相邻的节点合并为一个大的节点，可以消除原本存在的环。把所有原本存在的环路变为一个个超级节点，图就变成了树，这就是junction tree 能够hold主环路的原因

通过证明，无论是贝叶斯网络还是马儿克夫网络的联合概率都能够表示成:

absorption ：clique graph 通过前向后向传播（每条边都有两个方向），修正后的potential对应于clique的边缘概率。

message-passing调度 ：一个clique可以向另一个相邻clique发送信息，只有当它接收了除了这个点之外所有相邻clique的message时。

如果一个变量出现在一个环中的每条sep上时，我们可以随便选择一个sep，将这个变量删除（brml p105），如果这个sep变为空，则可以删除相应的边，从而获得clique tree。

Running intersection property ： if a node appears in two cliques,it apprears everywhere on the path between the cliques

只有满足了RIP，才能得到全局的一致性。 （如果不满足RIP，那么就不能通过message-passing 将这个node的信息共享给所有的clique，自然不能满足一致性）

当原图有环时，variable elimination 消除变量时，消除变量的相邻变量需要连边，这会引入新的边。

Triangulated Graph ： 所有的长度大于3的环，必须引入弦（chord）（对应于variable elimination中新增加的边）

但是引入chord的顺序不同，可能导致clique 的大小不同，而junction tree 的性能瓶颈在于clique的大小。（我们只能通过贪心来让最大的clique尽量小）

Greedy variable elimination ：

直到所有节点都被消除掉
如果原图已经有chord，那么消除变量不需要引入新的边。
通过这种variable elimination中新加的边，就是JT的chord

最终clique的potential就是边缘概率。

只有原图为树形时，JTA才是线性的时间复杂度
当所求的分布不在同一个clique中时，需要的计算复杂度为指数形式

[Algorithm] Universal Value Tree Problem

A unival tree (which stands for "universal value") is a tree where all nodes under it have the same value.

Given the root to a binary tree, count the number of unival subtrees.

For example, the following tree has 5 unival subtrees:

   0
  /  1   0
    /    1   0
  /  1   1

function Node(val) {
  return {
    val,
    left: null,
    right: null
  };
}

const root = Node(0);
root.left = Node(1);
root.right = Node(0);
root.right.left = Node(1);
root.right.right = Node(0);
root.right.left.left = Node(1);
root.right.left.right = Node(1);

function count_unival(root) {
  function helper(root) {
    let total_count = 0;
    let is_unival = true;

    // Base case 1: if current node is null, then return
    if (root == null) {
      return [0, true];
    }

    // Base case 2: if current node is not null, but its children node
    // are null, then count this node as usb-unvial tree
    if (root.left === null && root.right === null) {
      return [1, true];
    }

    // Base case 1 & Base case 2 can keep just one, it should still works

    // Do the Recursion
    let [left_count, is_left_unival] = helper(root.left);
    let [right_count, is_right_unival] = helper(root.right);

    // we need to consider whether the whole tree
    // root + left tree + right tree are unvial
    // the way to do it just compare root with its left and right node
    // whether they are the same if both left tree and right tree are
    // unival tree.
    if (!is_left_unival || !is_right_unival) {
      is_unival = false;
    }

    if (root.left !== null && root.val !== root.left.val) {
      is_unival = false;
    }

    if (root.right !== null && root.val !== root.right.val) {
      is_unival = false;
    }

    // If the whole tree are unival tree, then the final result
    // should + 1
    if (is_unival) {
      return [left_count + right_count + 1, is_unival];
    } else {
      return [left_count + right_count, is_unival];
    }
  }

  const [total_count, is_unival] = helper(root);
  return [total_count, is_unival];
}

const res = count_unival(root);
console.log(
  `Whole tree is${
    res[1] ? "" : "n‘t"
  } unival tree, total counts for sub-unival tree is ${res[0]}`
); // Whole tree isn‘t unival tree, total count is 5