Python por Komputilaj Ludoj: skribu-kun-python-cxap16

fonto: http://inventwithpython.com/chapter16.html

Temoj Kovritaj dum tiu ĉapitro:

Simulaciones
Procentoj
Piedo Charts
Entjera divido
La rondaj () Funkcio

"Komputilo vs komputilo" Ludoj

La Reversi AI algoritmo estis tre simpla, sed ĝi batas min preskaŭ ĉiufoje mi ludas ĝin. Tio estas ĉar la komputilo povas procesi instrukcioj tre rapida, tiel kontrolante ĉiu ebla pozicio sur la tabulo kaj selektante la plej alta komentario movado estas facila por la komputilo. Se mi prenis la tempon por rigardi ĉiun spacon sur la tabulo kaj noti la interpunkcio de ĉiu ebla movado, necesus longa tempo por mi trovi la plej bona movado.
Ĉu vi rimarkas, ke nia Reversi programo en Ĉapitro 14 havis du funkcioj, getPlayerMove () kaj getComputerMove (), kiuj ambaŭ revenis la movado selektita kiel du-ero lerta kiel [x, y]? La ambaŭ havis ankaŭ la samaj parametroj, la tabulo datumstrukturo kaj kiu teksas trovis. GetPlayerMove () decidis ke [x, y] movi reveni por lasi la ludanto tipo en la koordinatojn. GetComputerMove () decidis ke [x, y ] movi reveni por kuri la Reversi AI algoritmo.
Kio okazas kiam ni anstataŭigi la alvoko al getPlayerMove () kun alvoko al getComputerMove ()? Tiam la ludanto neniam tipoj en movado, ĝi decidas por ili! La komputilo ludas kontraŭ si!
Ni tuj faru tri novaj programoj, ĉiu bazita sur la Reversi programo en la lasta ĉapitro. Ni faros ŝanĝojn al reversi.py krei AISim1.py. Ni tuj fari ŝanĝojn AISim1.py krei AISim2.py. Kaj fine, ni faros ŝanĝojn al AISim2.py fari AISim3.py. Vi povas aŭ tajpi tiujn ŝanĝojn en vi mem, aŭ elŝuti ilin el la libro de afiŝinto ĉe la URL http://inventwithpython.com/chapter16 .

Farante la komputila Play Kontraŭ Itself

Konservu la malnova reversi.py dosiero AISim1.py klakante sur Arkivo kaj tiam Konservu Kiel, kaj poste eniris AISim1.py por la dosiernomo kaj klakante Ok. Tio kreos kopion de nia Reversi fontkodon kiel nova dosiero kiun oni povas fari ŝanĝojn, dum lasi la originalan Reversi ludo la sama (ni volas ludi ĝin denove). Ŝanĝi la sekvan kodon en AISim1.py:

movi = getPlayerMove (mainBoard, playerTile)

Al ĉi tio (la ŝanĝo estas en bold):

movi = getComputerMove (mainBoard, playerTile)

Kaj rulu la programon. Rimarku ke la ludo ankoraŭ petas vin se vi volas esti X aŭ O, sed ne demandu al vi eniri en iu ajn movojn. Kiam ni anstataŭis getPlayerMove (), ni ne plu nomos ajna kodo kiu prenas ĉi eniro de la ludanto. Ni ankoraŭ premas Ret post la originala komputilo movoj (pro la enigo ('Gazetaraj Entajpu vidi la komputilon \' s movado. ') On line 285), sed la ludo mem ludas!
Ni faru iu alia ŝanĝojn al AISim1.py. Ĉiuj funkcioj ni difinis por Reversi povas resti la sama. Sed anstataŭigi la tutan ĉefa sekcio de la programo (linio 246 kaj plu) por simili al la sekva kodo. Kelkaj el la kodon restis, sed la plimulto de ĝi estis ŝanĝita. Sed ĉiuj la liniojn antaux linio 246 estas samaj kiel en Reversi en la lasta ĉapitro. Vi ankaŭ povas eviti tajpi en la kodo elŝutante la fonto de la URL http://inventwithpython.com/chapter16 .

AISim1.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/AISim1.py
Se vi ricevas erarojn post tajpi tiun kodon en, kompari ĝin al la libro kodo kun la linio malsamoj ilo en http://inventwithpython.com/diff aŭ retpoŝtu la aŭtoro en al@inventwithpython.com

print ('Bonvenon Reversi!')
dum Vera:
# Restarigi la estraro kaj ludo.
mainBoard = getNewBoard ()
resetBoard (mainBoard)
se whoGoesFirst () == 'ludanto':
turni = 'X'
alie:
turni = 'O'
print ('La' + siavice + 'iros unue.')
dum Vera:
drawBoard (mainBoard)
partituroj = getScoreOfBoard (mainBoard)
print ('X havas% s punktoj. ho havas% s punktoj'% (partituroj ['X'], partituroj ['O']))
input ('Gazetaraj Entajpu por daŭrigi.')
se siavice == 'X':
# X estas laŭvice.
otherTile = 'O'
x, y = getComputerMove (mainBoard, 'X')
makeMove (mainBoard, 'X', x, y)
alie:
# Ho la vico.
otherTile = 'X'
x, y = getComputerMove (mainBoard, 'ho')
makeMove (mainBoard, 'ho', x, y)
se getValidMoves (mainBoard, otherTile) == []:
rompi
alie:
turni = otherTile
# Montru la fina rezulto.
drawBoard (mainBoard)
partituroj = getScoreOfBoard (mainBoard)
print ('X notis% s punktoj. ho notis% s punktoj.'% (partituroj ['X'], partituroj ['O']))
se ne playAgain ():
sys.exit ()

Kiel la AISim1.py Kodo Verkoj

La AISim1.py programo estas la sama kiel la originalo Reversi programo, escepte ke la alvoko al getPlayerMove () estis anstataŭita per alvoko al getComputerMove (). Estis iuj aliaj ŝanĝoj al la teksto kiu estas presita en la ekrano por fari la ludon pli facile sekvi.
Kiam vi kuras la AISim1.py programo, ĉiuj povas fari estas premi Enter por ĉiu vico ĝis la ludo finas. Kuri tra kelkaj ludoj kaj rigardi la komputilo ludas mem. Pro tio ke ambaŭ la X kaj O ludantoj uzas la saman algoritmon, vere estas nur demando de sorto por vidi kiu gajnas. La ikso ludanto gajnos duonon de la tempo, kaj la O ludanto gajnos duonon de la tempo.

Farante la komputila Ludu Itself Pluraj Tempoj

Sed kion se ni kreis novan algoritmo? Tiam ni povus agordi tiu nova AI kontraŭ la implementado en getComputerMove (), kaj vidi kiu estas pli bona. Ni faras iujn ŝanĝojn al nia programo. Alklaku Arkivo kaj tiam Konservu Kiel, kaj savi ĉi tiun dosieron kiel AISim2.py tiel ke ni povos fari ŝanĝojn sen tuŝi AISim1.py. Je ĉi tiu punkto, AISim1.py kaj AISim2.py havas la saman kodon. Ni faros ŝanĝojn al AISim2.py kaj savi la dosieron tiel ke AISim2.py havas la novajn ŝanĝojn kaj AISim1.py havas la originalan kodon.
Aldoni la sekvan kodon. La aldonitaj estas en grasaj, kaj iuj linioj estis forigita. Kiam vi faras ŝanĝante la dosiero, konservi ĝin kiel AISim2.py.
Se ĉi tiu estas konfuza, vi povas ĉiam elŝuti la AISim2.py fontkodon el la libro de afiŝinto ĉe http://inventwithpython.com/chapter16 .

AISim2.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/AISim2.py
Se vi ricevas erarojn post tajpi tiun kodon en, kompari ĝin al la libro kodo kun la linio malsamoj ilo en http://inventwithpython.com/diff aŭ retpoŝtu la aŭtoro en al@inventwithpython.com

print ('Bonvenon Reversi!')
xwins = 0
owins = 0
ligojn = 0
numGames = int (input ('Tajpu numeron de ludoj kuri'))
por ludo en gamo (numGames):
print ('Ludo #% s:'% (ludo), fino = '')
# Restarigi la estraro kaj ludo.
mainBoard = getNewBoard ()
resetBoard (mainBoard)
se whoGoesFirst () == 'ludanto':
turni = 'X'
alie:
turni = 'O'
dum Vera:
se siavice == 'X':
# X estas laŭvice.
otherTile = 'O'
x, y = getComputerMove (mainBoard, 'X')
makeMove (mainBoard, 'X', x, y)
alie:
# Ho la vico.
otherTile = 'X'
x, y = getComputerMove (mainBoard, 'ho')
makeMove (mainBoard, 'ho', x, y)
se getValidMoves (mainBoard, otherTile) == []:
rompi
alie:
turni = otherTile
# Montru la fina rezulto.
partituroj = getScoreOfBoard (mainBoard)
print ('X notis% s punktoj. ho notis% s punktoj.'% (partituroj ['X'], partituroj ['O']))
se partituroj ['X']> partituroj ['O']:
xwins + = 1
elif partituroj ['X'] <partituroj ['O']:
owins + = 1
alie:
ligojn + = 1
numGames = float (numGames)
xpercent = ronda (((xwins / numGames) * 100), 2)
opercent = ronda (((owins / numGames) * 100), 2)
tiepercent = ronda (((ligojn / numGames) * 100), 2)
print ('X gajnas% s ludoj (% s%%), ho venkoj% s ludoj (% s%%), ligojn por% s ludoj (% s%%) de% s ludoj entute.'% (xwins, xpercent , owins, opercent, bantoj, tiepercent, numGames))

Kiel la AISim2.py Kodo Verkoj

Ni aldonis la variabloj xwins, owins, kaj ligojn al konservi trako de kiom da fojoj X venkoj, ho venkoj, kaj kiam ili ligas. Linioj 284 al 289 pliigo tiuj variabloj ĉe la fino de ĉiu ludo, antaŭ ol ĝi cikloj reen por komenci tute nova ludo.
Ni forigis la plejparto de la impreso () funkcio flamo de la programo, kaj la alvokoj al drawBoard (). Kiam vi kuros AISim2.py, ĝi petas vin kiom da ludoj vi volas kuri. Nun kiam ni prenis el la alvoko al drawBoard () kaj anstataŭigi la dum Vera: loop per a por ludo en gamo (numGames): loop, ni povas kuri kelkajn ludojn sen halti por la uzanto tajpas ion ajn. Jen specimeno run kie ni kuras dek ludoj de komputilo vs komputilo Reversi:

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 10
Ludo # 0: X notis 40 punktoj. Ho notis 23 punktoj.
Ludo # 1: X notis 24 punktoj. Ho notis 39 punktoj.
Ludo # 2: X notis 31 punktoj. Ho notis 30 punktoj.
Ludo # 3: X notis 41 punktoj. Ho notis 23 punktoj.
Ludo # 4: X notis 30 punktoj. Ho notis 34 punktoj.
Ludo # 5: X notis 37 punktoj. Ho notis 27 punktoj.
Ludo # 6: X notis 29 punktoj. Ho notis 33 punktoj.
Ludo # 7: X notis 31 punktoj. Ho notis 33 punktoj.
Ludo # 8: X notis 32 punktoj. Ho notis 32 punktoj.
Ludo # 9: X notis 41 punktoj. Ho notis 22 punktoj.
X gajnas 5 ludoj (50.0%), ho gajnas 4 ludoj (40.0%), ligojn por 1 ludoj (10,0%) de 10.0 ludoj entute.

Ĉar la algoritmo faras havi hazarda parto, via kuri povus ne havi la ĝusta sama nombroj kiel supre.
Presi tion al la ekrano bremsas la komputilo malsupren, sed nun ke ni forigis tiu kodo, la komputilo povas kuri tutan ludon de Reversi en ĉirkaŭ unu aŭ du. Pensu pri tio. Ĉiufoje nia programo presis el unu el tiuj linioj, ĝi kuris tra kompleta ludo (kiu estas ĉirkaŭ kvindek aŭ sesdek movas, ĉiu movado zorgeme kontrolis al esti kiu ricevas la plej punktoj).

Procentoj

Figuro 16-1: Al pie chart kun 10%,
15%, 25%, kaj 50% porcioj.

Procentoj estas parto de tuta kvanto, kaj atingo de 0% al 100%. Se vi havis 100% de kukaĵo, vi havus la tutan torto. Se vi havus 0% de kukaĵo, vi ne havus neniun kukaĵo ajn. 50% de la kukaĵo estus duono de la kukaĵo. Al kuko estas komuna bildo uzi por procentoj. Fakte, estas speco de tabulo nomata kukaĵo abako kiu montras kiom de la plena tuta certa porcio estas. Jen kukaĵo abako kun 10%, 15%, 25%, kaj 50% porciojn sube. Rimarku ke la 10% + 15% + 25% + 50% aldonas ĝis 100%.
Ni povas kalkuli la procentojn kun divido. Al preni procenton, dividi la parton vi havas por la tuta, kaj tiam multipliki per cent. Ekzemple, se X gajnis 50 el 100 ludoj, vi devus kalkuli la esprimo 50/100, kiu taksas al 0,5. Ni multipliku tion per 100 por akiri procenton (en tiu kazo, 50%). Rimarku ke se X gajnis 100 el 200 ludoj, ni povus kalkuli la procentojn kun 100/200, kiu ankaŭ taksi al 0,5. Kiam ni multigos 0,5 per 100 por akiri la procento, ni preni 50%. Gajni 100 el 200 ludoj estas la sama procento (tio estas, la saman parton) kiel gajni 50 sur 100 ludoj.

Divido Kalkulas al Glitpunktaj

Estas grave noti, ke kiam vi uzas la / divido operatoro, la esprimo ĉiam taksi al glitpunkta nombro. Ekzemple, la esprimo 10/2 taksos la glitpunktan valoron 5.0, ne por la entjera valoro 5.
Tio estas grave memori, ĉar aldono entjero al flosanta punkto valoro kun la + Krome operatoro ankaŭ ĉiam taksi al glitpunkta valoro. Ekzemple, 3 + 4.0 taksos la flosanta punkto valoro 7,0 kaj ne al la entjero 7.
Provu eniri la sekvan kodon en la interaga konko:

>>> Spamado = 100/4
>>> Spamado
25.0
>>> Spamado = spamado +20
>>> Spamado
45.0
>>>

Rimarku ke en la supra ekzemplo, la datumtipo de la valoro stokita en spamado estas ĉiam glitpunktaj valoro. Vi povas pasi la flosanta punkto valoro al la int () funkcio, kiu revenos entjero formo de la glitpunkta valoro. Sed ĉi tio ĉiam ĉirkaŭ la flosanta punkto valoro sube. Ekzemple, la esprimoj int (4.0), int (4.2), kaj int (4,9) estos ĉiuj taksi al 4, kaj neniam 5.

La rondaj () Funkcio

La rondaj () funkcio estos cxirkaux kaleŝego numero al la plej proksima tuta kaleŝego nombro. Provu eniri la sekva en la interaga konko:

>>> Rondaj (10,0)
10.0
>>> Rondaj (10,2)
10.0
>>> Rondaj (8.7)
9.0
>>> Rondaj (4.5)
5.0
>>> Rondaj (3.5)
4.0
>>> Rondaj (3.4999)
3.0
>>> Rondaj (2.5422, 2)
2.54
>>>

Kiel vi povas vidi, kiam ajn la frakcio parto de nombro estas .5 aŭ pli granda, la nombro estas rondigita supren. Alie, la nombro estas rondigita suben. La rondaj () funkcio ankaŭ havas laŭvolan parametro, kie vi povas precizigi kion lokon vi deziras ĉirkaŭ la numero. Ekzemple, la esprimo rondaj (2.5422, 2) taksas al 2,54 kaj rondaj (2.5422, 3) taksas al 2,542.

Montrante la Statistikoj

  numGames = float (numGames) 
  xpercent = ronda (((xwins / numGames) * 100), 2) 
  opercent = ronda (((owins / numGames) * 100), 2) 
  tiepercent = ronda (((ligojn / numGames) * 100), 2) 
 
 print ('X gajnas% s ludoj (% s%%), ho venkoj% s ludoj (% s%%), ligojn 
por% s ludoj (% s%%) de% s ludoj entute.'% (xwins, xpercent , owins, 
opercent, bantoj, tiepercent, numGames)) 

La kodo en la fundo de nia programo montros la uzanto, kiom da gajnas X kaj O havis, kiom da ligojn tie estis, kaj kiel kio procentoj tiuj konsistigas. Statistike, des pli ludoj vi kuros, des pli preciza vian procentoj estos. Se vi kuris nur dek ludoj, kaj X gajnis tri el ili, tiam ŝajnus ke X algoritmo nur gajnas 30% de la tempo. Tamen, se vi kuri cent, aŭ eĉ mil ludoj, vi povas trovi ke X algoritmo gajnas pli proksima al 50% (tio estas, duono) de la ludoj.
Por trovi la procentoj, ni dividas la nombron de venkoj aŭ ligojn por la tuta nombro de ludoj. Ni konverti numGames al kaleŝego por certigi ni ne uzas entjera divido en nia kalkulo. Tiam ni multipliki la rezulto per 100. Tamen, ni povas fini kun nombro kiel 66.66666666666667. Do ni pasas ĉi nombro al la ronda () funkcio kun la dua parametro de 2 por limigi la precizeco al du decimalaj, do revenos kaleŝego kiel 66,67 anstataŭe (kiu estas multe pli legebla).
Ni provu alian eksperimenton. Kuru AISim2.py denove, sed ĉi-foje ili ĝin kuri cent ludoj:

Specimeno Run de AISim2.py

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 42 punktoj. Ho notis 18 punktoj.
Ludo # 1: X notis 26 punktoj. Ho notis 37 punktoj.
Ludo # 2: X notis 34 punktoj. Ho notis 29 punktoj.
Ludo # 3: X notis 40 punktoj. Ho notis 24 punktoj.

... Saltis por mallongeco ...

Ludo # 96: X notis 22 punktoj. Ho notis 39 punktoj.
Ludo # 97: X notis 38 punktoj. Ho notis 26 punktoj.
Ludo # 98: X notis 35 punktoj. Ho notis 28 punktoj.
Ludo # 99: X notis 24 punktoj. Ho notis 40 punktoj.
X gajnas 46 ludoj (46.0%), ho gajnas 52 ludoj (52.0%), ligojn por 2 ludoj (2.0%) de 100,0 ludoj entute.

Depende kiel rapide via komputilo estas, ĉi kuri povus esti prenita pri kelkaj minutoj. Ni povas vidi ke la rezultoj de ĉiuj cent ludoj ankoraŭ evens al ĉirkaŭ kvindek-kvindek, ĉar ambaŭ X kaj O uzas la saman algoritmon por gajni.

Komparante Malsamaj AI Algoritmoj

Ni aldonu kelkajn novajn funkciojn kun novaj algoritmoj. Sed unue alklaku Dosieraj, tiam Konservu Kiel, kaj savi ĉi tiun dosieron kiel AISim3.py. Antaŭ la impreso ('Bonvenon Reversi!') Linio, aldoni tiujn funkciojn:

AISim3.py
Tiu kodo estas elŝutebla el http://inventwithpython.com/AISim3.py
Se vi ricevas erarojn post tajpi tiun kodon en, kompari ĝin al la libro kodo kun la linio malsamoj ilo en http://inventwithpython.com/diff aŭ retpoŝtu la aŭtoro en al@inventwithpython.com

def getRandomMove (tabulo, kahelo):
# Reveno hazarda movado.
revenu random.choice (getValidMoves (tabulo, kahelo))
def isOnSide (x, y):
reveno x == 0 aŭ x == 7 aŭ y == 0 aŭ y == 7
def getCornerSideBestMove (tabulo, kahelo):
# Reveno angulo movado, aŭ flanka movado, aŭ la pli bona movado.
possibleMoves = getValidMoves (tabulo, kahelo)
# Randomize la ordo de la ebla movas
random.shuffle (possibleMoves)
# Ĉiam iras por angulo se haveblaj.
por x, y en possibleMoves:
se isOnCorner (x, y):
revenu [x, y]
# Se ne estas angulo, resendas flanko movado.
por x, y en possibleMoves:
se isOnSide (x, y):
revenu [x, y]
reveno getComputerMove (tabulo, kahelo)
def getSideBestMove (tabulo, kahelo):
# Reveno angulo movado, aŭ flanka movado, aŭ la pli bona movado.
possibleMoves = getValidMoves (tabulo, kahelo)
# Randomize la ordo de la ebla movas
random.shuffle (possibleMoves)
# Resendas flanko movado, se disponebla
por x, y en possibleMoves:
se isOnSide (x, y):
revenu [x, y]
reveno getComputerMove (tabulo, kahelo)
def getWorstMove (tabulo, kahelo):
# Reveno la movado kiu klakas la malplej kvanto de kaheloj.
possibleMoves = getValidMoves (tabulo, kahelo)
# Randomize la ordo de la ebla movas
random.shuffle (possibleMoves)
# Iru tra la tuta ebla movas kaj memori la plej bona komentario movado
worstScore = 64
por x, y en possibleMoves:
dupeBoard = getBoardCopy (tabulo)
makeMove (dupeBoard, kahelo, x, y)
partituron = getScoreOfBoard (dupeBoard) [kahelo]
se partituro <worstScore:
worstMove = [x, y]
worstScore = partituro
revenu worstMove
def getCornerWorstMove (tabulo, kahelo):
# Reveno angulo, spaco, aŭ la movado kiu klakas la malplej kvanto de kaheloj.
possibleMoves = getValidMoves (tabulo, kahelo)
# Randomize la ordo de la ebla movas
random.shuffle (possibleMoves)
# Ĉiam iras por angulo se haveblaj.
por x, y en possibleMoves:
se isOnCorner (x, y):
revenu [x, y]
revenu getWorstMove (tabulo, kahelo)
print ('Bonvenon Reversi!')

Kiel la AISim3.py Kodo Verkoj

Multaj el ĉi tiuj funkcioj estas tre simila unu al la alia, kaj iuj el ili uzas la novan isOnSide () funkcio. Jen recenzo de la nova algoritmoj ni faris:

Tabelo 17-1: Funkcioj uzata por nia Reversi AI.
Funkcio	Priskribo
getRandomMove ()	Hazarde elekti validan movon fari.
getCornerSideBestMove ()	Prenu angulo movado se haveblaj. Se ne estas angulo, preni spacon sur la flanko. Se neniu flankoj estas havebla, uzu la regula getComputerMove () algoritmo.
getSideBestMove ()	Prenu flanko spaco se ekzistas unu disponebla. Se ne, tiam uzu la regula getComputerMove () algoritmo (flanko spacoj estas elektitaj antauxe angulo spacoj).
getWorstMove ()	Prenu la spaco kiu rezultos en la malplej azuleĥoj esti spegulita.
getCornerWorstMove ()	Prenu angulo spaco, se haveblaj. Se ne, uzu la getWorstMove () algoritmo.

Komparante la Hazarda Algoritmo Kontraŭ la Regulaj Algoritmo

Nun la sola afero por fari estas anstataŭi unu el la getComputerMove () nomas en la ĉefa parto de la programo kun unu el la novaj funkcioj. Tiam ni povas ruli plurajn ludojn kaj vidi kiel ofte unu algoritmo gajnas super la alia. Unue, ni anstataŭigi ho algoritmo kun tiu en getComputerMove () kun getRandomMove () on line 351:

x, y = getRandomMove (mainBoard, 'ho')

Kiam ni kuras la programon kun cento ludoj nun, povas rigardi ion kiel jene:

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 25 punktoj. Ho notis 38 punktoj.
Ludo # 1: X notis 32 punktoj. Ho notis 32 punktoj.
Ludo # 2: X notis 15 punktoj. Ho notis 0 punktoj.
Ludo # 3: X notis 50 punktoj. Ho notis 14 punktoj.

... Saltis por mallongeco ...

Ludo # 96: X notis 31 punktoj. Ho notis 33 punktoj.
Ludo # 97: X notis 41 punktoj. Ho notis 23 punktoj.
Ludo # 98: X notis 33 punktoj. Ho notis 31 punktoj.
Ludo # 99: X notis 45 punktoj. Ho notis 19 punktoj.
X gajnas 84 ludoj (84.0%), ho gajnas 15 ludoj (15.0%), ligojn por 1 ludojn (1.0%) de 100,0 ludoj entute.

Wow! X gajni multe pli ofte ol ho faris. Tio signifas ke la algoritmo en getComputerMove () (preni ajnan disponebla anguloj, alie preni la spaco kiu klakas la plej azuleĥoj) gajnas pli da ludoj ol la algoritmo en getRandomMove () (kiu nur faras movojn hazarde). Tiu makes sense, ĉar farante inteligenta elekto estas kutime tuj estos pli bona ol nur elektante aferojn al la hazardo.

Komparante la Hazarda Algoritmo Kontraŭ Itself

Kio se ni ŝanĝis ho algoritmo uzi ankaŭ la algoritmo en getRandomMove ()? Ni trovu ekster ŝanĝante ho funkcio alvoko on line 351 el getComputerMove () por getRandomMove () kaj kuri la programon denove.

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 37 punktoj. Ho notis 24 punktoj.
Ludo # 1: X notis 19 punktoj. Ho notis 45 punktoj.

... Saltis por mallongeco ...

Ludo # 98: X notis 27 punktoj. Ho notis 37 punktoj.
Ludo # 99: X notis 38 punktoj. Ho notis 22 punktoj.
X gajnas 42 ludoj (42,0%), ho gajnas 54 ludoj (54.0%), ligojn por 4 ludoj (4.0%) de 100,0 ludoj entute.

Kiel vi povas vidi, kiam ambaŭ ludantoj faras hazarda movas, ili ĉiu venko ĉirkaŭ 50% de la tempo. (En la supra kazo, ho nur okazi akiri bonŝanca kaj gajnis iom pli ol duono de la tempo.)
Samkiel movante en la angulo spacoj estas bona ideo ĉar oni ne povas spegulita, movante flanke pecoj povas ankaŭ esti bona ideo. Sur la flanko, la kahelo havas la randon de la tabulo kaj ne estas tiel malkaŝe kiel la aliaj pecoj. La anguloj estas ankoraŭ preferinda al la flanko spacoj, sed movanta sur la flankoj (eĉ kiam estas movado kiu povas klaki pli pecojn) povas esti bona strategio.

Komparante la Regulaj Algoritmo Kontraŭ la CornersSideBest Algoritmo

Ŝanĝi X algoritmo on line 346 uzi getComputerMove () (nia originala algoritmo) kaj O algoritmo on line 351 uzi getCornerSideBestMove () (kiu unue provas movi sur angulo, tiam provas movi sur flanko pozicio, kaj tiam prenas la bona cetera movado), kaj ni kuris cent ludoj vidi kiu estas pli bona. Provu ŝanĝi la funkcio nomitaj kaj kuri la programon denove.

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 52 punktoj. Ho notis 12 punktoj.
Ludo # 1: X notis 10 punktoj. Ho notis 54 punktoj.

... Saltis por mallongeco ...

Ludo # 98: X notis 41 punktoj. Ho notis 23 punktoj.
Ludo # 99: X notis 46 punktoj. Ho notis 13 punktoj.
X gajnas 65 ludoj (65.0%), ho gajnas 31 ludoj (31.0%), ligojn por 4 ludoj (4.0%) de 100,0 ludoj entute.

Wow! Tio estas neatendita. Ŝajnas ke elektante la flanko spacoj super spaco kiu klakas pli kaheloj estas malbona strategio por uzi. La profito de la flanko spaco ne estas pli granda ol la kosto de elekti spaco kiu klakas malpli de la kontraŭulo kaheloj. Ĉu ni povas esti certaj de tiuj rezultoj? Ni kuras la programon denove, sed ĉi-foje ni havas la programon ludi mil ludoj. Ĉi tio povas preni kelkajn minutojn por via komputilo kuri (sed necesus tagoj por vi fari tion mane!) Provu ŝanĝi la funkcio nomitaj kaj kuri la programon denove.

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 1000
Ludo # 0: X notis 20 punktoj. Ho notis 44 punktoj.
Ludo # 1: X notis 54 punktoj. Ho notis 9 punktoj.

... Saltis por mallongeco ...

Ludo # 998: X notis 38 punktoj. Ho notis 23 punktoj.
Ludo # 999: X notis 38 punktoj. Ho notis 26 punktoj.
X gajnas 611 ludoj (61.1%), ho gajnas 363 ludoj (36,3%), ligojn por 26 ludoj (2,6%) de 1000,0 ludoj entute.

Ju pli precizaj statistikoj de la mil-ludoj run estas ĉirkaŭ la sama kiel la statistiko de la cent-ludoj run. Ŝajnas ke elektante la movado kiu klakas la plej kaheloj estas bona ideo ol elektante flanko movado.

Komparante la Regulaj Algoritmo Kontraŭ la plej malbona algoritmo

Direktu do nun la X ludanto algoritmo on line 346 uzi getComputerMove () kaj la O ludanto algoritmo on line 351 al getWorstMove () (kiu faras la movado kiu klakas sur la malplej kvanto de kaheloj), kaj kuri cent ludoj. Provu ŝanĝi la funkcio nomitaj kaj kuri la programon denove.

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 50 punktoj. Ho notis 14 punktoj.
Ludo # 1: X notis 38 punktoj. Ho notis 8 punktoj.

... Saltis por mallongeco ...

Ludo # 98: X notis 36 punktoj. Ho notis 16 punktoj.
Ludo # 99: X notis 19 punktoj. Ho notis 0 punktoj.
X gajnas 98 ludoj (98.0%), ho gajnas 2 ludoj (2.0%), ligojn por 0 ludoj (0.0%) de 100,0 ludoj entute.

Halt! La algoritmo en getWorstMove (), kiu ĉiam elekti la movado kiu klakas la malplej kaheloj, ili preskaŭ ĉiam perdas nian regula algoritmo. Tio ne estas vere mirinda ajn.

Komparante la Regulaj Algoritmo Kontraŭ la WorstCorner Algoritmo

Kion pri kiam ni anstataŭigi getWorstMove () on line 351 kun getCornerWorstMove (), kiu estas la sama algoritmo se gxi prenas neniun disponebla angulo pecoj antaŭ preni la plej malbona movado. Provu ŝanĝi la funkcio nomitaj kaj kuri la programon denove.

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 36 punktoj. Ho notis 7 punktoj.
Ludo # 1: X notis 44 punktoj. Ho notis 19 punktoj.

... Saltis por mallongeco ...

Ludo # 98: X notis 47 punktoj. Ho notis 17 punktoj.
Ludo # 99: X notis 36 punktoj. Ho notis 18 punktoj.
X gajnas 94 ludoj (94.0%), ho gajnas 6 ludoj (6,0%), ligojn por 0 ludoj (0.0%) de 100,0 ludoj entute.

La getCornerWorstMove () ankoraŭ perdas la plejparto de la ludoj, sed ŝajnas gajni kelkajn pli ludoj ol getWorstMove () (6% kompare al 2%). Ĉu prenante la angulo spacoj, kiam ili estas disponeblaj vere fari diferencon?

Komparante la plej malbona algoritmo Kontraŭ la WorstCorner Algoritmo

Ni povas kontroli per opcio X algoritmo al getWorstMove () kaj O algoritmo al getCornerWorstMove (), kaj poste kurante la programo. Provu ŝanĝi la funkcio nomitaj kaj kuri la programon denove.

Bonvenon Reversi!
Entajpu numeron de ludoj kuri: 100
Ludo # 0: X notis 25 punktoj. Ho notis 39 punktoj.
Ludo # 1: X notis 26 punktoj. Ho notis 33 punktoj.

... Saltis por mallongeco ...

Ludo # 98: X notis 36 punktoj. Ho notis 25 punktoj.
Ludo # 99: X notis 29 punktoj. Ho notis 35 punktoj.
X gajnas 32 ludoj (32.0%), ho gajnas 67 ludoj (67.0%), ligojn por 1 ludojn (1.0%) de 100,0 ludoj entute.

Jes, ĝi ŝajnas kiel preni la algoritmo kiu prenas la anguloj kiam povas faras traduki al pli gajnas. Dum ni trovis, ke tuj por la flankoj faras vi perdas pli ofte, irante en la anguloj estas ĉiam bona ideo.

Resumo: Lernado Nov Aĵoj de Kura Simulation Eksperimentoj

Ĉi tiu ĉapitro ne vere kovras ludo, sed modelita diversaj strategioj por Reversi. Se ni pensis ke prenante flanko movas en Reversi estis bona ideo, ni devus elspezi tagojn, eĉ semajnoj, zorgeme ludoj de Reversi mane kaj notante la rezultojn. Sed se ni scias, kiel plani komputilo por ludi Reversi, tiam ni povas havi la komputilon ludi Reversi uzante tiujn strategioj por ni. Se vi pensas pri tio, vi rimarkos ke la komputilo ekzekuti milionojn da linioj de niaj Python programo en duaj! Via eksperimentoj kun la simulado de Reversi povas helpi vin lerni pli pri ludi Reversi en reala vivo.
Fakte, ĉi tiu ĉapitro farus bonan sciencon justa projekto. Via problemo povas esti ke aro de movadoj kondukas al la plej venkoj kontraŭ aliaj aroj de movadoj, kaj fari hipotezon pri kiu estas la plej bona strategio. Post kuri pluraj simulaciones, vi povas difini, kiu strategio funkcias plej bone. Vi povas fari scienco justa projekto el simulado de ajna estraro ludon! Tio estas nur ĉar vi scias ĝuste kiel instrui la komputilon por fari ĝin, paŝo post paŝo, linio por linio. Vi povas paroli la komputilo lingvo, kaj akiri ĝin fari grandajn kvantojn de datumo prilaborado kaj nombro disigan por vi.
Tio estas ĉio por la teksto-bazita ludoj de ĉi tiu libro. Ludoj ke nur uzo teksto povas esti amuza, kvankam tie simpla. Sed plej modernaj ludoj uzas grafikaĵojn, aŭdaĵoj kaj kuraĝigon por fari multe pli ekscita serĉis ludoj. Por la resto de la ĉapitroj en ĉi tiu libro, ni lernos kiel krei ludoj kun grafikaĵoj uzante Python modulo nomata Pygame.

Python por Komputilaj Ludoj

Páginas

domingo, 3 de março de 2013

skribu-kun-python-cxap16