alpha zero general

Alpha Zero General (n'importe quel jeu, n'importe quel cadre!)

Une mise en œuvre simplifiée, très flexible, commentée et (espérons-le) facile à comprendre de l'apprentissage en renforcement auto-play basé sur le papier alphago zéro (Silver et al). Il est conçu pour être facile à adopter pour tout jeu contradictoire basé sur le tour par tour et tout cadre d'apprentissage en profondeur de votre choix. Une implémentation d'échantillon a été fournie pour le jeu d'Othello à Pytorch et Keras. Un tutoriel qui l'accompagne peut être trouvé ici. Nous avons également des implémentations pour de nombreux autres jeux comme Gobang et Tictactoe.

Pour utiliser un jeu de votre choix, sous-classez les classes dans Game.py et NeuralNet.py et implémentez leurs fonctions. Des exemples d'implémentations pour Othello peuvent être trouvés dans othello/OthelloGame.py et othello/{pytorch,keras}/NNet.py .

Coach.py contient la boucle d'entraînement de base et MCTS.py effectue la recherche sur les arbres Monte Carlo. Les paramètres de l'auto-play peuvent être spécifiés dans main.py Des paramètres de réseau neuronal supplémentaires sont dans othello/{pytorch,keras}/NNet.py (drapeau CUDA, taille du lot, époques, taux d'apprentissage, etc.).

Pour commencer à former un modèle pour Othello:

python main.py

Choisissez votre framework et votre jeu dans main.py

Installation de Docker

Pour une configuration d'environnement facile, nous pouvons utiliser nvidia-docker. Une fois que Nvidia-Docker est configuré, nous pouvons alors simplement courir:

 ./setup_env.sh

Pour configurer un conteneur Docker (par défaut: pytorch). Nous pouvons maintenant ouvrir un nouveau terminal et entrer:

 docker exec -ti pytorch_notebook python main.py

Expériences

Nous avons formé un modèle Pytorch pour 6x6 Othello (~ 80 itérations, 100 épisodes par itération et 25 simulations MCT par tour). Cela a pris environ 3 jours sur un Nvidia Tesla K80. Le modèle pré-entraîné (pytorch) peut être trouvé dans pretrained_models/othello/pytorch/ . Vous pouvez jouer à un jeu contre lui en utilisant pit.py Vous trouverez ci-dessous les performances du modèle par rapport à une ligne de base aléatoire et gourmand avec le nombre d'itérations.

Une description concise de notre algorithme peut être trouvée ici.

Citation

Si vous avez trouvé ce travail utile, n'hésitez pas à le citer comme

 @misc{thakoor2016learning,
  title={Learning to play othello without human knowledge},
  author={Thakoor, Shantanu and Nair, Surag and Jhunjhunwala, Megha},
  year={2016},
  publisher={Stanford University, Final Project Report}
}

Contributif

Bien que le code actuel soit assez fonctionnel, nous pourrions bénéficier des contributions suivantes:

• Fichiers de logique de jeu pour plus de jeux qui suivent les spécifications de Game.py , ainsi que leurs réseaux de neurones
• Réseaux de neurones dans d'autres cadres
• Modèles pré-formés pour différentes configurations de jeu
• Une version asynchrone des processus parallèles de code pour la play-play, la formation neurale du neural et la comparaison du modèle.
• MCTS asynchrones comme décrit dans l'article

Certaines extensions ont été implémentées ici.

Contributeurs et crédits

• Shantanu Thakoor et Megha Jhunjhunwala ont aidé à la conception et à la mise en œuvre de base.
• Shantanu Kumar a apporté des modèles Tensorflow et Keras pour Othello.
• Evgeny Tyurin a contribué des règles et un modèle formé pour Tictactoe.
• MBOSS a contribué des règles et un modèle pour Gobang.
• Jernej Habjan a contribué au match RTS.
• Adam Lawson a contribué des règles et un modèle formé pour 3D Tictactoe.
• Carlos Aguayo a contribué des règles et un modèle formé pour les points et les boîtes ainsi qu'une implémentation JavaScript.
• Robert Ronan a apporté des règles pour Santorini.
• Plamen Totev a contribué le joueur de protocole de texte Go pour Othello.

Remarque: les versions Chainer et TensorFlow V1 ont été supprimées mais peuvent être trouvées avant la validation 2AD461C.