将Minimax转换为Negamax（python）

我正在制作一个奥赛罗播放器，并使用alpha-beta剪枝实现了一个minimax算法。然后我在网上做了一系列关于最好的算法的研究，并不断听到他们都使用的negamax算法。似乎大多数人认为negamax比minimax快，因为它不会在min和max player？之间切换，所以如果不太难的话，我想把minimax算法转换成negamax

我想知道人们是否了解使用negamax的速度有多快，以及关于如何将我的minimax代码转换为negamax算法的任何提示或代码，我将不胜感激

这是我的极小极大算法：

def minimax(Board, maximizingPlayer, depth, count):
     # maximizing player has 'B' and minimizing 'W'
     if maximizingPlayer: player, opp = Board.player, Board.opp
     else: player, opp = Board.opp, Board.player

     moves_list = Board.get_moves_list(player, opp)
     best_move = (-1,-1)

     # base case
     if ( depth==0 or moves_list == [] ):
         best_score, parity, mobility, stability = Board.evaluate()
         best_move = (-1, -1)
         return best_score, best_move, count

     # maximizing player
     if maximizingPlayer:
           best_score = float("-inf")
           for move in moves_list:
                new_board = deepcopy(Board)
                new_board.play_legal_move(move[0], move[1], player, opp, flip=True)
                the_score, the_move, count = minimax(new_board, False, depth-1, count+1)
                best_score = max(best_score, the_score)
                if (the_score == best_score):
                    best_move = move

           return best_score, best_move, count
     # minimzing player
     else:
           best_score = float("inf")
           for move in moves_list:
                new_board = deepcopy(Board)
                new_board.play_legal_move(move[0], move[1], player, opp, flip=True)
                the_score, the_move, count = minimax(new_board, True, depth-1, count+1)
                best_score = min(best_score, the_score)
                if (the_score == best_score):
                    best_move = move

           return best_score, best_move, count

因为我收到了关于我的Alpha-beta修剪的回复，这里是：

def alphabeta(Board, maximizingPlayer, depth, count, alpha, beta):
     # maximizing player has 'B' and minimizing 'W'
     if maximizingPlayer: player, opp = Board.player, Board.opp
     else: player, opp = Board.opp, Board.player

     moves_list = Board.get_moves_list(player, opp)
     best_move = (-1,-1)

     # base case
     if ( depth==0 or moves_list == [] ):
         best_score, parity, mobility, stability = Board.evaluate()
         best_move = (-1, -1)
         return best_score, best_move, count

     # maximizing player
     if maximizingPlayer:
           best_score = float("-inf")
           for move in moves_list:
                new_board = deepcopy(Board)
                new_board.play_legal_move(move[0], move[1], player, opp, flip=True)
                the_score, the_move, count = alphabeta(new_board, False, depth-1, count+1, alpha, beta)
                if (the_score > alpha):
                    alpha = the_score
                    best_move = move
                if beta <= alpha: break

           return alpha, best_move, count
     # minimzing player
     else:
           best_score = float("inf")
           for move in moves_list:
                new_board = deepcopy(Board)
                new_board.play_legal_move(move[0], move[1], player, opp, flip=True)
                the_score, the_move, count = alphabeta(new_board, True, depth-1, count+1, alpha, beta)
                if (the_score < beta):
                    beta = the_score
                    best_move = move
                if beta <= alpha: break

           return beta, best_move, count

---

我认为现在您已经实现了minimax，这已经足够好了，但是您需要实现minimax中最重要的优化，即修剪，这将是对代码的一个简单更改，在速度上有非常显著的提高

编辑：-

注意，您已经使用了alpha-beta，因此可以实现negamax，但是您认为它没有切换的想法是不正确的，但是它减少了minimax的代码，我怀疑速度是否有显著提高。这里的想法是，一个玩家移动的点数始终是另一个玩家的-ve，但大小相同，允许您计算maxa，b=-min-a，-b

简单翻译如下：-

score = -negamax(depth-1,-player)
best = max(score,best)

这些是使用negamax计算minimax的唯一行

在这里，您不需要交替评估最小值和最大值，但事实上，给予最小值玩家的分数始终为正玩家的负值就足够了，这样您就可以始终评估最大值以获得正确的分数

注：-

---

就速度而言，这不是一个重要的优化，但它使代码简单易读，因此值得一试，但不幸的是，您需要删除大量代码才能将代码转换为negamax，因此我建议不要这样做。

我认为现在您已经实现了minimax，这已经足够好了，但您需要实现minimax中最重要的优化这就是删减，这将是对代码的一个简单更改，在速度上有非常显著的提高

编辑：-

注意，您已经使用了alpha-beta，因此可以实现negamax，但是您认为它没有切换的想法是不正确的，但是它减少了minimax的代码，我怀疑速度是否有显著提高。这里的想法是，一个玩家移动的点数始终是另一个玩家的-ve，但大小相同，允许您计算maxa，b=-min-a，-b

简单翻译如下：-

score = -negamax(depth-1,-player)
best = max(score,best)

这些是使用negamax计算minimax的唯一行

在这里，您不需要交替评估最小值和最大值，但事实上，给予最小值玩家的分数始终为正玩家的负值就足够了，这样您就可以始终评估最大值以获得正确的分数

注：-

---

就速度而言，这不是一个显著的优化，但它使代码简单易读，因此值得一试，但不幸的是，您需要删除大量代码才能将代码转换为negamax，因此我建议不要这样做。

感谢您的回复！实际上我已经实现了Alpha-beta修剪，所以不需要。对不起，我没说清楚。如果可以的话，我会更新我的问题并加入alpha-beta代码。我一直听说negamax比minimax快。真的吗，执行几十次乘法比单个if分支更快…？分支会影响指令管道，在许多情况下，硬件会预计算下一条指令，但分支意味着如果分支预测错误，它必须放弃所有计算，因此，分支被认为比几十次乘法更糟糕。此外，就CUDA中的并行计算而言，分支可能很糟糕，因为分支线程可能会花费更多或更少的时间，因此线程同步会浪费很多时间。感谢您的响应！实际上我已经实现了Alpha-beta修剪，所以不需要。对不起，我没说清楚。如果可以的话，我会更新我的问题并加入alpha-beta代码。我一直听说negamax比minimax快。真的吗，执行几十次乘法比单个if分支更快…？分支会影响指令管道，在许多情况下，硬件会预计算下一条指令，但分支意味着如果分支预测错误，它必须放弃所有计算，因此，分支被认为比几十次乘法更糟糕。此外，就CUDA中的并行计算而言，分支可能是不好的，因为分支线程可能会花费更多或更少的时间，因此线程同步会浪费很多时间。