Les jeux des pandas, le tutoriel

01Le projet en bref

Le dépôt part du tutoriel vidéo Tuto-IA-3D-Youtube de neocodeytb (le parcours 3D). Quatre jeux ont été ajoutés ensuite. Tous sont publiés sur rdv-app.fr/jeux.html, chacun avec une page « jouer » et une page « code expliqué ».

Organisation des fichiers

Point commun à respecter partout : neat-python doit rester en version 0.92. La version 2.0 refuse les fichiers config*.txt du projet.

02Le parcours 3D (main.py)

Vingt pandas apprennent à traverser un parcours 3D. Le résultat est atteint en 30 à 100 générations en mode rapide, soit une à quatre minutes sur un processeur ordinaire.

La grande boucle

Deux boucles cohabitent : celle de Panda3D (taskMgr, une tâche par image) et celle de NEAT (p.run, une évaluation par génération). C'est NEAT qui commande.

1. initNeat lit config.txt et crée 20 génomes.
2. p.run(self.playGame, 10000) appelle playGame à chaque génération.
3. playGame transforme chaque génome en réseau et en panda, puis lance taskMgr.run().
4. À chaque image : updatePlayerNeat (décider, bouger), updateCollisionsNeat (murs, sols, zones), verifFinPartie.
5. En fin de partie, taskMgr.stop() rend la main à playGame, qui note chaque génome.

def playGame(self, genomes, config):
    self.players = []
    for _, g in genomes:
        net = neat.nn.FeedForwardNetwork.create(g, config)
        self.players.append(self.generatePlayerNeat(idx, net))
        g.fitness = 0
    self.taskMgr.run()      # la partie se joue ici
    for _, g in genomes:
        g.fitness = ...     # voir la fitness

Le monde, la physique, les capteurs

La carte map_tuto.glb n'est qu'un décor. Le jeu ne connaît que des formes de collision invisibles placées dans initColliders, chacune avec une étiquette : Wall (rebond), Floor, Ladder, Score1 à Score9 (zones de progression), Reward (victoire), Bomb (mort).

La physique est volontairement simple : frottement ×0,93 par image, gravité −0,30 par image en l'air, mort sous z = −100.

Un panda ne voit rien. Il porte trois boîtes de collision devant lui, qui valent 1 si elles touchent le sol. Un capteur à 0 veut dire « du vide devant ».

Le cerveau

• 12 entrées : les 3 capteurs, puis 9 cases qui disent quelle zone a été franchie en dernier (une seule à 1, encodage « one-hot »).
• 5 sorties : avancer, reculer, tourner à gauche, tourner à droite, sauter. Une action est faite si sa sortie est positive.

Les 9 cases de zone permettent au même réseau d'agir différemment selon l'endroit du parcours, alors qu'il ne voit presque rien.

La fitness

Dans le tuto d'origine, la note est le numéro de la dernière zone franchie (0 à 10). Beaucoup de pandas ont la même note, et NEAT ne sait pas lequel était le plus proche de réussir. La version corrigée ajoute un bonus inférieur à 1 :

bonus = 0 if player["score"] == 10 else 0.99 / (1 + player["distMin"] / 50)
g.fitness = player["score"] + bonus

Il départage les ex æquo sans jamais faire passer une zone 4 devant une zone 5.

Difficultés rencontrées et solutions

Le pas de temps fixe a un second effet : chaque partie devient reproductible. C'est ce qui permet à la démo web (Three.js) de rejouer exactement les parties de l'entraînement exportées par python main.py --rapide --export-web.

03Le labyrinthe (labyrinthe.py)

Des pandas qui ne voient presque rien apprennent à sortir d'un labyrinthe en un minimum d'actions. Le champion final sort de 17 labyrinthes jamais vus sur 20, en 1,00 fois le minimum d'actions en moyenne.

Les règles

Grille de 10 × 10 cases, départ en haut à gauche tourné vers l'est, sortie dans le mur est de la case en bas à droite. À chaque pas, une seule action parmi trois : avancer, tourner à gauche, tourner à droite. Tourner coûte autant qu'avancer.

La partie s'arrête à la sortie, après 4 × taille² actions (400 pour un 10 × 10), ou si le panda repasse plus de 4 fois sur la même case avec la même orientation (il tourne en rond).

Créer un labyrinthe

Les labyrinthes sont « parfaits » (un seul chemin entre deux cases). Ils sont creusés par exploration en profondeur : on perce un mur vers un voisin pas encore visité, et on revient en arrière dans un cul-de-sac.

while pile:
    x, y = pile[-1]
    voisins = [(d, x + DX[d], y + DY[d]) for d in range(4)
               if ... and (x + DX[d], y + DY[d]) not in vues]
    if not voisins:
        pile.pop()          # cul-de-sac : on revient en arrière
        continue
    d, nx, ny = rng.choice(voisins)
    self.murs[y][x][d] = False              # on perce le mur des deux côtés
    self.murs[ny][nx][(d + 2) % 4] = False
    vues.add((nx, ny))
    pile.append((nx, ny))

Le hasard dépend d'une graine : la même graine donne le même labyrinthe. On entraîne sur les graines 1 à 20 et on teste sur d'autres. Deux parcours en largeur calculent ensuite la distance de chaque case à la sortie et le nombre minimal d'actions, virages compris.

Ce que sent le panda (8 entrées, 3 sorties)

• Mur devant, à gauche, à droite (0 ou 1).
• Dernière action : avancer, gauche, droite. C'est sa seule mémoire.
• Une boussole : la sortie est-elle devant ou derrière, à droite ou à gauche (vecteur vers la sortie projeté sur son regard).

Le réseau rend 3 valeurs ; on joue la plus forte (argmax). Contrairement au parcours 3D, une seule action à la fois.

La fitness

Sortir rapporte toujours plus que ne pas sortir. Entre deux pandas bloqués, celui qui s'est le plus approché gagne : l'évolution progresse avant même la première sortie. En Python, on additionne les 20 labyrinthes d'entraînement (maximum 40).

Deux entraînements

• Python : 60 pandas, 150 générations, 20 labyrinthes chacun, environ 0,7 seconde par génération. Avec --export-web, chaque partie est enregistrée en lettres (A avancer, G gauche, D droite) : 150 générations × 60 pandas × 3 labyrinthes tiennent en 2 Mo.
• Navigateur : une version JavaScript de NEAT tourne dans un Web Worker, pour que la page reste fluide. Le calcul du réseau reproduit exactement FeedForwardNetwork de neat-python (activation tanh(2,5 × z)) : le champion Python fait les mêmes actions dans le navigateur.

Difficultés rencontrées et solutions

Pour lancer : python labyrinthe.py (300 générations et bilan), python labyrinthe.py --generations 150 --graine 1 --export-web pour régénérer les données de la démo.

04Panda ninja (minigame.html)

Un ninja apprend à traverser un niveau à défilement plein de trous, de caisses, de gardes et d'archers. Tout tourne dans le navigateur : avec 80 ninjas, le premier arrivé apparaît entre la génération 18 et 65 selon le niveau.

Les règles

Une partie s'arrête aussi au bout de 60 secondes, ou si le ninja n'a pas avancé depuis 5 secondes.

Créer un niveau

Un niveau est une liste de morceaux de sol (les trous sont les espaces entre eux), de caisses et d'ennemis, tirée d'une graine. La difficulté augmente le nombre et la taille des obstacles, sans jamais dépasser ce qu'un saut permet.

const nb = 12 + 4 * difficulte;
for (let i = 0; i < nb; i++) {
  const t = r();
  if (t < 0.32) {                                     // un trou
    const w = Math.round(48 + r() * (24 + 14 * difficulte));
    sols.push([debut, x]); x += w; debut = x; x += 130 + r() * 80;
  } else if (t < 0.52) {                              // une caisse
    caisses.push([x, 40, Math.round(24 + r() * (14 + 10 * difficulte))]);
  } else if (t < 0.8) {                               // un garde
    ennemis.push({ type: "garde", x1: x, x2: x + l });
  } else {                                            // un archer
    ennemis.push({ type: "archer", x: x + 60 });
  }
}

Le moteur : une seule fonction déterministe

pas(niveau, état, actions) avance le jeu d'une image (1/60 s). Les actions tiennent sur 4 bits : 1 droite, 2 gauche, 4 sauter, 8 lancer. Pas de hasard, pas d'horloge : la même suite d'actions donne toujours la même partie.

Le même code sert à trois choses : faire jouer l'humain, faire jouer l'IA dans le Web Worker, et rejouer une partie enregistrée.

if (a & 1) vx += VIT;                          // droite : 3 px par image
if (a & 2) vx -= VIT;                          // gauche
if ((a & 4) && p.sol) { p.vy = SAUT; }         // sauter : -11,5 px par image
if ((a & 8) && p.cd <= 0) {                    // lancer, si le shuriken est prêt
  s.shurikens.push({ x: p.x + p.dir * 12, y: p.y - 20, v: 8 * p.dir, reste: 40 });
  p.cd = 30;
}
p.vy += GRAV;                                  // gravité : 0,6 px par image²

Ce que sent le ninja (11 ou 12 entrées, 4 sorties)

Le ninja ne voit pas l'écran. Il reçoit des mesures de ce qui arrive devant lui :

• Devant lui : distance et largeur du prochain trou, distance et hauteur de la prochaine caisse, distance de l'ennemi le plus proche, « est-ce un archer », distance de la flèche la plus proche.
• Lui-même : au sol, vitesse verticale, shuriken prêt, hauteur au-dessus du sol.
• En option : sa position dans le niveau (0 au départ, 1 à l'arrivée).

Les distances sont divisées par une portée (200 ou 300 px) puis bornées à 1 : « 1 » veut dire « rien en vue ». Chaque sortie positive appuie sur sa touche : le ninja peut courir, sauter et lancer en même temps.

La fitness

Difficultés rencontrées et solutions

05Les dames (dames-moteur.js)

Dames internationales contre une IA, à deux sur le même écran ou en ligne. Ici, pas de réseau de neurones : l'IA cherche ses coups par alpha-bêta et apprend les 7 poids qui servent à juger une position. Entraînée 30 générations, elle marque 69 % des points contre l'IA de départ (contrôle sur 40 parties).

Le damier en mémoire

Seules les 50 cases foncées comptent : un tableau de 50 nombres (0 vide, 1 pion blanc, 2 dame blanche, −1 pion noir, −2 dame noire). La numérotation 1 à 50 est celle des compétitions, ce qui donne directement la notation officielle (32-28, 28x19).

Les « rayons » sont calculés une fois pour toutes : pour chaque case et chaque diagonale, la liste des cases jusqu'au bord. Un pion n'en regarde que la première, une dame les parcourt toutes.

const RAYONS = Array.from({ length: 50 }, (_, s) => DIRS.map(([dr, dc]) => {
  const r = [];
  let l = LIGNE(s) + dr, c = COL(s) + dc;
  while (CASE(l, c) >= 0) { r.push(CASE(l, c)); l += dr; c += dc; }
  return r;
}));

Trouver les coups : la rafle

Une recherche en profondeur essaie toutes les suites de prises depuis chaque pièce. On ne garde ensuite que les rafles qui prennent le plus de pièces (prise majoritaire).

let i = 0;
while (i < ray.length && b[ray[i]] === 0) i++;          // la dame glisse sur les cases vides
const a = ray[i];
if (b[a] * camp >= 0 || prises.includes(a)) continue;  // pas adverse, ou déjà prise
i++;
while (i < ray.length && b[ray[i]] === 0) {             // toutes les cases libres derrière
  dfs(ray[i], [...prises, a], [...chemin, ray[i]]);
  i++;
}

Juger une position et chercher le meilleur coup

L'IA compte 7 critères par camp (pions, dames, avancée, centre, rangée du fond, pions protégés, pions bientôt dame), multipliés chacun par un poids. Elle explore les coups jusqu'à une profondeur donnée (minimax), en coupant les branches inutiles (alpha-bêta), dans un Web Worker.

Apprendre par tournois

Un algorithme évolutionnaire fait évoluer 12 jeux de 7 poids. Chacun joue 4 parties à profondeur 2 ; les 3 meilleurs passent tels quels, les autres places vont à des enfants de deux bons parents, légèrement modifiés. L'IA a appris seule à garder sa rangée du fond (poids de 0,1 à 0,4-0,6) et à valoriser les pions proches de la promotion (de 0,3 à plus de 1).

Jouer en ligne

Un serveur Node sans dépendance tient les parties. Chaque salle a un code de 5 caractères. Chaque navigateur reçoit l'état par un flux Server-Sent Events et envoie ses coups par POST. Le serveur vérifie chaque coup avec le même fichier de règles que la page :

if (p.trait !== c) return repondre(res, 409, { erreur: "Ce n'est pas à vous de jouer." });
if (m.index !== salle.coups.length) return repondre(res, 409, { erreur: "Coup déjà joué ou décalé" });
const legal = liste.find((x) => cle(x) === cle({ de: m.de, a: m.a, prises: m.prises || [] }));
if (!legal) return repondre(res, 422, { erreur: "Coup illégal." });
salle.coups.push(legal);
diffuser(salle);

Difficultés rencontrées et solutions

Le serveur tourne sous pm2 (dames-reseau, port 3077), derrière nginx sur /dames-api/.

06L'IA et l'or (trading-or.html)

Des IA apprennent à trader l'or sur 25 ans de cours réels (simulation, sans argent réel). Résultat principal : sur une période jamais vue (2019-2026), la meilleure IA fait 7 à 14 % par an, quand acheter et garder rapportait 16,4 %.

Les données

Les cours viennent de Yahoo Finance (contrat à terme COMEX, symbole GC=F) : 6 550 clôtures quotidiennes depuis 2000 pour l'entraînement, et le cours minute par minute pour le temps réel. Un relais Node sur rdv-app.fr interroge Yahoo à la place du navigateur et garde les réponses en mémoire (6 heures pour l'historique, 30 secondes pour le direct).

Ce que voit l'IA et ce qu'elle décide

Chaque jour, au moins 13 entrées : variations sur 1, 5, 20 et 60 jours, écarts aux moyennes 20, 50 et 200 jours, volatilité, RSI, recul depuis le plus haut d'un an, et sa position actuelle (vendeuse, neutre, acheteuse). Chaque indicateur est divisé par une valeur typique puis borné entre −3 et 3.

const borne = (v) => Math.max(-3, Math.min(3, v));
f[o]     = borne(lr(i, 1) / 0.015);                 // variation sur 1 jour
f[o + 4] = borne((c[i] / moy(20) - 1) / 0.04);      // écart à la moyenne 20 jours
f[o + 8] = borne((rsi - 50) / 25);                  // RSI centré

3 sorties : vendre, rester neutre, acheter ; la plus forte l'emporte. La décision prise à la clôture du jour i s'applique jusqu'à la clôture du lendemain, frais de 0,1 % par changement.

La fitness et le test

g.fitness = Math.log(r.eq) - 0.5 * r.dd;   // gain en logarithme, moins la moitié de la pire chute

La sélection n'utilise que la période d'entraînement. Après chaque génération, la meilleure IA est rejouée sur la période de test, pour information seulement : c'est ce qui fait du test un vrai examen.

Difficultés rencontrées et solutions

La page liste aussi ses simplifications (exécution au cours de clôture, frais fixes, pas de taux de change, chiffres économiques non révisés).

07En plus : Shinobi (Master System)

Un sixième essai, en cours : l'IA apprend un vrai jeu Sega dans l'émulateur stable-retro, à partir de l'image de l'écran. C'est là que les difficultés ont été les plus nombreuses. Page : shinobi.html.

Le principe

• Ce que voit l'IA : l'écran sans la barre du haut, en 44 × 64 cases grises (2 816 entrées).
• Ce qu'elle fait : 5 sorties (droite, gauche, saut, coup, bas), une décision toutes les 4 images.
• Sa note : distance parcourue + score / 10 + 500 par otage sauvé − 200 par barre de vie perdue ; +5 000 pour un niveau fini, plus 300 par barre de vie restante.
• Niveau par niveau : quand le niveau est fini, l'état de l'émulateur est sauvegardé et toute la population continue sur le niveau suivant.

Difficultés rencontrées et solutions

08Leçons communes

Les mêmes problèmes reviennent d'un jeu à l'autre. Les régler une fois a servi pour tous les suivants.