AI กับ Python - เกม

มีการเล่นเกมด้วยกลยุทธ์ ผู้เล่นหรือทีมทุกคนจะต้องวางกลยุทธ์ก่อนเริ่มเกมและพวกเขาต้องเปลี่ยนหรือสร้างกลยุทธ์ใหม่ตามสถานการณ์ปัจจุบันในเกม

อัลกอริทึมการค้นหา

คุณจะต้องพิจารณาเกมคอมพิวเตอร์ด้วยกลยุทธ์เดียวกันกับข้างต้น โปรดทราบว่าอัลกอริทึมการค้นหาเป็นสิ่งที่กำหนดกลยุทธ์ในเกมคอมพิวเตอร์

มันทำงานอย่างไร

เป้าหมายของอัลกอริทึมการค้นหาคือการค้นหาชุดการเคลื่อนไหวที่เหมาะสมที่สุดเพื่อให้พวกเขาไปถึงจุดหมายสุดท้ายและชนะ อัลกอริทึมเหล่านี้ใช้ชุดเงื่อนไขที่ชนะซึ่งแตกต่างกันไปในทุกเกมเพื่อค้นหาการเคลื่อนไหวที่ดีที่สุด

เห็นภาพเกมคอมพิวเตอร์เป็นต้นไม้ เรารู้ว่าต้นไม้มีโหนด เริ่มจากรูทเราสามารถมาที่โหนดสุดท้ายที่ชนะ แต่ด้วยการเคลื่อนไหวที่เหมาะสมที่สุด นั่นคือการทำงานของอัลกอริทึมการค้นหา ทุกโหนดในทรีดังกล่าวแสดงถึงสถานะในอนาคต อัลกอริทึมการค้นหาจะค้นหาผ่านโครงสร้างนี้เพื่อทำการตัดสินใจในแต่ละขั้นตอนหรือโหนดของเกม

การค้นหาแบบผสมผสาน

ข้อเสียที่สำคัญของการใช้อัลกอริทึมการค้นหาคือมีลักษณะที่ละเอียดถี่ถ้วนซึ่งเป็นสาเหตุที่ทำให้พวกเขาสำรวจพื้นที่ค้นหาทั้งหมดเพื่อค้นหาวิธีแก้ปัญหาที่นำไปสู่การสูญเสียทรัพยากร มันจะยุ่งยากกว่านี้หากอัลกอริทึมเหล่านี้จำเป็นต้องค้นหาพื้นที่การค้นหาทั้งหมดเพื่อค้นหาโซลูชันสุดท้าย

เพื่อขจัดปัญหาดังกล่าวเราสามารถใช้การค้นหาแบบผสมผสานซึ่งใช้ฮิวริสติกเพื่อสำรวจพื้นที่การค้นหาและลดขนาดโดยกำจัดการเคลื่อนไหวที่ผิดพลาดที่อาจเกิดขึ้นได้ ดังนั้นอัลกอริทึมดังกล่าวสามารถประหยัดทรัพยากรได้ อัลกอริทึมบางอย่างที่ใช้ฮิวริสติกเพื่อค้นหาพื้นที่และบันทึกทรัพยากรจะกล่าวถึงที่นี่ -

Minimax Algorithm

เป็นกลยุทธ์ที่ใช้ในการค้นหาแบบผสมผสานที่ใช้ฮิวริสติกเพื่อเร่งกลยุทธ์การค้นหา แนวคิดของกลยุทธ์ Minimax สามารถเข้าใจได้ด้วยตัวอย่างของเกมผู้เล่นสองคนซึ่งผู้เล่นแต่ละคนพยายามที่จะคาดเดาการเคลื่อนไหวครั้งต่อไปของฝ่ายตรงข้ามและพยายามลดฟังก์ชันนั้นให้น้อยที่สุด นอกจากนี้เพื่อที่จะชนะผู้เล่นจะพยายามเพิ่มฟังก์ชันของตัวเองให้สูงสุดตามสถานการณ์ปัจจุบันเสมอ

ฮิวริสติกมีบทบาทสำคัญในกลยุทธ์ประเภทนี้เช่น Minimax ทุกโหนดของต้นไม้จะมีฟังก์ชันฮิวริสติกที่เกี่ยวข้อง ตามฮิวริสติกนั้นจะใช้เวลาในการตัดสินใจที่จะย้ายไปยังโหนดที่จะเป็นประโยชน์ต่อพวกเขามากที่สุด

การตัดแต่งอัลฟ่า - เบต้า

ปัญหาหลักของขั้นตอนวิธี Minimax คือสามารถสำรวจส่วนต่างๆของต้นไม้ที่ไม่เกี่ยวข้องซึ่งนำไปสู่การสูญเสียทรัพยากร ดังนั้นจึงต้องมีกลยุทธ์ในการตัดสินใจว่าส่วนใดของต้นไม้มีความเกี่ยวข้องและส่วนใดไม่เกี่ยวข้องและปล่อยให้ส่วนที่ไม่เกี่ยวข้องไม่ได้สำรวจ การตัดแต่งอัลฟ่า - เบต้าเป็นกลยุทธ์ประเภทหนึ่ง

เป้าหมายหลักของอัลกอริธึมการตัดแต่งอัลฟ่า - เบต้าคือการหลีกเลี่ยงการค้นหาส่วนต่างๆของต้นไม้ที่ไม่มีวิธีแก้ปัญหาใด ๆ แนวคิดหลักของการตัดแต่งกิ่งอัลฟ่า - เบต้าคือการใช้ขอบเขตสองชื่อAlphaขอบเขตล่างสูงสุดและ Betaขอบเขตบนขั้นต่ำ พารามิเตอร์ทั้งสองนี้เป็นค่าที่ จำกัด ชุดของโซลูชันที่เป็นไปได้ จะเปรียบเทียบค่าของโหนดปัจจุบันกับค่าของพารามิเตอร์อัลฟาและเบต้าเพื่อให้สามารถย้ายไปยังส่วนของต้นไม้ที่มีโซลูชันและทิ้งส่วนที่เหลือ

อัลกอริทึม Negamax

อัลกอริทึมนี้ไม่แตกต่างจากขั้นตอนวิธี Minimax แต่มีการนำไปใช้งานที่สง่างามกว่า ข้อเสียเปรียบหลักของการใช้ขั้นตอนวิธี Minimax คือเราจำเป็นต้องกำหนดฟังก์ชันฮิวริสติกสองฟังก์ชันที่แตกต่างกัน ความเชื่อมโยงระหว่างฮิวริสติกเหล่านี้คือยิ่งสถานะของเกมดีขึ้นสำหรับผู้เล่นคนหนึ่งผู้เล่นคนอื่นก็ยิ่งแย่ลงเท่านั้น ในอัลกอริทึม Negamax การทำงานแบบเดียวกันของฟังก์ชันฮิวริสติกสองฟังก์ชันทำได้โดยใช้ฟังก์ชันฮิวริสติกเพียงฟังก์ชันเดียว

การสร้างบอทเพื่อเล่นเกม

สำหรับการสร้างบอทเพื่อเล่นเกมผู้เล่นสองคนใน AI เราจำเป็นต้องติดตั้งไฟล์ easyAIห้องสมุด. เป็นกรอบปัญญาประดิษฐ์ที่ให้ฟังก์ชันทั้งหมดในการสร้างเกมที่มีผู้เล่นสองคน คุณสามารถดาวน์โหลดได้ด้วยความช่วยเหลือของคำสั่งต่อไปนี้ -

pip install easyAI

บอทเพื่อเล่นเหรียญยืนสุดท้าย

ในเกมนี้จะมีกองเหรียญ ผู้เล่นแต่ละคนจะต้องใช้เหรียญจำนวนหนึ่งจากกองนั้น เป้าหมายของเกมคือหลีกเลี่ยงการรับเหรียญสุดท้ายในกอง เราจะใช้คลาสLastCoinStanding สืบทอดมาจาก TwoPlayersGame คลาสของ easyAIห้องสมุด. รหัสต่อไปนี้แสดงรหัส 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

การแก้เกมด้วยการบล็อกรหัสต่อไปนี้ -

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

บอทเพื่อเล่น Tic Tac Toe

Tic-Tac-Toe เป็นเกมที่คุ้นเคยและเป็นที่นิยมมากที่สุดเกมหนึ่ง ให้เราสร้างเกมนี้โดยใช้ไฟล์easyAIไลบรารีใน Python รหัสต่อไปนี้คือรหัส 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

ในการเพิ่ม AI ให้กำหนดเวลาที่ผู้เล่นทำการเคลื่อนไหว -

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 .