AI TicTacToe 游戏中的 Minimax 方法

Question

下面的代码描述了一个AI TicTacToe游戏（主文件是game.py）

**player.py:**

import math
import random


class Player():
    def __init__(self, letter):
        self.letter = letter

    def get_move(self, game):
        pass


class HumanPlayer(Player):
    def __init__(self, letter):
        super().__init__(letter)

    def get_move(self, game):
        valid_square = False
        val = None
        while not valid_square:
            square = input(self.letter + '\'s turn. Input move (0-9): ')
            try:
                val = int(square)
                if val not in game.available_moves():
                    raise ValueError
                valid_square = True
            except ValueError:
                print('Invalid square. Try again.')
        return val


class RandomComputerPlayer(Player):
    def __init__(self, letter):
        super().__init__(letter)

    def get_move(self, game):
        square = random.choice(game.available_moves())
        return square


class SmartComputerPlayer(Player):
    def __init__(self, letter):
        super().__init__(letter)

    def get_move(self, game):
        if len(game.available_moves()) == 9:
            square = random.choice(game.available_moves())
        else:
            square = self.minimax(game, self.letter)['position']
        return square

    def minimax(self, state, player):
        max_player = self.letter  # yourself
        other_player = 'O' if player == 'X' else 'X'

        # first we want to check if the previous move is a winner
        if state.current_winner == other_player:
            return {'position': None, 'score': 1 * (state.num_empty_squares() + 1) if other_player ==       max_player else -1 * (
                        state.num_empty_squares() + 1)}
        elif not state.empty_squares():
            return {'position': None, 'score': 0}

        if player == max_player:
            best = {'position': None, 'score': -math.inf}  # each score should maximize
        else:
            best = {'position': None, 'score': math.inf}  # each score should minimize
        for possible_move in state.available_moves():
            state.make_move(possible_move, player)
            sim_score = self.minimax(state, other_player)  # simulate a game after making that move

            # undo move
            state.board[possible_move] = ' '
            state.current_winner = None
            sim_score['position'] = possible_move  # this represents the move optimal next move

            if player == max_player:  # X is max player
                if sim_score['score'] > best['score']:
                    best = sim_score
            else:
                if sim_score['score'] < best['score']:
                    best = sim_score
        return best

**game.py:**

import math
import time
from player import HumanPlayer, RandomComputerPlayer, SmartComputerPlayer


class TicTacToe():
    def __init__(self):
        self.board = self.make_board()
        self.current_winner = None

    @staticmethod
    def make_board():
        return [' ' for _ in range(9)]

    def print_board(self):
        for row in [self.board[i*3:(i+1) * 3] for i in range(3)]:
            print('| ' + ' | '.join(row) + ' |')

    @staticmethod
    def print_board_nums():
        # 0 | 1 | 2
        number_board = [[str(i) for i in range(j*3, (j+1)*3)] for j in range(3)]
        for row in number_board:
            print('| ' + ' | '.join(row) + ' |')

    def make_move(self, square, letter):
        if self.board[square] == ' ':
            self.board[square] = letter
            if self.winner(square, letter):
                self.current_winner = letter
            return True
        return False

    def winner(self, square, letter):
        # check the row
        row_ind = math.floor(square / 3)
        row = self.board[row_ind*3:(row_ind+1)*3]
        # print('row', row)
        if all([s == letter for s in row]):
            return True
        col_ind = square % 3
        column = [self.board[col_ind+i*3] for i in range(3)]
        # print('col', column)
        if all([s == letter for s in column]):
            return True
        if square % 2 == 0:
            diagonal1 = [self.board[i] for i in [0, 4, 8]]
            # print('diag1', diagonal1)
            if all([s == letter for s in diagonal1]):
                return True
            diagonal2 = [self.board[i] for i in [2, 4, 6]]
            # print('diag2', diagonal2)
            if all([s == letter for s in diagonal2]):
                return True
        return False

    def empty_squares(self):
        return ' ' in self.board

    def num_empty_squares(self):
        return self.board.count(' ')

    def available_moves(self):
        return [i for i, x in enumerate(self.board) if x == " "]


def play(game, x_player, o_player, print_game=True):

    if print_game:
        game.print_board_nums()

    letter = 'X'
    while game.empty_squares():
        if letter == 'O':
            square = o_player.get_move(game)
        else:
            square = x_player.get_move(game)
        if game.make_move(square, letter):

            if print_game:
                print(letter + ' makes a move to square {}'.format(square))
                game.print_board()
                print('')

            if game.current_winner:
                if print_game:
                    print(letter + ' wins!')
                return letter  # ends the loop and exits the game
            letter = 'O' if letter == 'X' else 'X'  # switches player

        time.sleep(.8)

    if print_game:
        print('It\'s a tie!')



if __name__ == '__main__':
    x_player = SmartComputerPlayer('X')
    o_player = HumanPlayer('O')
    t = TicTacToe()
    play(t, x_player, o_player, print_game=True)

如您所见，程序员使用了 minimx 算法来最小化失败的可能性并最大化获胜的可能性。 现在，在尝试了解这种 minimax 方法的工作原理几天之后，我忍不住请你们向我解释一下。

1.将此代码添加到 player.py 背后的原因是什么？该方法如何返回大于负无穷大初始值的分数？：

if player == max_player:
 best = {'position': None, 'score': -math.inf}
else:
 best = {'position': None, 'score': math.inf}

2. 在我们的 simscore variabel 中，我们将其他玩家参数添加到我们的 minimax function 中。我们为什么要这样做？ 我们不需要将变量 max_player 作为参数添加到 minimax() 来模拟游戏吗？

3. 在这个具体案例中递归是如何工作的？

Answer 1

1.将此代码添加到 player.py 背后的原因是什么？该方法如何返回大于负无穷大初始值的分数？：

if state.current_winner == other_player:
    return {
        'position': None,
        'score': 1 * (state.num_empty_squares() + 1) if other_player == max_player else -1 * (state.num_empty_squares() + 1)}

或者我认为交替：

    if state.current_winner == other_player:
        position = None
        score = state.num_empty_squares() + 1
        if other_player == max_player:
            score = -score
        return {'position': None, 'score': score}

如果在所有移动树中最后移动的玩家“获胜”，那么这最终对那个玩家有利，对另一个玩家不利。 有更多空位的胜利更好。

2. 在我们的 simscore variabel 中，我们将其他玩家参数添加到我们的 minimax function 中。我们为什么要这样做？ 我们不需要将变量 max_player 作为参数添加到 minimax() 来模拟游戏吗？

minimax()被称为递归模拟游戏。 当调用它时，它通过other_player = 'O' if player == 'X' else 'X'切换玩家，当我们将“当前” other_player到下一个动作时，minimax minimax()可以确定谁在此调用中移动。

3. 在这种特定情况下递归如何工作？

每次调用minimax()都允许两个玩家之一进行模拟移动。 在这个方法中，当前移动的玩家是other_player 。 根据当前游戏 state 选择移动，并调用 minimax minimax()来模拟下一个玩家移动。