Faisons l'IA d'Othello avec Chainer-Part 2-

introduction

Cet article est une suite de "Création d'Othello AI avec Chainer-Part 1-". Nous espérons que vous aurez lu la première partie avant de lire cet article.

Donc, en utilisant le modèle entraîné créé dans la première partie, j'ai implémenté l'IA en utilisant le modèle MLP dans le jeu Othello. Pour l'application de jeu Othello, utilisez celle créée dans "Faisons Othello avec wxPython". Le code source et les modèles entraînés de l'application de jeu Othello sont répertoriés sur GitHub, veuillez donc les récupérer à partir de là.

Description de l'application de jeu Othello

Ceci est une application créée avec wxPython. Il nécessite wxPython pour fonctionner. Veuillez consulter ici pour la méthode d'installation. La méthode de démarrage est la suivante.

$ python reversi.py

reversi_1.2.0.png Je vais expliquer brièvement l'écran. Spécifiez le modèle pour l'IA par MLP dans "Paramètre du modèle MLP" à l'extrême droite. Spécifiez le modèle pour le premier coup (noir) dans «pour le noir» et le modèle pour le deuxième coup (blanc) dans «pour le blanc». De même, spécifiez l'IA de l'ordinateur dans le "Réglage de l'IA de l'ordinateur" à l'extrémité droite. Les détails de l'IA seront décrits plus loin. Dans la zone vide au centre, le score est affiché au fur et à mesure que le jeu progresse. Réglez le type de jeu en «Mode jeu» en bas au centre et démarrez le jeu avec le bouton «START».

"SCORE" en bas au centre est le nombre actuel de pierres dans le premier (noir) et le deuxième (blanc). Entrez le nombre de boucles dans la zone de texte en bas au centre et appuyez sur le bouton "Comp vs Comp Loop" pour lire l'ordinateur A et l'ordinateur B pour le nombre spécifié de fois dans une ligne. (Pour le moment, n'utilisez pas le bouton "START") À la fin de la boucle, le nombre de victoires pour l'ordinateur A et l'ordinateur B sera affiché. DRAW est le nombre de tirages.

Cette application Othello vous permet non seulement de jouer des batailles régulières, mais possède également les fonctionnalités suivantes.

  1. Vous pouvez sélectionner Computer AI. (Pour plus d'informations sur l'IA autre que MLP, cliquez ici](http://qiita.com/kanlkan/items/cf902964b02179d73639))
    • MLP
  1. Si AI utilisant le modèle MLP est sélectionné et AI sélectionne un mouvement qui s'écarte des règles, "* Déplacement illégal! ... *" est émis vers la sortie d'erreur standard. Les types sont les suivants. ** Si un mouvement illégal se produit, la main de l'ordinateur sera placée à la première place trouvée dans la pierre, si elle peut être placée, et s'il est nécessaire de passer, passez-la et continuez la partie. Masu (Fail Safe). ** **
    • Cannot put stone but AI cannot select 'PASS'.
  1. Vous pouvez compter les victoires et les pertes en jouant plusieurs batailles entre des IA informatiques d'affilée.

Vérifier l'IA à l'aide du modèle MLP

Passons maintenant à vérifier s'il est jouable. Je veux faire une IA forte si possible. Par conséquent, le modèle entraîné en utilisant uniquement le score de jeu du premier jeu gagnant (noir) (* model_black_win.npz ) et le modèle formé en utilisant uniquement le score de jeu du deuxième joueur (blanc) ( model_white_win.npz) Jouons contre un humain (moi) en utilisant *). Hmmmm. .. .. ** Mumu **. ** Mouvement illégal! Il est sorti ... ** Ce n'était pas aussi facile que lors de l'organisation de trois yeux. Cependant, il est toujours conforme aux attentes. Tout d'abord, examinons les types de mouvements illégaux qui apparaissent et leur fréquence. Le soleil se couche lorsque vous jouez contre vous-même, alors jouons les uns contre les autres. Je jouerai contre MLP et Random. Mouvement illégal! S'est produit 7027 fois en 1000 batailles. La répartition des types de mouvement illégal qui s'est produit est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 93
Cannot 'PASS' this turn but AI selected it. 51
Cannot put stone at AI selected postion. 6883
total 7027

Calculez grossièrement. En supposant qu'aucune passe n'est générée dans une partie et que le plateau ne peut pas être réglé tant qu'il n'est pas rempli, 60 coups seront effectués jusqu'à ce que le plateau soit rempli et réglé. Un joueur réussit 30 coups. 30 000 coups en 1000 batailles. Ainsi, puisqu'il est 7027/30000, on peut estimer grossièrement que 23,4% des cas sont frauduleux.

80% des jeux se jouent selon les règles, je crains donc de changer la configuration MLP ... Tout d'abord, je ferai ce que je peux penser sans changer la configuration de MLP.

Le festival try & error a commencé.

Réessayer 1: essayez d'utiliser le score de tous les matchs, pas seulement le score du match gagnant

Pour créer une IA forte, je vais la mettre de côté et donner la priorité au respect des règles. Nous allons essayer d'augmenter la variété des modèles en apprenant non seulement les jeux qui y ont gagné mais aussi les jeux qui ont perdu. Définissez "* model_black.npz " pour le premier mouvement (noir) et " model_white.npz *" pour le deuxième mouvement (blanc) comme MLP AI. Ces modèles sont des modèles créés avec les commandes suivantes.

$ python build_mlp.py Othello.01e4.ggf black
$ mv reversi_model.npz model_black.npz
$ python build_mlp.py Othello.01e4.ggf white
$ mv reversi_model.npz model_white.npz

Maintenant, jouons les ordinateurs les uns contre les autres comme avant. MLP vs revanche aléatoire. Mouvement illégal! S'est produit 5720 fois en 1000 batailles. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 65
Cannot 'PASS' this turn but AI selected it. 123
Cannot put stone at AI selected postion. 5532
total 5720

Puisqu'il est 5720/30000, il est illégal à un taux de 19,1%. Il semble que l'avenir soit encore long, mais il est moins qu'avant. C'est une bonne tendance.

Réessayer 2: essayez d'augmenter le nombre d'époques pour vous entraîner de 1000 à 3000

C'est assez vaincu, mais si vous vous entraînez plus souvent, cela fonctionnera. J'ai modifié "* build_mlp.py *" afin que batch_size et max epoch count puissent être spécifiés comme arguments, et recréé le modèle avec batch_size = 100 et max_epoch_count = 3000.

$ python build_mlp.py Othello.01e4.ggf black 100 3000
$ mv reversi_model.npz model_epoch-3000_black.npz
$ python build_mlp.py Othello.01e4.ggf white 100 3000
$ mv reversi_model.npz model_epoch-3000_white.npz

D'ailleurs, dans mon environnement, cet apprentissage a pris 5 heures + 5 heures = 10 heures ... J'ai peur de n'avoir qu'un environnement Linux sur VirtualBox ...

Laissez les ordinateurs jouer les uns contre les autres avec ces modèles. MLP contre 1000 batailles aléatoires.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 35
Cannot 'PASS' this turn but AI selected it. 257
Cannot put stone at AI selected postion. 5677
total 5966

Puisqu'il s'agit de 5966/30000, 19,9% du temps c'est frauduleux. Cela ne change pas grand-chose. Même si vous augmentez l'Époque à 1000 ou plus, il semble que l'apprentissage ne se poursuivra plus. En fait, même si vous n'essayez pas avec Epoch réglé sur 3000, préparez séparément environ 1000 données de test similaires aux données de l'enseignant et prenez la corrélation Epoch-Précision (courbe d'apprentissage) lors de l'exécution de "* build_mlp.py *". Si vous le regardez, vous pouvez voir à quel point Epoch est peu susceptible de faire progresser l'apprentissage.

Réessayer 3: effectuez 10000 fois MLP vs aléatoire et utilisez le modèle formé sur ce score

Même si les données des enseignants sont conçues, elles ne fonctionnent pas bien, je vais donc essayer une approche différente. Configurez MLP AI en utilisant "* model_black.npz ", " model_white.npz " et jouez les uns contre les autres en MLP vs Random (10000 batailles cette fois). J'essaierai de m'entraîner à nouveau avec ce score. L'intention est que je pense qu'il est possible d'en apprendre davantage sur les modèles dans lesquels MLP AI n'est pas bon en utilisant un syllabaire qui donne la bonne réponse avec la fonction Fail Safe pour les modèles pour lesquels MLP AI n'est pas bon. Parce que c'est. Tout d'abord, jouons à 10000 MLP contre Random. Un fichier de partition appelé " record.log " sera sauvegardé, renommez-le donc en " mlp_vs_random_10000_01.log *". Lisez ce fichier journal et recréez le modèle.

$ python build_mlp.py mlp_vs_random_10000_01.log black 100 1000
$ mv reversi_model.npz model_mlp_vs_random_black_01.npz
$ python build_mlp.py mlp_vs_random_10000_01.log white 100 1000
$ mv reversi_model.npz model_mlp_vs_random_white_01.npz

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_mlp_vs_random_black_01.npz, model_mlp_vs_random_white_01.npz *). Mouvement illégal! S'est produit 2794 fois en 1000 matchs. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 84
Cannot 'PASS' this turn but AI selected it. 57
Cannot put stone at AI selected postion. 2653
total 2794

Puisqu'il est 2794/30000, il est illégal à un taux de 9,3%. Ça m'a l'air bien! C'est environ la moitié! Maintenant, faisons de notre mieux à partir d'ici.

Cette méthode semble fonctionner, alors essayez à nouveau les mêmes étapes. Utilisez * model_mlp_vs_random_black_01.npz, model_mlp_vs_random_white_01.npz * pour jouer 10000 fois dans MLP vs Random, remplacez "* record.log " par " mlp_vs_random_10000_02.log *" et recréez le modèle avec ce journal. Je vais.

$ python build_mlp.py mlp_vs_random_10000_02.log black 100 1000
$ mv reversi_model.npz model_mlp_vs_random_black_02.npz
$ python build_mlp.py mlp_vs_random_10000_02.log white 100 1000
$ mv reversi_model.npz model_mlp_vs_random_white_02.npz

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_mlp_vs_random_black_02.npz, model_mlp_vs_random_white_02.npz *). Mouvement illégal! S'est produit 2561 fois en 1000 batailles. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 121
Cannot 'PASS' this turn but AI selected it. 41
Cannot put stone at AI selected postion. 2399
total 2561

Puisqu'il est 2399/30000, 8,0% des cas sont frauduleux. Hmmm ... devrait-il être considéré comme une légère baisse? Une fois, cette méthode est arrêtée ici.

Réessayer 4: effectuez 10000 fois MLP vs Random, combinez le score avec Othell0.01e4.ggf et utilisez le modèle entraîné.

$cat Othello.01e4 mlp_random_10000_01.log > 01e4_mlp_randomA_10000_01.ggf
$ python build_mlp.py 01e4_mlp_randomA_10000_01.ggf
 black 100 1000
$ mv reversi_model.npz model_01e4_mlp_vs_random_black_02.npz
$ python build_mlp.py 01e4_mlp_randomA_10000_01.ggf
 white 100 1000
$ mv reversi_model.npz model_01e4_mlp_vs_random_white_02.npz

Comme mentionné ci-dessus, entraînons-nous avec le syllabaire existant "* Othello.01e4.ggf " et le syllabaire créé à l'étape précédente " mlp_random_10000_01.log *". Je pensais que la performance serait améliorée car le score serait plus diversifié et inclurait une main qui deviendrait un coup illégal.

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_01e4_mlp_vs_random_black.npz, model_01e4_mlp_vs_random_white.npz *). Mouvement illégal! S'est produit 3325 fois en 1000 batailles. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 48
Cannot 'PASS' this turn but AI selected it. 90
Cannot put stone at AI selected postion. 3187
total 3325

Puisqu'il est 3325/30000, nous faisons des actions frauduleuses à un taux de 11,1%. Eh bien, le résultat n'est pas très différent de Retry 3. Pardon.

Résumé intermédiaire

Cette semaine, je vais le résumer ici.

Est-ce un tel endroit? À l'heure actuelle, la probabilité de sélectionner un mouvement illégal a été réduite à 8,0%, donc l'IA avec Fail Safe sera le résultat au point médian. Eh bien, c'est peut-être le résultat final, mais je suis un peu déçu, donc à partir de la semaine prochaine, je jouerai avec les paramètres du modèle MLP. J'ajouterai plus à cet article sur les essais futurs. Si vous êtes intéressé par le développement, veuillez le regarder.

Dans cette étude, dans mon environnement, c'est un gros goulot d'étranglement qu'il faut plusieurs heures pour former le modèle à partir de la partition à chaque fois ... Si vous pouvez utiliser le GPU, je pense que vous pouvez le faire un peu plus facilement, il serait donc intéressant de réécrire "* build_mlp.py *" pour supporter le GPU et essayer diverses choses.

** ↓↓↓↓↓ 2016/08/14 mise à jour ↓↓↓↓↓ **

Confirmation de la courbe d'apprentissage

Mise à jour de "* bulb_mlp.py *" pour afficher la courbe d'apprentissage. Réservez 1000 échantillons à la fin des données en tant que données de test (Validation) (ces 1000 échantillons ne sont pas utilisés pour la formation), et pour le taux de réponse correct (principal / précision) dans les données de formation à chaque époque et les données de test inconnues du modèle. Le taux de réponse correct (validation / principal / précision) est affiché. Vous pouvez maintenant dessiner la courbe d'apprentissage. Eh bien, c'est une histoire que vous devriez enfin faire depuis le début ...

Tout d'abord, la courbe d'entraînement dans le premier modèle est affichée. lc_black.png lc_white.png

À 1000 Epoch, principal / précision est saturé à environ 0,45. On peut juger qu'essayer de changer l'Époque effectuée lors de la nouvelle tentative 2 de 1000 à 3000 semble être inefficace. Au fait, le taux de réponse correcte de 0,45 = 45% n'est-il pas bas? Vous pensez peut-être, mais comme nous utilisons le score réel, il y a plusieurs mouvements pour répondre à une certaine condition du tableau, il semble donc que le taux de réponse correct ne soit pas si élevé.

Ensuite, la courbe d'apprentissage lorsque le nombre de neurones dans la couche cachée (h1, h2) est augmenté de 100 à 200 est affichée. lc_neuron-200_black.png lc_neuron-200_white.png

C'est la même chose qu'il converge presque vers 1000 Epoch. L'augmentation du nombre de neurones augmente le taux de réponse correct (principal / précision) des données d'entraînement, mais la valeur de validation / principal / précision, qui est le taux de réponse correct pour les entrées inconnues, est presque la même que lorsque le nombre de neurones est de 100. Cela signifie ... je ne pense pas que je peux me conformer aux règles même si je passe de 100 à 200 neurones ... Mais pour le moment, je vais le vérifier lors d'une nouvelle tentative 5.

Réessayer 5: augmenter les neurones h1 et h2 de 100 à 200

Je pensais que l'augmentation du nombre de neurones augmenterait l'effet d'entraînement sur le score et permettrait de respecter les règles. Modifiez la définition de la classe MLP dans "* build_mlp.py *".

...
class MLP(Chain):
    def __init__(self):
        super(MLP, self).__init__(
                l1=L.Linear(64,200)
                l2=L.Linear(200,200)
                l3=L.Linear(200,65)
        )
...

Après les modifications, créez un modèle entraîné.

$ python build_mlp.py Othelo.01e4.ggf black 100 1000
$ mv reversi_model.npz model_neuron-200_black.npz
$ python build_mlp.py Othelo.01e4.ggf white 100 1000
$ mv reversi_model.npz model_neuron-200_white.npz

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_neuron-200_black.npz, model_neuron-200_white.npz ). (La définition de la classe MLP dans " reversi.py *" doit également être modifiée comme décrit ci-dessus) Mouvement illégal! S'est produit 10778 fois en 1000 batailles. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 99
Cannot 'PASS' this turn but AI selected it. 120
Cannot put stone at AI selected postion. 10778
total 10997

Puisqu'il est 10997/30000, nous faisons des actions frauduleuses à un taux de 36,7%. Cela empire ... peut-être que cela correspond trop aux données d'entraînement.

Réessayer 6: augmenter l'échantillon d'entraînement d'environ 3 fois

Connectons non seulement Othello.01e4.ggf mais aussi Othello.02e4.ggf et Othello.03e4.ggf pour lire le score d'échecs, et faisons-en environ 3 fois plus pour apprendre plus de motifs différents.

$ cat Othello.01e4.ggf Othello.02e4.ggf Othello.03e4.ggf > Othello.01-03e4.ggf
$ python build_mlp.py Ohtello.01-03e4.ggf black 100 1000
$ mv reversi_model.npz model_01-03e4_black.npz 
$ python build_mlp.py Ohtello.01-03e4.ggf white 100 1000
$ mv reversi_model.npz model_01-03e4_white.npz

La courbe d'apprentissage est la suivante. lc_01-03e4_black.png lc_01-03e4_white.png La validation / main / précision est passée de 0,3 à 0,35 par rapport au cas où le score n'est que Othello.01e4.ggf. Pouvez-vous vous attendre un peu?

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_01-03e4_black.npz, model_01-03e4_white.npz *). Mouvement illégal! S'est produit 5284 fois en 1000 matchs. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 40
Cannot 'PASS' this turn but AI selected it. 228
Cannot put stone at AI selected postion. 5016
total 5284

Puisqu'il est 5284/30000, il est illégal à un taux de 17,6%. Ce n'est pas très différent du cas où seul Othello.01e4.ggf est utilisé pour le score du jeu (19,1%). Ça devient assez compliqué ...

Réessayer 7: Ajouter des informations de «lieu» à l'entrée MLP (état de la carte)

Cette fois, je vais changer la façon de penser et essayer de modifier l'entrée MLP elle-même. Plus précisément, en plus de «0»: aucun, «1»: noir, «2»: blanc et «3»: place pour placer les informations de la carte à donner en entrée. Par exemple. X1 est l'état X0 dans le cas du virage noir, avec une place pour le mettre ajouté.

X0 = [[0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,2,1,0,0,0],\
      [0,0,1,2,2,2,2,0],\
      [0,0,0,1,2,2,0,0],\
      [0,0,0,0,1,2,0,0],\
      [0,0,0,0,0,0,0,0]]

X1 = [[0,0,0,0,0,0,0,0],\
      [0,0,0,0,0,0,0,0],\
      [0,0,0,3,3,0,0,0],\
      [0,0,3,2,1,3,0,3],\
      [0,0,1,2,2,2,2,3],\
      [0,0,3,1,2,2,3,0],\
      [0,0,0,0,1,2,3,0],\
      [0,0,0,0,0,0,0,0]]

En faisant cela, j'ai pensé qu'une IA conforme aux règles pouvait être créée. Il semble y avoir un tsukkomi disant "Je vous dis presque les règles!", Mais l'hypothèse que l'état de la carte est utilisé comme entrée et que le coup suivant est obtenu comme sortie n'a pas changé. (Une excuse assez douloureuse ...) "* Build_mlp.py *" modifié pour spécifier s'il faut ajouter un emplacement pour le placer. Si True est ajouté à la fin de la commande, l'endroit où il peut être placé sera ajouté à la carte d'entrée en tant que «3».

$ pythohn build_mlp.py Othello.01e4.ggf black 100 1000 True
$ mv reversi_model.npz model_black_puttable_mark.npz 
$ pythohn build_mlp.py Othello.01e4.ggf white 100 1000 True
$ mv reversi_model.npz model_white_puttable_mark.npz 

La courbe d'apprentissage est la suivante. lc_puttable_mark_black.png lc_puttable_mark_white.png

Il a la validation / principale / précision la plus élevée à ce jour et converge vers 0,4.

Rematch avec MLP vs Random en utilisant le nouveau modèle (* model_black_puttable_mark.npz, model_white_puttable_mark.npz ). Correction de " reversi.py " pour prendre en charge ces modèles. Si le nom du modèle MLP spécifié contient " puttable_mark *", il correspond à l'entrée représentée par "3" où il peut être placé.

Mouvement illégal! S'est produit 207 fois en 1000 batailles. La répartition est la suivante.

Detail Nombre d'occurrences
Cannot put stone but AI cannot select 'PASS'. 16
Cannot 'PASS' this turn but AI selected it. 17
Cannot put stone at AI selected postion. 174
total 207

Puisqu'il est 207/30000, nous faisons quelque chose d'illégal à un taux de 0,7%. Quel 1% ou moins! C'est une amélioration spectaculaire.

Résumé final

Je vais résumer ce qui précède.

En tant qu'IA qui fonctionne correctement, est-ce celui avec "Fail Safe" ajouté à celui avec "Place" ajouté comme "3" dans l'état de la carte? C'est peut-être un peu bâclé, mais j'ai pu créer une IA décente.

À l'heure actuelle, la force de l'IA ne dépend que du score. Après avoir créé l'IA de base par la méthode ci-dessus, elle sera renforcée en utilisant le renforcement de l'apprentissage, etc. J'ignore totalement l'apprentissage par renforcement, alors j'essaierai après mes études.

Merci pour votre considération. C'était pauvre.

Recommended Posts

Faisons l'IA d'Othello avec Chainer-Part 1-
Faisons l'IA d'Othello avec Chainer-Part 2-
Faisons une IA à trois yeux avec Pylearn 2
Créez Puyopuyo AI avec Python
Faisons une interface graphique avec python.
Faisons une rupture de bloc avec wxPython
Faisons un graphe avec python! !!
Faisons un spacon avec xCAT
Faisons un jeu de shiritori avec Python
Faisons la voix lentement avec Python
Faisons un langage simple avec PLY 1
[Python] Rendons matplotlib compatible avec le japonais
Créez un framework Web avec Python! (1)
Faisons un bot Twitter avec Python!
Créez un framework Web avec Python! (2)
Remplaçons UWSC par Python (5) Faisons un robot
Créer des couches Lambda avec Lambda
3. 3. Programmation IA avec Python
Créez un Yuma avec Discord.py
Jouer avec Othello (Reversi)
[Jouons avec Python] Créer un livre de comptes de ménage
Essayez de créer un jeu simple avec Python 3 et iPhone
Facilitons un peu la gestion des dépendances avec pip
Créons une application Mac avec Tkinter et py2app
Essayez de créer une grille sphérique avec Rhinoceros / Grasshopper / GHPython
[Super facile] Faisons un LINE BOT avec Python.
Créer des diapositives avec iPython
J'ai essayé de faire d'Othello AI que j'ai appris 7,2 millions de mains par apprentissage profond avec Chainer
Créons un client de socket Web avec Python. (Authentification par jeton d'accès)
Une histoire de compétition avec un ami dans Othello AI Preparation
Faisons un diagramme sur lequel on peut cliquer avec IPython
Jouons avec la 4e dimension 4e
Faisons un robot Discord.
Jouons avec les données Amedas - Partie 1
Créez des boutons de type SF avec Kivy
Faisons un plugin Errbot
Jouons avec les données Amedas - Partie 4
Rendre avec la syntaxe facile
Faites une loterie avec Python
Écrivons python avec cinema4d.
Faisons R-CNN avec Sklearn-theano
Jouons avec les données Amedas - Partie 2
Construisons git-cat avec Python
Othello fait avec python (comme GUI)
Faire un feu avec kdeplot
Créer un chatbot Slack avec Errbot
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Implémentation ~
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 1
Créons une IA à trois voies avec Pylearn2 --Save and load model -
Faisons un ordinateur de vélo avec Raspberry Pi Zero (W, WH)
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 2
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 3
Faisons une application WEB pour l'annuaire téléphonique avec flacon Partie 4
Faisons une discussion WEB en utilisant WebSocket avec AWS sans serveur (Python)!
Faisons une chemise IoT avec Lambda, Kinesis, Raspberry Pi [Partie 1]
J'ai essayé de créer Othello AI avec tensorflow sans comprendre la théorie de l'apprentissage automatique ~ Battle Edition ~