AI(人工智能:一种现代的方法)学习之:CSP(Constraint Satisfaction Problems) 约束满足问题：通过结构（Structure）加速 CSP 的求解 / 迭代提升算法

回顾加速 CSP 求解的算法

• 之前的章节中涉及了几种加速 CSP 求解过程的方式，包括 Filtering 过滤法，提前滤除那些一定会无解的搜索分支。这期间涉及了 forward checking （前向检查），虽然这并不是一种非常完美的方法。
• 第二种加速 CSP 求解的方法是 Ordering（排序），一方面对于要进行探究的变量进行排序，另一方面对一个变量中可选的多个值进行排序。在探究变量的顺序上，我们选择先处理最难的变量（因为我们终究要探究所有的变量来找到解，因此先探究困难的变量有助于提前排除错误，也叫 fail fast ordering 方法，这样在发生错误回溯的时候就不会面对指数量级的回溯而造成的大量时间浪费）而在面对变量中的值的时候，我们偏向于选择容易让当前算法继续下去的解法（乐观的，最优希望的解法 least constraining value），因为我们不需要对每个变量中所有的值进行尝试）；如果上面的解释有什么不懂的地方，可以去上一篇文章回顾一下。
• 今天的文章中涉及的内容是：如何利用问题的结构（problem structure）;这部分内容将对 弧相容（弧一致性） 问题进行扩展。
• 首先回使用着色问题回顾一下弧相容的过程：

• 目前从 V -> NSW 的弧已经满足相容性
  
• 这个 SA -> NSW 的弧中，也是满足相容性的
  
• 但是 NSW -> SA 的弧发生了不相容的情况，因此我们需要删除 tail （NSW）中的蓝色来保证相容性
  
• 因为 NSW 中的内容发生改变，因此所有指向 NSW 的变量都应该重新检验弧相容性，因此我们还需要对 V-> NSW 弧进行检查：
  
• 发现这时候 V 中的红色不能满足相容性了因此要将 V 中的红色删除:
  
• 由于之前没有指向 V 的变量，因此我们可以继续检测其他的弧的相容性：
  
• 对于 SA -> NT, 发生了不相容的情况，因此删除 SA 中的蓝色值，而这也导致了 SA 的值域变为空，因此这个 CSP 搜索过程发生了错误，因此需要回溯到上一个正确的状态。
  

K-consistency（K一致性）

• 比弧相容（弧一致性）有更强的限制规则：不仅要所有的二元组满足弧一致性，而且要保证所有的三元或者四元组也满足规则。
• 这实现起来可能比较昂贵，但它也是非常强大的。

节点一致性 node-consistency / Unary consistency

• 当前节点的 domian 中至少有一个值满足该节点的约束

弧一致性（binary-consistency）

• 在这里要用另外一种较为奇怪的方式阐述我们已经知道的 弧相容，这样做的目的是为了后面将其扩展成更高阶的一致性约束。
• 对任意一对节点（pair of nodes)；在一个节点中进行赋值（assignment），这个结果可以扩展到另一个节点；这意味着，对 tail节点 进行任何分配，都应该有一个对应的分配发生在 head节点，而且分配的时候不违反任何约束。

K-consistency

• 对于每个 k-node（k个相互挨着的节点）；在任何不破坏约束的情况下将 k-1 分配给它们以保证对第 k 个节点的扩展。也就是说，如果你能达到 k-1 就能达到 k。
  
• 当 k 逐渐增大，计算变得非常昂贵

强 K 一致性（Strong k consistency）

• strong k consistency 意味着保证 k consistency 的同时，也同样要满足 k-1 consistency， k-2 consistency，… 1 consistency
• 声明：strong k consistency 意味回溯不可能发生，也就是我们可以解决当下的问题而不触发任何的回溯。
• 这是因为在 strong k consistency 的情境下：

• 当我们拿到第一个 node，我们保证它已经符合了 1-consistency 因此没有违反任何约束，因此肯定不会发生回溯
• 当再拿到第二个 node，因为它一定满足与第一个节点之间的 2-consistency，因此也不会违法任何约束
• 同理，一直到 k 个节点分配值结束都不会产生任何的违反约束的行为，每一个节点都能保证是合法的扩展
• 因此根本不会发生回溯行为

• 虽然 k consistency 的计算会很昂贵，但是我们从这里面可以学到一点：如果我们选择合适的 consistency，我们就可以最大程度避免回溯导致的计算浪费。

Structure

独立子问题（independent subproblem）

• 从利用结构的极端情况开始：
  
• 在 澳大利亚地图着色问题上可以看到 T 是一个独立的，与周围的块不存在约束的区域，因此我们可以认为这是一个 独立子问题
• 类似的，对于一个包含 $n$ 个 variable 的 graph，可以被切分成 $\frac{n}{c}$ 个子问题，每个子问题的 variable 数量仅有 $c$ 个
• 这样的分割情况下，假设每个变量的取值都有 $d$ 个，那么所有的变量的取值情况一共有 $d^n$ 个，但是切割之后，问题的规模变成了，$O(\frac{n}{c}{d}^c)$ 因为每个 子区域的变量数量变成了 $c$ 个，所以每个区域来看的话，所有变量的取值一共只有 $d^c$ 个，这采用了分治的思想。

树结构的 CSP（tree structured CSPs）

• 通过树结构，可以将问题线性化：
  • 选择一个 variable 作为树的 root
  • 假设选择 A 节点作为 root，整棵树可以表示成下面的形式（线性化）：
    
• 再来考虑着色的问题：

• 这个问题可以转变成：
  • 第一步：从右向左的的 backward，在 backward 的过程中删除那些节点中不相容的值
• 第二步：从左到右（从 root 到根节点）分配颜色

第一步

• 首先从 F 开始，因为 D 指向 F，因此我们首先检查 D->F 的相容性；D 中的蓝色不相容，因此删除 D 中的蓝色：
  
• 接下来是 E，指向 E 的弧有 D；因此我们检查 D->E 的相容性：已经是相容的了
• 接下来是 D，检查 B->D：是相容的
• 然后是 C， B->C 中出现了不相容，删除 B 中的绿色：
  
  然后是 A->B 的相容性：A 中的蓝色不相容，删除：
  
• 这种树结构的极大优势就是：所有的节点只可能有一个 parent，也就是说指向他的弧只可能有一个，因此我们再检查相容性的时候不需要检查两个方向， 只从最末端的点向前检查即可！

第二步

• 完成了这种相容性的检验，接下来应该进行第二步，从 root 向后进行上色：
• 对于 A,只能选择 红色
• 对于 B,只能选择蓝色
• 对于 C，只能选 绿色
• 对于 D，选红色或者绿色都行
• 对 E，选绿色或者蓝色都行
  对于 F，选蓝色
• 其实看出来，无论选什么都是对的，因为从 右向左的过程已经完成了所有的弧相容检测。
• 这种算法的复杂度是 $O(n{d}^2)$
• 之所以有 $d^2$ 是因为，检查每一对弧的时候，都需要将这两个节点中的所有值进行配对并且检测，每个节点中最多有 $d$ 个值，因此总体的复杂度是 $d^2$

CSP 中树结构的结论

• 当使用树结构进行 CSP 任务的时候，当完成了 backward 的弧相容检测过程，那么所有的从 root-to-leaf 方向的弧全部都是满足一致性的
• 如果 root-to-leaf 方向的弧是一致的，那么前向的分配一定不会触发回溯问题

类树结构的 CSP(Nearly Tree-Structured CSPs)

• 因为在实际问题中，几乎不可能遇到独立子问题的情况，而完全的树情况也很难遇到，我们比较容易碰到的结构类型是：接近树的结构，但不完全满足树的结构。因为我们可以主动地将很多问题转换成类似树的结构。
• 实现类树结构的方法是：可以通过删除图中的部分节点来实现。

割集条件算法（cutset conditioning）

• 实例化一个变量，因此他邻居的 domain 中的值会减少

• 实例化一组变量，使得剩下的 graph 称为一棵树，这个过程中被实例化的节点数为 $c$ 个；实例化的这 $c$ 个节点的集合就是 割集（cutset），你也可以笼统的理解：将割集从原本的集合中剔除可以将原本连通的图变成不连通的，从而简化问题。

• 从左边到右边，我们将 SA 分配了红色，然后剩下的问题就变成了一棵树；这个例子中我们实例化了 1 个节点，剩下了 6 个节点，这些节点组成了一个线性的结构

• 进行处理过后去掉的节点数$c$，因此复杂度变成了 $O(d^c(n-c)d^2)$为什么复杂度变成这样了呢？

  • 因为当这个集合原本大小为 $n$，现在删去了其中的 $c$ 个节点，那么整个集合中还剩下 $n-c$ 个节点，根据之前的知识，这些节点维持树的结构，因此计算的复杂度应该是 $(n-c)d^2$
  • 但是删去 $c$ 个节点的过程并不是一蹴而就的，因为要对 $c$ 个节点的每个值都进行实例化尝试，因此一共要进行 $d^c$ 次尝试，因此综合起来，我们要实例化 $c$ 个节点来构造剩下的树结构，整体过程的复杂度就是 $d^c(n-c)d^2$

• 看一个具体的例子来展示 cutset conditioning 的过程：

• 选择 SA 作为要实例化的节点，并且把 SA 的所有可能的取值（红绿蓝）都实例化一遍，得到不同 SA 取值下的树结构
• 对三种情况分别按照 Tree-structured 中的方式进行求解

• 再来看一个例子：

• 找到最小的 cutset
• 很显然将 A,B 构成割集可以让剩下的节点变成树结构

树分解算法（Tree Decomposing）

• 这种算法的思路是将多个节点以及他们之间存在的约束看做一个整体，这个整体叫 mega-variable
• 每个 mega-variable 都代表原 CSP 问题中的一个部分
• 这样我们就把一个整体的问题划分成了独立子问题（independent subproblem），但问题是，我们必须保证他们重叠的部分要满足一致性
• 例如最左边的图中的 NT 除了和 SA 以及 WA 之间存在一致性之外，还需要保证它和第二个图中的 Q 保持一致性。这个问题是独立子问题的一个重点关注的部分。

• 每个连接的部分都要保证 shared vars 是一致的，连贯的（coherent）
  

迭代提升算法（Iterative Improvement）

• 这是在 CSP 求解过程中第一次涉及随机算法（randomized algorithm）
• 这是一种基于 local 的搜索算法（local search）
• 这种算法是从一个 ”完全状态“ 开始的。而不是像之前的所有算法一样专注于部分的赋值
• 之前的算法（例如弧相容、前向搜索，等）都是对当前的 variable 谨慎地赋值，然后再对下一个 variable 进行类似的操作直到图中的所有 variable 都被赋值，这个过程中我们谨慎地对每一步进行检查，确保他们是合法的，如果不合法就进行回溯。
• 但是迭代提升开始于一个随机的赋值，即全图的所有 variable 都被赋值了，当然他们未必是合法的赋值，但是这没关系，迭代算法会在后面的步骤中不断修正这些不合法的步骤并最终实现 CSP 的全局求解
• 例如下面的例子：

• 在一个配色的问题中，我们最开始的状态是两个临接区域都赋值为红色，显然这是不合法的
• 因此我们再迭代的过程中将第二个按照约束条件替换成合法的蓝色，这样就完成了迭代的过程。
• 在以往的过程中，我们通常会用 ”回溯“算法来保留一些 ”备选“ 方案，例如当前的赋值不可行了我们再通过回溯选择备选方案，因此我们可能引入非常高的复杂度，但是这种迭代的算法没有任何备选的方案
• 这个算法会在过程中不断调整当前的状态 (基于 minimum conflicts heuristic 算法)，直到它起作用或者放弃。
  

最小冲突启发式（minimum conflicts heuristic)

minimum conflicts heuristic： 选择一个值，这个值在当前的状态下会违反最少的约束。

• N 皇后问题中的 Iterative Improvement 举例：

• 初始化的时候，所有的皇后都是冲突的
  
• 随便选一个皇后，对其进行操作，试图减少违反的约束的情况；选中 $2$ 号皇后，在它右边的 $4$ 个格子中的数字分别代表了选择那个格子之后 $2$ 号皇后与周围的皇后的约束违反次数，按照 Iterative Improvement 算法的原则我们选择最小的值：$0$ 然后对 $2$ 号皇后进行重新分配
  
  
• 对皇后 $1$ 重复这个过程:
  
  
• 继续
  
  -继续
• 在当前这个步骤有两个 1 可以选，但是当我们选择了这个 1， 就导致了冲突，但没关系，这个算法没有记忆不需要回溯，只需要根据当前的状态调整即可，于是第 1 个皇后进行调整：
  
  
• 现在所有的皇后之间都没有冲突了。

• 着色问题中的 Iterative Improvement 举例：

• 一开始所有的 variable 都随机分配了一个值，但是很多是不合法的
• 开始按照算法进行迭代：
  
  
  
  
  
  
  
  
  
  
  
  
  
• 只用了上述很少的步骤就把这个问题解决了。

• 从上面的问题中我们看出，采用迭代提升算法在解决某个冲突的过程中可能会引入新的冲突，但是这没问题，不需要回溯，只要一步步解决即可。因此有可能永远运行下去找不到解，停不下来也有可能。
• 而且这种方式也不能保证最优解
• 但是这种算法非常快

最小冲突启发式的性能分析

• 看下方可视化的图：
  • 对于约束很少的情况和约束很多的情况 最小冲突启发式 的效果都是很好的，因为当约束很少的时候就代表绝大多数的随机情况都是对的，因此只需要调整几个值可能就能得到不错的解。而当约束很多的时候，也是效率很高的，因为约束很多代表符合情况的解的数量其实是很少的，因此也可以很快的找到解。
  • 但是当约束条件和变量的数量在某个范围内，既有很多解的情况，约束又不是那么严格，那么通过迭代提升算法的求解复杂度就会急剧升高。