Question

我正在为旧的北欧tafl家庭棋盘游戏编写人工智能（project here，source file at issue here）。他们足够接近国际象棋，以便在这里适用国际象棋AI的知识。（有问题的变体是在7x7板上进行的，具有径向对称的起始位置，白色从中间开始，黑色从边缘开始。）我遇到了一个奇怪的问题，我是如何实现alpha的-beta search：搜索到固定深度的结果，除了alpha-beta修剪之外没有启用优化，根据探测节点的顺序而改变。

在相关文件中，重要的方法是“探索＆＃39;探索儿童＆＃39;，＆＃39; handleEvaluationResults＆＃39;以及＆＃39; generateSuccessorMoves＆＃39;。＆＃39;探索＆＃39;检查是否有转置表命中（在此测试的其他地方禁用），如果它是胜利或叶子节点则评估状态，或者调用exploreChildren。 exploreChildren对子节点进行递归搜索。 generateSuccessorMoves生成（并可选择排序）退出当前状态的移动。 handleEvaluationResults确定子评估是否导致截止。

所以，我编写了一个最小的测试用例：generateSuccessorMoves首先不进行任何排序，然后简单地对移动列表进行洗牌而不是对其进行排序。搜索的结果在结果上不等同，也不在考虑对称性的结果中，也不在结果中：

MAIN SEARCH
# cutoffs/avg. to 1st a/b a/b
Depth 0: 0/0 0/0
Depth 1: 0/22 0/1
Depth 2: 42/0 3/0
Finding best state...
Best move: d3-g3 with path...
    d3-g3
    e1-f1
    e4-e1xf1
End of best path scored -477
Observed/effective branching factor: 23.00/9.63
Thought for: 72msec. Tree sizes: main search 893 nodes, continuation search: 0 nodes, horizon search: 0 nodes
Overall speed: 12402.77777777778 nodes/sec
Transposition table stats: Table hits/queries: 0/0 Table inserts/attempts: 0/0
1. move: d3-g3 value: -477
Using 5000msec, desired 9223372036854775807
Depth 3 explored 1093 states in 0.037 sec at 29540.54/sec
MAIN SEARCH
# cutoffs/avg. to 1st a/b a/b
Depth 0: 0/0 0/0
Depth 1: 0/21 0/2
Depth 2: 104/0 2/0
Finding best state...
Best move: d3-f3 with path...
    d3-f3
    d2-c2
    d5-f5xf4
End of best path scored -521
Observed/effective branching factor: 23.00/10.30
Thought for: 37msec. Tree sizes: main search 1093 nodes, continuation search: 0 nodes, horizon search: 0 nodes
Overall speed: 29540.540540540544 nodes/sec
Transposition table stats: Table hits/queries: 0/0 Table inserts/attempts: 0/0
7. move: d3-f3 value: -521

显然，这是一个极端的情况，但我的理解是，在这种情况下（即除了＆alpha-beta修剪之外没有任何功能）的alpha-beta应该是稳定的无论搜索的顺序是什么 - 至少，它应该返回一个具有相同值的节点。我错了吗？我做错了吗？

首先编辑：虽然我认为从这个问题的描述中可以看出这一点，但事实证明我的alpha-beta实现中存在一些尚未知的错误。进一步的测试表明它没有提供与纯minimax相同的结果。

第二次编辑：这是在上面链接的文件中实现的alpha-beta搜索的伪代码版本。

explore(depth, maxDepth, alpha, beta)
    // some tafl variants feature rules where one player moves more than once in a turn
    // each game tree node knows whether it's maximizing or minimizing
    var isMaximizing = this.isMaximizing()
    var value = NO_VALUE

    if(isTerminal(depth, maxDepth))
        value = eval()
    else
        for(move in successorMoves)
            if(cutoff) break

            nodeValue = nextNode(move).explore(depth + 1, maxDepth, alpha, beta)
            if(value == NO_VALUE) value = nodeValue

            if(isMaximizing)
                value = max(value, nodeValue)
                alpha = max(alpha, value)
                if(beta <= alpha) break
            else
                value = min(value, nodeValue)
                beta = min(beta, value)
                if(beta <= alpha) break


rootNode.explore(0, 5, -infinity, infinity)

Answer 1

事实证明这是我的错。我有一些代码递归地重新评估某个节点上方的节点，用于扩展搜索，我在错误的地方调用它（在探索任何节点的所有子节点之后）。早期的反向传播导致了不正确的α和β值，因此提前截止。

alpha-beta搜索中出现意外的路径依赖？

1 个答案: