Nel 2018, Google ha battuto il campione di GO con la sua Rete Neurale AlphaGo, e c'è stato così tanto clamore. Nuove eccellenti librerie open source di Machine Learning sono diventate disponibili, utilizzando GPU domestiche per velocizzare il processo di addestramento.
Ho preso la decisione di provare a farlo con Abak, ma quando ho iniziato, sapevo a malapena cosa fosse una rete neurale. Avevo avuto una piccola tentazione all'università (1996), ma mancando dati, una GPU e un obiettivo, era complesso da affrontare. Inoltre: dal punto di vista matematico, le Reti Neurali sono un argomento pesante, e hai bisogno di molta ispirazione.
Dopo molta ricerca intensa e ossessiva, sono riuscito a costruire un modello e farlo imparare.
Sulle spalle dei giganti, il mio primo intento è stato imparare dal Dr. Gerald Tesauro, che ha sviluppato TD-Gammon negli anni '90. Se ricordo bene, questa è stata la prima implementazione pratica di un algoritmo di apprendimento per rinforzo.
Ma poiché Abak è un gioco bidimensionale, non potevo usare il modello proposto e ho dovuto sviluppare il mio. Ho deciso di usare l'output di alcuni degli algoritmi come parte del modello, come informazione esperta, così la NN avrebbe avuto il processo di apprendimento più facile. Mi sentivo come se stessi barando facendo così.
Ecco un confronto tra entrambi i modelli, quello del Backgammon e quello di Abak.
Il modello TD ampiamente utilizzato nel Backgammon descrive le colonne. Per ogni colonna del tavoliere, vengono usati 4 input per descriverla.
- Nessuna pedina: [0,0,0,0]
- Una pedina: [1,0,0,0]
- Due pedine: [1,1,0,0],
- Tre pedine: [1,1,1,0]
- Più di tre pedine: [1,1,1,1].
Ha 28 di questi set (uno per colonna del tavoliere) per riferirsi a ogni squadra, quindi 28*2*4 input in totale, più alcuni per contare le pedine sulla barra. Purtroppo, sto scrivendo a memoria, che potrebbe non essere accurata.
Il modello di Abak è molto diverso. Descrive le pedine, e ciascuna ha un set di caratteristiche. Nelle versioni più recenti, ho aggiunto una descrizione semplificata del tavoliere come complemento, con risultati che non erano incredibili, ma le caratteristiche sono ancora presenti.
Il modello di descrizione del gioco ha quattro parti [477 input]:
- Descrizione delle Pedine (14x30): La descrizione include statistiche per la pedina, distanza, altezza, ecc. Non include la classe, che è ereditata dalla sua posizione nel modello.
- Stato della Squadra (4x2): Conteggio di alcune caratteristiche delle pedine o dello stato.
- Mappa di forza (24x2).
- Stato del gioco: chi lancia dopo! (1).
Puoi consultare una descrizione completa del modello qui sotto.
Versioni:
1.- Python Cumpy (TD-V1).
La prima versione di questa IA è stata addestrata in Python puro usando Cumpy, una libreria simile a Numpy che gira sulla GPU. Volevo imparare da zero, quindi anche se ho giocato per un po' con Tensorflow, ho deciso di andare nudo (beh, equipaggiato con la fantastica combo Python e Cumpy).
Caratteristiche:
- Una rete che stima le probabilità che la squadra 0 vinca la partita.
- Inconsapevole dei punti.
- Non aveva il flag "chi lancia dopo".
- Non aveva la mappa di forza.
- Un livello nascosto, con attivatori sigmoide.
- Ci sono volute 45.000 partite per battere la mia IA precedente scritta con informazioni esperte (GOAFI).
- Ha imparato per 4.500.000 partite. E ha vinto il 75% dei casi contro GOFAI.
- È stata in produzione per 2 anni.
2.- Tensorflow (TD-V2).
Il mio problema con la Versione 1 era che non era brava a calcolare le probabilità di vittoria perché era stata addestrata senza il flag "chi lancia dopo". In qualche modo, i risultati della NN erano abbastanza buoni per selezionare una buona mossa, ma dal punto di vista matematico, non erano coerenti. La Versione 2 ha risolto quel problema e ha aggiunto una nuova rete per calcolare le probabilità che la partita finisca in 1, 2 o 3 punti.
Ho scelto Tensorflow questa volta per addestrare il nuovo modello perché volevo imparare un framework, e ho trovato un eccellente esempio da cui partire.
Caratteristiche:
- Una rete per calcolare le probabilità che la squadra 0 vinca la partita.
- Una rete per calcolare la probabilità che la partita finisca in 1, 2 o 3 punti.
- Include la nuova mappa di forza.
- Due livelli nascosti, con diversi attivatori: Leaky RELU per i livelli nascosti e sigmoide nel livello di output.
- Ci sono volute 12.000 partite per vincere il 50% delle volte contro TD-V1.
- Ha imparato per 350.000 partite e ha raggiunto un tasso di vittoria dell'80% contro TD-V1.
3.- Versione 3: In Sospeso.
Come ultimo miglio nel processo decisionale di selezione della mossa migliore, c'è un semplice algoritmo che cerca la migliore Equità [%W*%p1+%W*%p2+%W*%p3].
A seconda dell'obiettivo del match, del numero di punti necessari a ciascun giocatore per vincere, e del valore del cubo, pesa diversamente l'output delle reti.
Vorrei fare una NN che gestisca quello. Quella sarà la V3. Non in sviluppo al momento.
Modello della Rete Neurale di Abak:
Descrizione della Pedina (14 input x 30 pedine):
- Distanza da casa x/25
- Quantità di pedine sopra x/4
- Quantità di pedine sotto x/4
- È sulla barra [0,1]
- È a casa [0,1]
- È al sicuro (a distanza = 0). [0,1]
- Sta facendo un blocco con un'altra pedina [0,1]
- È intrappolabile dal druido [0,1]
- È intrappolata dal druido [0,1]
- Sta intrappolando (questo input è solo per ogni druido) [0,1]
- Rischio di essere colpita nella zona vicina (6 posizioni avanti) [0..1]
- Rischio di essere colpita nella zona lontana (12 posizioni avanti) [0..1]
- Rischio di essere intrappolata dal druido [0..1]
- Possibilità di movimento [0..1]
Input relativi alla partita per ogni squadra (4x2):
- Quantità di pedine sulla barra. x/15
- Quantità di pedine al sicuro. x/15
- Tutte le pedine sono a casa. [0,1]
- Quantità di pedine al sicuro 0. [0,1]
Mappa di Forza: (24*2):
Infine, una mappa di forza, simile a quella proposta dal Dottor Tesauro per il Backgammon, ma semplificata. Per ogni posizione e per ogni squadra, ha un numero tra 0 e 1, che rappresenta quanto è forte quel blocco:
- 0.0se vuoto.
- 0.1se c'è una pedina.
- 0.5se quella pedina è una guardia.
- 1.0se ci sono due o più pedine.