Python人工智能 – 游戏

游戏是用策略进行的。每个玩家或团队在开始游戏前都会制定一个策略，他们必须根据游戏中的当前情况改变或建立新的策略。

搜索算法

你将不得不考虑计算机游戏，其策略也与上述相同。请注意，搜索算法是在计算机游戏中找出策略的算法。

它是如何工作的

搜索算法的目标是找到最佳的棋步集，以便他们能够到达最终目的地并获胜。这些算法使用获胜的条件集，每个游戏都不同，以找到最佳的动作。

把计算机游戏想象成一棵树。我们知道，树有节点。从根部开始，我们可以来到最后的获胜节点，但要有最佳的动作。这就是搜索算法的工作。这种树上的每个节点都代表一个未来状态。搜索算法通过这棵树进行搜索，在游戏的每个步骤或节点上做出决定。

组合搜索

使用搜索算法的主要缺点是它们具有穷举性质，这就是为什么它们要探索整个搜索空间以找到导致资源浪费的解决方案。如果这些算法需要搜索整个搜索空间来寻找最终的解决方案，那就更麻烦了。

为了消除这种问题，我们可以使用组合搜索，它使用启发式来探索搜索空间，并通过消除可能的错误动作来减少其大小。因此，这种算法可以节省资源。这里讨论了一些使用启发式搜索空间和节省资源的算法

最小值算法

这是组合搜索使用的策略，使用启发式来加速搜索策略。Minimax策略的概念可以通过双人游戏的例子来理解，在游戏中，每个玩家都试图预测对手的下一步行动，并试图使该函数最小化。另外，为了取胜，玩家总是试图根据当前的情况使自己的函数最大化。

启发式在这类策略中起着重要作用，如最小化策略。树上的每个节点都有一个与之相关的启发式函数。基于该启发式，它将决定向对其最有利的节点移动。

Alpha-Beta修剪

Minimax算法的一个主要问题是，它可以探索树的那些不相关的部分，导致资源的浪费。因此，必须有一个策略来决定树的哪一部分是相关的，哪一部分是不相关的，并让不相关的部分不被探索。Alpha-Beta修剪就是这样一种策略。

Alpha-Beta修剪算法的主要目标是避免搜索树上那些没有任何解决方案的部分。Alpha-Beta修剪的主要概念是使用两个界限，即 Alpha （最大下限）和 Beta （最小上限）。这两个参数是限制可能解决方案集合的值。它将当前节点的值与阿尔法和贝塔参数的值进行比较，这样它就可以移动到树上有解决方案的部分，而舍弃其他部分。

Negamax算法

这种算法与Minimax算法没有区别，但它的实现方式更优雅。使用Minimax算法的主要缺点是，我们需要定义两个不同的启发式函数。这些启发式函数之间的联系是，一个游戏的状态对一个玩家越好，对另一个玩家就越差。在Negamax算法中，两个启发式函数的相同工作是在一个启发式函数的帮助下完成的。

建立机器人来玩游戏

为了在人工智能中建立机器人来玩双人游戏，我们需要安装 easyAI 库。它是一个人工智能框架，提供建立双人游戏的所有功能。你可以在以下命令的帮助下下载它 —

pip install easyAI

一个玩 “最后的硬币 “的机器人

在这个游戏中，会有一堆硬币。每个玩家必须从这堆硬币中取出一定数量的硬币。游戏的目标是避免拿走这堆硬币中的最后一个。我们将使用从 easyAI 库的 TwoPlayersGame 类中继承的 LastCoinStanding 类。下面的代码显示了这个游戏的Python代码 –

导入所需的包，如图所示 –

from easyAI import TwoPlayersGame, id_solve, Human_Player, AI_Player
from easyAI.AI import TT

现在，从 TwoPlayerGame 类中继承该类，以处理游戏的所有操作 —

class LastCoin_game(TwoPlayersGame):
   def __init__(self, players):

现在，定义球员和要开始比赛的球员。

self.players = players
self.nplayer = 1

现在，定义游戏中的硬币数量，这里我们使用15个硬币进行游戏。

self.num_coins = 15

定义一个玩家在一次移动中可以采取的最大硬币数量。

self.max_coins = 4

现在有一些特定的东西需要定义，如以下代码所示。定义可能的移动。

def possible_moves(self):
   return [str(a) for a in range(1, self.max_coins + 1)]

界定硬币的去向

def make_move(self, move):
   self.num_coins -= int(move)

界定谁拿了最后一枚硬币。

def win_game(self):
   return self.num_coins <= 0

界定什么时候停止游戏，那就是有人获胜的时候。

def is_over(self):
   return self.win()

定义如何计算得分。

def score(self):
   return 100 if self.win_game() else 0

定义这堆硬币中剩余的数量。

def show(self):
   print(self.num_coins, 'coins left in the pile')
if __name__ == "__main__":
   tt = TT()
   LastCoin_game.ttentry = lambda self: self.num_coins

Solving the game with the following code block −

r, d, m = id_solve(LastCoin_game,
   range(2, 20), win_score=100, tt=tt)
print(r, d, m)

决定谁将开始比赛

game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()

你可以找到以下输出和这个游戏的简单玩法-

d:2, a:0, m:1
d:3, a:0, m:1
d:4, a:0, m:1
d:5, a:0, m:1
d:6, a:100, m:4
1 6 4
15 coins left in the pile
Move #1: player 1 plays 4 :
11 coins left in the pile
Player 2 what do you play ? 2
Move #2: player 2 plays 2 :
9 coins left in the pile
Move #3: player 1 plays 3 :
6 coins left in the pile
Player 2 what do you play ? 1
Move #4: player 2 plays 1 :
5 coins left in the pile
Move #5: player 1 plays 4 :
1 coins left in the pile
Player 2 what do you play ? 1
Move #6: player 2 plays 1 :
0 coins left in the pile

玩打井游戏的机器人

井字游戏是人们非常熟悉的、最受欢迎的游戏之一。让我们通过使用Python中的 easyAI 库来创建这个游戏。下面的代码是这个游戏的Python代码-

如图所示，导入软件包 –

from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player

从 TwoPlayerGame 类继承该类，以处理游戏的所有操作：

class TicTacToe_game(TwoPlayersGame):
   def __init__(self, players):

现在，定义球员和将要开始游戏的球员 −

self.players = players
self.nplayer = 1

界定董事会的类型 –

self.board = [0] * 9

现在有一些特定的事情需要定义如下−

定义可能的动作

def possible_moves(self):
   return [x + 1 for x, y in enumerate(self.board) if y == 0]

定义一个球员的移动 –

def make_move(self, move):
   self.board[int(move) - 1] = self.nplayer

为了提高人工智能，定义玩家何时走棋-

def umake_move(self, move):
   self.board[int(move) - 1] = 0

界定对手有三个人在一条线上的失败条件

def condition_for_lose(self):
   possible_combinations = [[1,2,3], [4,5,6], [7,8,9],
      [1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]
   return any([all([(self.board[z-1] == self.nopponent)
      for z in combination]) for combination in possible_combinations])

为游戏的结束定义一个检查

def is_over(self):
   return (self.possible_moves() == []) or self.condition_for_lose()

显示游戏中玩家的当前位置

def show(self):
   print('\n'+'\n'.join([' '.join([['.', 'O', 'X'][self.board[3*j + i]]
      for i in range(3)]) for j in range(3)]))

计算分数。

def scoring(self):
   return -100 if self.condition_for_lose() else 0

定义主方法来定义算法并开始游戏：

if __name__ == "__main__":
   algo = Negamax(7)
   TicTacToe_game([Human_Player(), AI_Player(algo)]).play()

你可以看到下面的输出和这个游戏的简单玩法：

. . .
. . .
. . .
Player 1 what do you play ? 1
Move #1: player 1 plays 1 :
O . .
. . .
. . .
Move #2: player 2 plays 5 :
O . .
. X .
121
. . .
Player 1 what do you play ? 3
Move #3: player 1 plays 3 :
O . O
. X .
. . .
Move #4: player 2 plays 2 :
O X O
. X .
. . .
Player 1 what do you play ? 4
Move #5: player 1 plays 4 :
O X O
O X .
. . .
Move #6: player 2 plays 8 :
O X O
O X .
. X .