Beam Search 简介

概要

传统的广度优先策略能够找到最优的路径，但是在搜索空间非常大的情况下，内存占用是指数级增长，很容易造成内存溢出，因此提出了beam search的算法。
beam search尝试在广度优先基础上进行进行搜索空间的优化（类似于剪枝）达到减少内存消耗的目的。

Beam Search算法

新的概念

1. 为了达到搜索的目的，beam search 引入了启发函数的概念（$h$) 来估计从当前节点到目标节点的损失。
   启发函数可以使搜索算法只保存能够到达目标节点的节点
2. beam width $B$每一层(each level)广度优先搜索算法保存的节点数目。
   可以防止程序内存溢出，并加快搜索速度。
3. BEAM 作用类似于open list，用于保存下一轮扩展的节点
4. SET 保存BEAM中的所有的后续节点，是启发函数的输入空间。
5. a hash table 作用类似于close list，用于保存所有已经访问过的节点

算法流程

1. 将开始节点（start）增加到BEAM和hash table
2. 循环遍历BEAM的所有后续节点增加到SET中，并清空BEAM
3. 从SET中选择$B$个启发函数值最优的节点增加到BEAM及hash table中（已经存在hash table中的节点不能增加）
4. 以上过程循环持续进行指导找到目标节点或hash table 满了或主循环结束后BEAM为空（没有找到解）

伪代码

/* initialization */
g = 0;
hash_table = { start };
BEAM = { start };

/* main loop */
while(BEAM ≠ ∅){                             // loop until the BEAM contains no nodes
  SET = ∅;                                   // the empty set

  /* generate the SET nodes */
  for(each state in BEAM){
    for(each successor of state){
      if(successor == goal) return g + 1;
      SET = SET ∪ { successor };             // add successor to SET
    }
  }

  BEAM = ∅;                                  // the empty set
  g = g + 1;

  /* fill the BEAM for the next loop */
  while((SET ≠ ∅) AND (B > |BEAM|)){         // set is not empty and the number of nodes in BEAM is less than B
    state = successor in SET with smallest h value;
    SET = SET \ { state };                   // remove state from SET
    if(state ∉ hash_table){                  // state is not in the hash_table
      if(hash_table is full) return ∞;
      hash_table = hash_table ∪ { state };   // add state to hash_table
      BEAM = BEAM ∪ { state };               // add state to BEAM
    }
  }
}

// goal was not found, and BEAM is empty - Beam Search failed to find the goal
return ∞;

beam search example

说明

一下样例都是用两行代表一次主循环执行过程。
两行中的第一行显示增加到SET中的nodes（字母顺序）
第二行显示的是从SET中增加到BEAM中的节点
两行后都有一个hash table显示其状态(hash table 只有7slots，表示可用内存的大小)
以下每一个例子对$B$取不同的值，并且只展示了四步，用来展示beam search的优势跟不足
beamsearch 目标是从I-> B

搜索的图

exmple 1 $B$ = 1,展示Beam search 的不足，找不到解

loop number	SET,BEAM	hash table
	BEAM={I}	hash table={I}
1	SET={G,J,E,H}	hashtable={I}
1	BEAM={G}	hash table={I,G}
2	SET={D,G,I}	hashtable={I,G}
2	BEAM={D}	hash table={I,D,G}
3	SET={G}	hashtable={I,D,G}
3	BEAM={}	hash table={I,D,G}

此时BEAM 为空，导致搜索失败。
因此$B$的选择非常重要。

exmple 2 $B$ = 2 搜索到非最优值

loop number	SET,BEAM	hash table
	BEAM={I}	hash_table = { , I(null), , , , , }
1	SET={G(I), J(I), E(I), H(I)}	hash_table = { , I(null), , , , , }
1	BEAM={ G(I), J(I) }	hash_table = { , I(null), J(I), , , , G(I) }
2	SET={A(J), D(G), G(J), J(G), E(J), I(G)}	hash_table = { , I(null), J(I), , , , G(I) }
2	BEAM={A(J), D(G)}	hash_table = { A(J), I(null), J(I), D(G), , , G(I) }
3	SET={C(A), G(D), J(A)}	hash_table = { A(J), I(null), J(I), D(G), , , G(I) }
3	BEAM={C(A)}	hash_table = { A(J), I(null), J(I), D(G), C(A), _, G(I) }
4	SET = { B(C) [goal found - algorithm returns], A(C) }	hash_table = { A(J), I(null), J(I), D(G), C(A), _, G(I) }

此例中 beam search 搜索到了一个路径：IJACB，但不是最优解（IECB)
展示了并不是每次循环BEAM都能被填充满（step 3）

exmple 3 $B$ = 3,找到最优值，并且内存没有溢出

loop number	SET,BEAM	hash table
	BEAM={I}	hash_table = { , I(null), , , , , }
1	SET={G(I), J(I), E(I), H(I)}	hash_table = { , I(null), , , , , }
1	BEAM = { G(I), J(I), E(I) }	hash_table = { , I(null), J(I), , E(I), _, G(I) }
2	SET = { A(J), C(E), D(G), F(E), G(J), J(E), E(J), H(E), I(E) }	hash_table = { , I(null), J(I), , E(I), _, G(I) }
2	BEAM = { A(J), C(E), D(G) }	hash_table = { A(J), I(null), J(I), C(E), E(I), D(G), G(I) }
3	SET = { B(C) [goal found - algorithm returns], A(C), C(A), J(A) }	hash_table = { A(J), I(null), J(I), C(E), E(I), D(G), G(I) }

$B$=3 beam search可以找到最优值，但是当B更大时，会造成可用内存溢出（hash table 溢出）

exmple 4 $B$ = 4 内存占用过多

loop number	SET,BEAM	hash table
	BEAM={I}	hash_table = { , I(null), , , , , }
1	SET={G(I), J(I), E(I), H(I)}	hash_table = { , I(null), , , , , }
1	BEAM = { G(I), J(I), E(I), H(I) }	hash_table = { H(I), I(null), J(I), , E(I), , G(I) }
2	SET = { A(J), C(E), D(G), F(E), G(J), J(E), E(H), H(E), I(E) }	hash_table = { H(I), I(null), J(I), , E(I), , G(I) }
2	BEAM = { A(J), C(E), D(G) [not enough memory - algorithm returns] }	hash_table = { H(I), I(null), J(I), A(J), E(I), C(E), G(I) }

第二步时造成内存溢出，搜索失败。

参考资料

http://jhave.org/algorithms/graphs/beamsearch/beamsearch.shtml