实现 Minimax 算法的问题

Question

我一直在尝试为一个简单的国际象棋机器人实现一个 Minimax 算法，我觉得我理解它背后的基础知识和一般原则，但我的代码并没有真正起作用，我正试图找出原因。

这是我的 function 用于生成 boardScore。

const boardScore = (fen) => {
    // fen = rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
    // caps are for white
    // white is maximizing player
    const pieceWorth = {
      p: -1,
      P: 1,
      k: -3,
      K: 3,
      b: -3,
      B: 3,
      r: -5,
      R: 5,
      q: -3,
      Q: 3,
      k: -99999,
      K: 99999,
    };
    const pieces = fen.split(" ")[0].split("");
    const score = 0;
    for (const piece in pieces) {
      score += pieceWorth[pieces[piece]] || 0;
    }

    if (game.turn() === "b" && game.in_checkmate()) score += 99999999;
    if (game.turn() === "w" && game.in_checkmate()) score -= 99999999;

    return score;
  };

这是我调用的根极小极大 function 的代码。 目前我只是想让它适用于黑色棋子（轮到人工智能）

const minimaxRoot = (game, depth) => {
    // checking for black - minimizing player
    const minUtility = Infinity;
    let bestMove = null;

    const moves = game.moves();
    for (let i = 0; i < moves.length; i++) {
      game.move(moves[i]);
      let score = minimax(game, depth - 1);
      if (score < minUtility) {
        minUtility = score;
        bestMove = moves[i];
      }
      game.undo();
      console.log(minUtility);
      return bestMove;
    }
  };

这是我的极小极大算法。

// white is maximizing player
  const minimax = (game, depth, white) => {
    console.count();
    if (depth === 0) {
      return boardScore(game.fen());
    }

    const moves = game.moves();

    if (white) {
      let bestScore = -Infinity;
      for (let i = 0; i < moves.length; i++) {
        game.move(moves[i]);
        let score = minimax(game, depth - 1, false);
        bestScore = Math.max(bestScore, score);
        game.undo();
      }
      return bestScore;
    } else {
      let bestScore = Infinity;
      for (let i = 0; i < moves.length; i++) {
        game.move(moves[i]);
        let score = minimax(game, depth - 1, true);
        bestScore = Math.min(bestScore, score);
        game.undo();
      }
      return bestScore;
    }
  };

这就是我调用 function 的方式，当我采取行动时会发生这种情况。

const blackMove = () => {
    game.move(minimaxRoot(game, 3));
    setPosition(game.fen());
  };

任何帮助，将不胜感激。 在这两天的大部分时间里，我一直在努力解决这个问题，但进展甚微。 我见过的大多数示例都包括某种形式的 alpha-beta 修剪或转置表或移动排序，这使它变得更加复杂，这让我难以理解。

Answer 1

首先，不要使用极小极大算法。 与alpha-beta相比，它效率低下。 为了更简单，您应该在NegaMax框架中使用 Alpha Beta。

使用 NegaMax 的注意事项：评估 function 应相对于侧面移动。

那么，你对function的评价仅仅基于物质平衡，没有像样的打法是不够的。 关于评估的两个好的（和简单的）页面：
https://www.chessprogramming.org/Simplified_Evaluation_Function
https://www.chessprogramming.org/PeSTO%27s_Evaluation_Function

对于更复杂/高级的搜索实现：

• MiniMax 和 AlphaBeta 算法在这里得到了很好的解释

• 转置表在这里得到了很好的解释，而 Zobrist Hashing在这里得到了很好的解释。 （简化的）想法是不要（浪费时间）搜索以前搜索过的 position，我们更愿意存储他们的分数。

• 移动排序是一个简单的事实，AlphaBeta 的性能取决于移动的顺序：如果它有最好的移动首先搜索它会更快。 所以我们近似传递alphaBeta的移动顺序（例如QxP不好，因为PxQ =>首先搜索好的捕获）。

• 此外，为了在国际象棋引擎中拥有一副像样的国际象棋，必须有一个静止搜索，以避免地平线效应。

我已经在 JavaScript 中的（我认为）评论很好的国际象棋引擎中实现了所有这些东西。

我认为这应该是 NegaMax 方式的 AlphaBeta 算法的工作代码：

const alphaBeta = (game, depth, white, alpha=-Infinity, beta=Infinity) => {
    console.count();
    if (depth === 0) {
        var view = white ? 1 : -1;
        return view * boardScore(game.fen());
    }

    const moves = game.moves();

    let bestScore = -Infinity;
        for (let i = 0; i < moves.length; i++) {
                game.move(moves[i]);
            let score = -alphaBeta(game, depth - 1, !white, -beta, -alpha);
            game.undo();
            if( score >= beta ) {
                return beta;   //  fail hard beta-cutoff
            }
            if( score > alpha ) {
                alpha = score; // alpha acts like max in MiniMax
            }
        }

    return alpha;
 
};

Answer 2

当它在 2 个动作之间交替时，通常意味着它选择了列表中的第一个动作并且没有找到更好的动作。

这里的问题很常见，它与您的评估 function 有关。 你总是为黑色返回一个负值，即使是黑色在极小值循环中转动（而白色则相反）。 如果是黑人转移动，则需要返回-score ，如果是白人转，则需要score 。 如果您的极小极大循环中没有其他问题，那么这应该可以解决您的问题。

稍后您会遇到的另一件事是您没有检查将死或绘制您的极小极大 function。 在检查深度是否== 0的地方，您还需要检查游戏是否以任何方式结束，然后返回，否则即使游戏结束它也会继续计算，这会产生非常奇怪的结果。