Add: 9 lectures chiffrees RL-7 multi-agent (densite 748 -> 1298, #13410)

MyIA.AI.Notebooks/RL/rl_7_multi_agent_rl.ipynb

@@ -137,6 +137,14 @@
     "print(\"PettingZoo charge avec succes\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "644c4588",
+   "metadata": {},
+   "source": [
+    "**Lecture de la sortie — le double check d'import.** Les deux cellules d'installation rendent la meme ligne, `PettingZoo charge avec succes`, et c'est tout l'objet du passage : verifier que la librairie multi-agent est presente AVANT de construire dessus. Le geste est applique deux fois, et un echec doit s'arreter ici, pas au milieu d'un entrainement de 20 000 episodes. Tout ce qui suit — API AEC, TicTacToe, IQL — suppose cette ligne acquise.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "m4e5e005",
@@ -232,6 +240,14 @@
     "print(f\"Espaces d'obs     : {env.observation_space(env.possible_agents[0])}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "6bd75d12",
+   "metadata": {},
+   "source": [
+    "**Lecture chiffree — les agents et leurs espaces, ligne par ligne.** La sortie enumere ce que la presentation de la librairie ne listait pas : `Agents possibles : ['player_1', 'player_2']` (deux agents nommes, pas des indices), `Agent actuel : player_1` (le cycle AEC designe QUI doit jouer — c'est la difference structurante avec Gymnasium ou l'agent est unique), puis `Espaces d'action : Discrete(9)` (neuf cases, un choix parmi neuf) et l'espace d'observation complet en un bloc : `Dict('action_mask': Box(0, 1, (9,), int8), 'observation': Box(0, 1, (3, 3, 2), int8))`. Le dictionnaire dit l'architecture : observation et masque d'action voyagent ENSEMBLE, chaque agent recevant la meme structure. La cellule suivante detaille le tenseur (3, 3, 2) case par case.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "m7h8e008",
@@ -315,6 +331,22 @@
     "print(f\"Terminaisons        : {env.terminations}\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "de29bcf1",
+   "metadata": {},
+   "source": [
+    "**Lecture chiffree — une partie aleatoire, lue sur la grille.** La sortie affiche la grille finale :\n",
+    "\n",
+    "```\n",
+    "O X O\n",
+    ". O X\n",
+    "X X O\n",
+    "```\n",
+    "\n",
+    "avec `Recompenses finales : {'player_1': -1, 'player_2': 1}` et les deux `Terminaisons` a `True`. La grille se lit position par position (0 en haut a gauche, 8 en bas a droite) : O occupe 0, 2, 4 et 8 — la grande diagonale (0, 0), (1, 1), (2, 2), positions 0, 4 et 8, toutes trois a O. C'est exactement ce que chiffrent les recompenses : O (player_2) prend +1, X (player_1) encaisse -1, et les deux agents terminent ensemble — dans l'API AEC, la fin de partie est un dictionnaire par agent, pas un signal global unique.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "m9j0e010",
@@ -669,6 +701,14 @@
     "agents, history = train_iql(num_episodes=20000)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "6192f992",
+   "metadata": {},
+   "source": [
+    "**Lecture chiffree — le calendrier d'exploration et l'effondrement de O.** Les quatre lignes d'entrainement se lisent d'abord par leur derniere colonne : `eps: 0.607`, puis `0.368`, `0.223`, `0.135`. Ce calendrier est deterministe — pure fonction du nombre d'episodes — et chaque palier de 5 000 episodes abaisse le taux d'exploration, donc le nombre de coups aleatoires offerts a l'adversaire. Deuxieme lecture, celle qu'aucun chiffre du paragraphe suivant ne resume : sur CE run, la colonne O recule de checkpoint en checkpoint, sans rebond, pendant que X termine nettement plus haut que son creux de mi-parcours — et les nuls varient eux dans les deux sens. Les trois colonnes somment a 100 a chaque ligne (jeu a somme nulle), mais leur repartition est une realisation stochastique : l'entrainement n'est pas seede, et affirmer que le recul de O est systematique — ou le miroir exact de la progression de X — exigerait de repeter l'entrainement sur plusieurs seeds.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "n6q7e017",
@@ -878,6 +918,14 @@
     "evaluate_against_random('player_2', agents, num_games=1000)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "49ca7299",
+   "metadata": {},
+   "source": [
+    "**Lecture chiffree — l'evaluation chiffree contre l'aleatoire.** Les deux blocs evaluent chaque agent entraine, en politique greedy, contre un joueur aleatoire sur 1 000 parties. Trois lectures : les DEUX agents ecrasent l'aleatoire — de l'ordre de neuf victoires sur dix pour player_1 et sept sur dix pour player_2 sur ce run — l'apprentissage a eu lieu des deux cotes ; l'ecart entre les deux taux est net, mais un run unique ne separe pas ce qui revient a l'avantage structurel du premier joueur au morpion de ce que la position change a l'apprentissage (les deux agents ont suivi le meme entrainement, seule la position differe) — quantifier chaque effet exigerait plusieurs entrainements et evaluations seedes ; enfin le tuple final rendu par la cellule est le decompte brut de player_2 : trois entiers qui somment au nombre de parties jouees — la sortie verifie elle-meme la coherence entre les taux affiches et les comptes bruts.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "o1v2e022",
@@ -1005,6 +1053,22 @@
     "play_and_display(agents)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "2ea556a9",
+   "metadata": {},
+   "source": [
+    "**Lecture chiffree — la partie gagnee, coup par coup.** La sortie trace les sept coups puis la grille finale :\n",
+    "\n",
+    "```\n",
+    "X O X\n",
+    "O X O\n",
+    "X . .\n",
+    "```\n",
+    "\n",
+    "avec `Resultat : X gagne`. X occupe les positions 0, 2, 4 et 6 — et l'anti-diagonale (0, 2), (1, 1), (2, 0) est completee par le `Coup 7 : X joue en position 6`. La geometrie du denouement se lit avant le coup 7 : apres le coup 5 (X en position 4), X tient DEUX menaces simultanees — la grande diagonale (0, 4, 8) et l'anti-diagonale (2, 4, 6). Un seul coup de blocage ne peut fermer les deux ; le coup 6 de O (position 5) n'en ferme aucune, et X convertit la menace anti-diagonale au coup suivant. C'est un fork : la partie est gagnee au coup 5, quand la double menace se forme — le coup 7 ne fait que l'encaisser. A comparer avec la partie aleatoire du §2, ou personne ne construisait de double menace.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "o4y5e025",
@@ -1081,6 +1145,14 @@
     "print(\"Exercice a completer : Connect Four multi-agent\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "c88eda44",
+   "metadata": {},
+   "source": [
+    "**Lire la sortie d'un exercice non rempli.** « Exercice a completer : Connect Four multi-agent » — le contrat, pose dans l'enonce ci-dessus : adapter l'IQL a `connect_four_v3`, ou l'espace d'etat passe de 3^9 a 3^42 configurations — un facteur 3^33 entre les deux. Le terrain est deja la : l'encodage d'observation du §4, l'IQLAgent, la boucle `train_iql` — seuls l'encodage et les parametres changent. La question de lecture quand la sortie sera remplie : ce que devient le taux de victoire quand la table Q dictionnaire (initialisation paresseuse : seuls les etats VISITES sont stockes) doit couvrir un espace des etats 3^33 fois plus grand — l'apprentissage tabulaire atteint-il encore la convergence sur un budget d'episodes raisonnable, ou le goulot deplace-t-il du cote de la couverture d'etats ?\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -1120,6 +1192,14 @@
     "print(\"Exercice a completer : self-play avec versions passees\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "96894292",
+   "metadata": {},
+   "source": [
+    "**Lire la sortie d'un exercice non rempli.** « Exercice a completer : self-play avec versions passees » — le contrat : toutes les N episodes, sauvegarder une copie de la table Q et tirer l'adversaire au hasard parmi ces versions gelees, au lieu de l'adversaire en cours d'apprentissage. Le terrain : la boucle `train_iql` du §5 ou les deux agents evoluent SIMULTANEMENT — precisement la source de non-stationnarite que le §3 listait comme defi numero un. La question de lecture quand la sortie sera remplie : la courbe de O remonte-t-elle quand son adversaire cesse de changer sous ses pas ? C'est la difference entre apprendre contre un environnement mouvant et apprendre contre un curriculum d'adversaires figes, chacun plus fort que le precedent.\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 12,
@@ -1159,6 +1239,14 @@
     "print(\"Exercice a completer : reward shaping\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "d06ca6cb",
+   "metadata": {},
+   "source": [
+    "**Lire la sortie d'un exercice non rempli.** « Exercice a completer : reward shaping » — le contrat : ajouter des recompenses intermediaires (pion central, ligne de 2, blocage adverse) aux +1/-1/0 de fin de partie. Le terrain : le schema de recompenses du §2, la table Q du §4, la boucle du §5. La question de lecture quand la sortie sera remplie tient en une tension : le shaping densifie le signal (un retour a CHAQUE coup au lieu d'un seul en fin de partie) mais peut detourner l'objectif — un agent qui apprend a empiler des lignes de 2 sans les convertir en victoires aura un score intermediaire eleve et un taux de victoire plat. Les deux courbes, score shape et taux de victoire, se liront ENSEMBLE : si elles divergent, le biais du shaping est mesure, pas devine.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "e2d0059d",