Minimax 算法在识别赢/输场景时错误地采取行动

Question

python 中的以下minimax算法旨在找到给定连接四板中可能移动的值。 它由另一个 function computer_move调用，也如下所示。

预期行为： minimax将返回基于棋盘 state 和玩家的 position 的评估。

• 如果玩家是一个，它返回最高值移动的评估。

• 如果玩家是两人，则返回最低值移动的评估。

minimax由computer_move调用，它获取返回值并从中选择最佳值。

实际行为： computer_move似乎成功地从minimax的返回值中选择了最佳着法，但 minimax 没有正确评估不同的着法。 具体而言，未正确评估获胜案例或可以阻止获胜的案例。 中间情况有未知行为，因为 static 评估 function 尚未实施。 然而，在任何一方的胜利是一次性的情况下，算法无法正确反应。

我已经尝试在两个函数中切换各种标志并交换最小值/最大值，但这似乎并没有解决问题。 仔细使用 print 语句还告诉我computer_move正在正确处理返回值，但minimax返回不正确的值，这表明算法存在一些错误。 然而，它似乎是教科书上的极小极大算法，至少在我看来是这样。

有人对问题可能有什么建议吗？ 谢谢！

极小极大 function：

def minimax(board, depth, alpha, beta, player, move):
    # Base cases
    if check_winning(board, 1) or check_winning(board, 2):
        player = player*2-3     #Convert to +/-1
        return player*math.inf
    elif depth==0:
        return static_eval(board)

    # Player 1 finds highest value move
    if player==1:
        max_eval = -math.inf
        for move in range(COLUMNS):
            if valid_move(board, move):
                make_move(board, move, player)
                eval = minimax(board, depth-1, alpha, beta, 2, move)
                unmake_move(board, move)
                max_eval = max(max_eval, eval)
                alpha = max(alpha, eval)
                if beta <= alpha:
                    break
        return max_eval

    # Player 2 finds lowest (for player one) value move
    else:
        min_eval = math.inf
        for move in range(COLUMNS):
            if valid_move(board, move):
                make_move(board, move, player)
                #print_board(board)
                eval = minimax(board, depth-1, alpha, beta, 1, move)
                unmake_move(board, move)
                min_eval = min(min_eval, eval)
                beta = min(beta, eval)
                if beta <= alpha:
                    break
        return min_eval

调用 minimax function 并实施最佳着法：

# Get list of move values, and choose highest/lowest depending on player

def computer_move(board, player, difficulty=3):
    move_vals=[]
    for move in range(COLUMNS):
        if(valid_move(board, move)):
            move_vals.append(minimax(board,
                                     difficulty, 
                                     -math.inf, 
                                     math.inf, 
                                     player, 
                                     move))
        else:
            move_vals.append(-math.inf)

    min_val = min(move_vals)
    max_val = max(move_vals)
    if(player==1):
        move = move_vals.index(max_val)
    else:
        move = move_vals.index(min_val)

    make_move(board, move, player)

    print('Here is the computer\'s move:')
    print_board(board)

Answer 1

这里有一个问题：

 if check_winning(board, 1) or check_winning(board, 2):
        player = player*2-3     #Convert to +/-1
        return player*math.inf

在您的情况下，如果玩家 1 获胜并且轮到他了，您将发回 -infininty 的分数。 将案例拆分成不同的语句，这样可以更容易调试。 此外，您不需要 depth == 0，您可以检查棋盘何时已满，如果是这种情况，则为平局。

if check_winning(board, current_player):
    return math.inf
if check_winning(board, the_other_player):
    return -math.inf
if is_board_full(board):
    return 0

您可能还希望包含始终为 go 的深度以获得最短可能的获胜/最长可能的失败，并且您也不需要像 inf 这样大的值：

if check_winning(board, current_player):
    return (10+depth)
if check_winning(board, the_other_player):
    return -(10+depth)
if is_board_full(board):
    return 0

Answer 2

结果发现有两个问题：

1. 因为minimax function 被硬编码为玩家一最大化和玩家二最小化，玩家一获胜必须返回正值，玩家二获胜必须始终返回负值
2. computer_move function 需要在调用minimax function 之前将潜在的移动添加到棋盘上，并在调用之后取消它们

这是更新后的代码：

def minimax(board, depth, alpha, beta, player, previous_move):
    # Change 1
    if check_winning(board, 1):
        return 100+depth
    if check_winning(board, 2):
        return -(100+depth)
    elif depth==0:
        return static_eval(board)

    # Player 1 finds highest value move
    if player==1:
        max_move_eval = -math.inf
        for move in range(COLUMNS):
            if valid_move(board, move):
                make_move(board, move, player)
                move_eval = minimax(board, depth-1, alpha, beta, 2, move)
                unmake_move(board, move)
                max_move_eval = max(max_move_eval, move_eval)
                alpha = max(alpha, move_eval)
                if beta <= alpha:
                    break
        return max_move_eval

    # Player 2 finds lowest (for player one) value move
    else:
        min_move_eval = math.inf
        for move in range(COLUMNS):
            if valid_move(board, move):
                #print_board(board)
                make_move(board, move, player)
                move_eval = minimax(board, depth-1, alpha, beta, 1, move)
                unmake_move(board, move)
                min_move_eval = min(min_move_eval, move_eval)
                beta = min(beta, move_eval)
                if beta <= alpha:
                    break
        return min_move_eval

def computer_move(board, difficulty, player):
    other_player = int(not bool(player-1))+1
    move_vals=[]
    for move in range(COLUMNS):
        if(valid_move(board, move)):
            # Change 2
            make_move(board, move, player)
            move_vals.append(minimax(board,
                                     difficulty, 
                                     -math.inf, 
                                     math.inf, 
                                     other_player, 
                                     move))
            unmake_move(board, move)
        else:
            if(player==2):
                move_vals.append(-math.inf)
            if(player==1):
                move_vals.append(math.inf)

    min_val = min(move_vals)
    max_val = max(move_vals)
    if(player==1):
        move = move_vals.index(max_val)
    else:
        move = move_vals.index(min_val)

    make_move(board, move, player)

    print('Here is the computer\'s move:')
    print_board(board)