KI mit Python - Gaming

Spiele werden mit einer Strategie gespielt. Jeder Spieler oder jedes Team würde vor Spielbeginn eine Strategie entwickeln und muss die Strategie entsprechend der aktuellen Situation (en) im Spiel ändern oder neu entwickeln.

Suchalgorithmen

Sie müssen Computerspiele auch mit der gleichen Strategie wie oben betrachten. Beachten Sie, dass Suchalgorithmen diejenigen sind, die die Strategie in Computerspielen herausfinden.

Wie es funktioniert

Das Ziel von Suchalgorithmen ist es, den optimalen Satz von Zügen zu finden, damit sie das endgültige Ziel erreichen und gewinnen können. Diese Algorithmen verwenden die für jedes Spiel unterschiedlichen Gewinnbedingungen, um die besten Züge zu finden.

Visualisieren Sie ein Computerspiel als Baum. Wir wissen, dass der Baum Knoten hat. Ausgehend von der Wurzel können wir zum endgültigen Gewinnknoten kommen, aber mit optimalen Zügen. Das ist die Arbeit von Suchalgorithmen. Jeder Knoten in einem solchen Baum repräsentiert einen zukünftigen Zustand. Die Suchalgorithmen durchsuchen diesen Baum, um bei jedem Schritt oder Knoten des Spiels Entscheidungen zu treffen.

Kombinierte Suche

Der Hauptnachteil der Verwendung von Suchalgorithmen besteht darin, dass sie erschöpfender Natur sind, weshalb sie den gesamten Suchraum durchsuchen, um die Lösung zu finden, die zur Verschwendung von Ressourcen führt. Es wäre umständlicher, wenn diese Algorithmen den gesamten Suchraum durchsuchen müssten, um die endgültige Lösung zu finden.

Um solche Probleme zu beseitigen, können wir eine kombinatorische Suche verwenden, bei der die Heuristik verwendet wird, um den Suchraum zu erkunden und seine Größe zu verringern, indem mögliche falsche Bewegungen beseitigt werden. Daher können solche Algorithmen die Ressourcen sparen. Einige der Algorithmen, die Heuristik verwenden, um den Speicherplatz zu durchsuchen und Ressourcen zu sparen, werden hier erläutert.

Minimax-Algorithmus

Es ist die Strategie der kombinatorischen Suche, die Heuristik verwendet, um die Suchstrategie zu beschleunigen. Das Konzept der Minimax-Strategie kann am Beispiel von Zwei-Spieler-Spielen verstanden werden, bei denen jeder Spieler versucht, den nächsten Zug des Gegners vorherzusagen und diese Funktion zu minimieren. Um zu gewinnen, versucht der Spieler immer, seine eigene Funktion basierend auf der aktuellen Situation zu maximieren.

Heuristik spielt eine wichtige Rolle bei solchen Strategien wie Minimax. Jedem Knoten des Baums wäre eine heuristische Funktion zugeordnet. Basierend auf dieser Heuristik wird die Entscheidung getroffen, einen Schritt in Richtung des Knotens zu machen, von dem sie am meisten profitieren würden.

Alpha-Beta-Schnitt

Ein Hauptproblem des Minimax-Algorithmus besteht darin, dass er die irrelevanten Teile des Baums untersuchen kann, was zur Verschwendung von Ressourcen führt. Daher muss es eine Strategie geben, um zu entscheiden, welcher Teil des Baums relevant und welcher irrelevant ist, und den irrelevanten Teil unerforscht zu lassen. Alpha-Beta-Beschneiden ist eine solche Strategie.

Das Hauptziel des Alpha-Beta-Bereinigungsalgorithmus besteht darin, zu vermeiden, dass diejenigen Teile des Baums durchsucht werden, für die es keine Lösung gibt. Das Hauptkonzept des Alpha-Beta-Beschneidens besteht darin, zwei benannte Grenzen zu verwendenAlpha, die maximale Untergrenze und Beta, die minimale Obergrenze. Diese beiden Parameter sind die Werte, die den Satz möglicher Lösungen einschränken. Es vergleicht den Wert des aktuellen Knotens mit dem Wert der Alpha- und Beta-Parameter, sodass er zu dem Teil des Baums wechseln kann, der die Lösung enthält, und den Rest verwerfen kann.

Negamax-Algorithmus

Dieser Algorithmus unterscheidet sich nicht vom Minimax-Algorithmus, hat jedoch eine elegantere Implementierung. Der Hauptnachteil der Verwendung des Minimax-Algorithmus besteht darin, dass zwei verschiedene heuristische Funktionen definiert werden müssen. Der Zusammenhang zwischen diesen Heuristiken besteht darin, dass je besser ein Spielzustand für einen Spieler ist, desto schlechter ist er für den anderen Spieler. Im Negamax-Algorithmus wird dieselbe Arbeit von zwei heuristischen Funktionen mit Hilfe einer einzelnen heuristischen Funktion ausgeführt.

Bots bauen, um Spiele zu spielen

Um Bots zu bauen, um Zwei-Spieler-Spiele in AI zu spielen, müssen wir das installieren easyAIBibliothek. Es ist ein Framework für künstliche Intelligenz, das alle Funktionen zum Erstellen von Spielen für zwei Spieler bietet. Sie können es mit Hilfe des folgenden Befehls herunterladen:

pip install easyAI

Ein Bot zum Spielen der letzten stehenden Münze

In diesem Spiel würde es einen Stapel Münzen geben. Jeder Spieler muss eine Reihe von Münzen von diesem Stapel nehmen. Das Ziel des Spiels ist es zu vermeiden, die letzte Münze auf dem Stapel zu nehmen. Wir werden die Klasse benutzenLastCoinStanding geerbt von der TwoPlayersGame Klasse der easyAIBibliothek. Der folgende Code zeigt den Python-Code für dieses Spiel -

Importieren Sie die erforderlichen Pakete wie gezeigt -

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

Erben Sie nun die Klasse von der TwoPlayerGame Klasse für alle Operationen des Spiels -

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

Definieren Sie nun die Spieler und den Spieler, der das Spiel starten soll.

self.players = players
self.nplayer = 1

Definieren Sie nun die Anzahl der Münzen im Spiel. Hier verwenden wir 15 Münzen für das Spiel.

self.num_coins = 15

Definieren Sie die maximale Anzahl von Münzen, die ein Spieler in einem Zug nehmen kann.

self.max_coins = 4

Nun müssen einige bestimmte Dinge definiert werden, wie im folgenden Code gezeigt. Definieren Sie mögliche Bewegungen.

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

Definieren Sie das Entfernen der Münzen

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

Definieren Sie, wer die letzte Münze genommen hat.

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

Definieren Sie, wann das Spiel beendet werden soll, dh wann jemand gewinnt.

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

Definieren Sie, wie die Punktzahl berechnet wird.

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

Definieren Sie die Anzahl der verbleibenden Münzen auf dem Stapel.

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

Lösen Sie das Spiel mit dem folgenden Codeblock -

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

Entscheiden, wer das Spiel starten soll

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

Sie finden die folgende Ausgabe und ein einfaches Spiel dieses Spiels -

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

Ein Bot zum Spielen von Tic Tac Toe

Tic-Tac-Toe ist sehr bekannt und eines der beliebtesten Spiele. Lassen Sie uns dieses Spiel mit dem erstelleneasyAIBibliothek in Python. Der folgende Code ist der Python-Code dieses Spiels -

Importieren Sie die Pakete wie gezeigt -

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

Erben Sie die Klasse von der TwoPlayerGame Klasse für alle Operationen des Spiels -

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

Definieren Sie nun die Spieler und den Spieler, der das Spiel starten wird -

self.players = players
self.nplayer = 1

Definieren Sie den Board-Typ -

self.board = [0] * 9

Nun gibt es einige bestimmte Dinge, die wie folgt definiert werden müssen:

Definieren Sie mögliche Bewegungen

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

Definieren Sie den Zug eines Spielers -

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

Um die KI zu verbessern, definieren Sie, wann ein Spieler einen Zug macht -

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

Definieren Sie die Verlustbedingung, dass ein Gegner drei in einer Linie hat

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])

Definieren Sie einen Check für das Ende des Spiels

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

Zeigen Sie die aktuelle Position der Spieler im Spiel an

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)]))

Berechnen Sie die Ergebnisse.

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

Definieren Sie die Hauptmethode, um den Algorithmus zu definieren und das Spiel zu starten -

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

Sie können die folgende Ausgabe und ein einfaches Spiel dieses Spiels sehen -

. . .
. . .
. . .
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 .