Alpha Beta Pruning in Adversarial Search
Minimax Implementation
def max-value(state):
initialize v = -∞
for each successor of state:
v = max(v, min-value(successor))
return v
def min-value(state):
initialize v = +∞
for each successor of state:
v = min(v, max-value(successor))
return v
V ( s ) = m a x ( V ( s ′ ) ) s ′ ∈ s u c c e s s o r ( s ) V(s) = max(V(s')) s' \in successor(s) V(s)=max(V(s′))s′∈successor(s)
V ( s ′ ) = m i n ( V ( s ) ) s ∈ s u c c e s s o r ( s ′ ) V(s') = min(V(s)) s \in successor(s') V(s′)=min(V(s))s∈successor(s′)
Alpha Beta Pruning
General configuration (MIN version)
We’re computing the MIN-VALUE at some node n
We’re looping over n’s children
n’s estimate of the childrens’ min is dropping
Who cares about n’s value? MAX
Let
α
\alpha
α be the best value that MAX can get at any choice point along the current path from the root
If n becomes worse than
α
\alpha
α, MAX will avoid it, so we can stop considering n’s other children (it’s already bad enough that it won’t be played)
MAX version is symmetric
Examples

To start with, we know nothing about the bounds, so we set α = − ∞ , β = ∞ \alpha = - \infty, \beta = \infty α=−∞,β=∞.

Then we passing along the bounds to the child, child’s child…


Now we reach at the level: depth of 4. We run our evaluation functions here.
An evaluation function is like:
Ideal function: returns the actual minimax value of the position
In practice: typically weighted linear sum of features:
E
v
a
l
(
s
)
=
w
1
f
1
(
s
)
+
⋅
⋅
⋅
+
w
n
f
n
(
s
)
Eval(s) = w_1f_1(s) + \cdot\cdot\cdot + w_nf_n(s)
Eval(s)=w1f1(s)+⋅⋅⋅+wnfn(s).
We get value 3, since this is a min node, we now know the minmax value must be less than or equal to 3, thus, we set β = 3 \beta = 3 β=3.

Next child in depth 4 is value 17, while 17 > 3, we ignore this child.
All children handled, we return to depth 3. we have β = 3 \beta = 3 β=3 here, so we can set α = 3 \alpha = 3 α=3 at the depth 2 node.

We pass along the bounds of depth2 to next child of depth3.


At this moment, we get
α
=
3
a
n
d
β
=
2
,
α
>
β
\alpha = 3 \space and \space \beta = 2, \alpha > \beta
α=3 and β=2,α>β.
If these values are to change, children values would be greater than 3 and less than 2, which is impossible. We can prune any children and return.
We do these steps recursively, we will reach this:

Some pictures and ideas comes from h t t p s : / / w w w . c s . u c l a . e d u / https://www.cs.ucla.edu/ https://www.cs.ucla.edu/.
Two Quiz
notice: I do not have answers.


本文深入探讨了AlphaBeta剪枝算法在对抗搜索中的应用,详细解释了Minimax实现原理及AlphaBeta剪枝如何通过限制搜索空间来提高效率。文章通过递归函数max-value和min-value展示了算法流程,并用实例说明了剪枝过程。
1696

被折叠的 条评论
为什么被折叠?



