Le programme d'études du projet Shatranj.ai peut être consulté à l'adresse suivante lms.shatranj.ai

Vous trouverez ci-dessous de brefs résumés des thèmes abordés dans le cadre du programme d'études.

Leçon 1 - Champ d'application et priorités du cours

• Présente le projet Shatranj.AI, ses fondations Erasmus+, ses organisations partenaires et ses plateformes numériques.
• Vision du projet, contexte Erasmus KA2
• Institutions partenaires et patrimoine culturel
• Aperçu des plateformes (éditeur, LMS, outils de codage)
• Rôle des enseignants et résultats des élèves
• Vue d'ensemble de la structure du programme d'études
• Introduction à Python/Jupyter

Leçon 2 - Introduction à l'informatique et à la configuration de Python

• Les étudiants apprennent les concepts informatiques de base et installent Python/Jupyter.
• Les bases du CPU, de la RAM et des E/S
• Bits, octets, représentation binaire
• Installation de JupyterLab
• Première exécution d'un notebook Python
• Variables, expressions simples
• Accès aux dossiers du lecteur

Leçon 3 - Types de données Python

• Couvre les types de données intégrés de Python et les opérations de base.
• Entiers, flottants, chaînes de caractères, booléens
• Conversion de type
• Listes et indexation
• Concepts de mutabilité
• Exercices sur les pièces d'échecs en tant que cordes

Leçon 4 - Conditionnelles, boucles, flux de contrôle

• Introduction à la logique, aux boucles et aux programmes interactifs.
• Logique If/elif/else
• Opérations booléennes
• Boucles For/while
• Pause/poursuite
• Programmes de saisie simples

Leçon 5 - Fonctions, portée, paramètres

• Enseigne le code modulaire avec des fonctions.
• Définition des fonctions
• Paramètres et retours
• Champ d'application local/mondial
• Lambdas
• Petit projet fonctionnel (calculateur de valeur à la pièce)

Leçon 6 - Fichiers, exceptions, bibliothèques, tests

• Travailler avec des fichiers et du code robuste.
• Lecture/écriture de fichiers
• Essayer/excepter
• Importer des bibliothèques
• Tests simples
• Traitement des entrées non valides

Leçon 7 - OOP, Classes, TicTacToe

• Première exposition à la POO.
• Classes et objets
• Attributs et méthodes
• Modélisation du jeu
• Mise en œuvre du TicTacToe
• Débogage du code OOP

Leçons 8 - Échecs et représentation de l'échiquier du Shatranj

• Représentations au conseil d'administration pour les échecs et Shatranj
• Coordonner les systèmes et les stratégies d'indexation
• Structures de données internes pour l'état de la carte
• UTF-8 et rendu symbolique des pièces
• Intégration avec les éditeurs de tableaux et les outils de visualisation

Leçons 9 - Mouvement des pièces, mises à jour de l'état du jeu et conditions terminales

• Règles de déplacement des pièces aux échecs et au Shatranj
• Génération de mouvements légaux ou pseudo-légaux
• Mise à jour de l'état du jeu après un déplacement
• Détection des contrôles et des autocontrôles illégaux
• Détection des conditions terminales : échec et mat

Leçon 10 - Problèmes de recherche et parcours de graphes

• Formulation d'un problème de recherche : états, actions, transitions et objectifs
• Graphes et arbres de l'espace-état
• Recherche en profondeur (DFS)
• Recherche en largeur d'abord (BFS)
• Recherche de coûts uniformes (UCS)
• Exercices de traçage de graphiques et de visualisation
• Exemples simples de jeux d'échecs et de grilles

Leçon 11 - Recherche heuristique et arbres de jeux contradictoires

• Fonctions heuristiques et recherche informée
• Recevabilité et cohérence
• Recherche A*
• Recherche contradictoire et arbres de jeu
• Fonctions d'évaluation des états de jeu
• Recherche minimax
• Expectiminimax pour les environnements stochastiques et incertains
• Élagage alpha-bêta et amélioration des performances
• Fonctions d'évaluation des états de jeu
• Exemples contradictoires basés sur les échecs

Leçon 12 - Tour à cheval (Tour du chevalier)

• Exploration de la Tournée du Chevalier avec récursion et heuristique.
• Mouvement du graphe du chevalier
• Visites ouvertes/fermées
• Retour en arrière avec DFS
• Heuristique de Warnsdorff
• Connexion au TSP

Leçon 13 - Puzzle des huit reines

• Satisfaction des contraintes avec backtracking.
• Logique de l'attaque de la reine
• Recherche récursive
• Techniques d'optimisation
• Références historiques sur les reines
• Mise en œuvre de l'ordinateur portable

Leçon 14 - Problème du blé et de l'échiquier

• Puzzles mathématiques et croissance exponentielle.
• Doubler sur l'échiquier
• Puissances de 2
• Casse-tête mobiles du type Mont Fuji utilisés dans les entretiens, casse-tête mathématiques appliqués
• Carrés magiques
• Puzzles logiques de Smullyan
• Problèmes de carreaux de chevalier et autres problèmes de carreaux sur la grille

Leçon 15 - Logique du minimax, de l'alpha-bêta et de l'échec et mat

• Recherche contradictoire profonde et parties finales d'échecs.
• Calcul du minimax
• Taille alpha-bêta
• Opposition, triangulation
• Sources historiques (Al-Adli, Reti)

Leçon 16 - Le diamant de Suli (étude historique de fin de partie)

• Analyse historique des fins de parties d'échecs, bases de données de fins de parties, programmation dynamique, hachage
• Biographie d'Al-Suli
• Reconstruction de la fin de partie
• Opposition et triangulation
• Théorie des carrés correspondants
• Programmation dynamique : solution au dilemme des 1000 ans en C/C++
• Inspection de la solution sur play.shatranj.ai et aussi via notebooks ascii boards

Leçon 17 - Personnaliser Stockfish pour jouer à Shatranj, Rybka-Deep Blue-Stockfish Story

Explore comment les moteurs d'échecs modernes ont évolué et comment les moteurs open-source peuvent être adaptés aux variantes historiques.

• La recherche matérielle par force brute de Deep Blue
• Rybka et l'essor des moteurs centrés sur l'évaluation
• Stockfish, un moteur ouvert, piloté par la communauté
• Comment Stockfish représente les pièces, les mouvements et les règles
• Modification du mouvement de la pièce (ferz, wazir), évaluation, règles de légalité
• Construire une recherche et une évaluation compatibles avec Shatranj

Leçon 18 - Fondements de l'apprentissage par renforcement : Gridworld, programmation dynamique et complexité

Présente l'apprentissage par renforcement (RL) en résolvant un petit monde en grille exactement lorsque les règles sont connues, puis montre pourquoi cette approche “omnisciente” ne fonctionne pas pour les grands jeux tels que les échecs.

• Boucle agent-environnement ; états, actions, récompenses, épisodes ; facteur d'actualisation γ.
• Évaluation de la politique (“robot à la dérive”) et itération des valeurs (“chasseur de trésors”) à l'aide de sauvegardes de Bellman.
• Propagation visuelle de la valeur et dérivation d'une politique optimale à partir de la fonction de valeur.
• La malédiction de la dimensionnalité : complexité de l'espace d'état contre complexité de l'arbre de jeu ; motivation du nombre de Shannon.
• Les “jeux géants” historiques (par exemple, les échecs de Tamerlane, le jeu de Go) comme contexte pour expliquer pourquoi l'apprentissage est nécessaire.

Leçon 19 - La tour gelée : Apprentissage Q tabulaire sur FrozenLake

Passage de la planification à l'apprentissage : l'agent commence sans carte et apprend une politique par essais et erreurs à l'aide de l'apprentissage Q tabulaire.

• Formuler FrozenLake/Frozen Rook comme un MDP : S, A, R, P, états terminaux, γ.
• Règle de mise à jour de l'apprentissage Q et exploration ε-greedy (programme d'exploration→exploitation).
• Former un agent dans le Gymnase FrozenLake ; comparer les transitions déterministes et les transitions glissantes.
• Inspecter ce qui a été appris via les cartes thermiques des tableaux Q / les flèches de politique ; accorder α, γ, ε et les comptes d'épisodes.
• Leçons sur le passage à l'échelle : récompenses éparses, crédit différé et pourquoi les cartes plus grandes sont plus difficiles à jouer.

Leçon 20 - Échec et mat pour deux tours contre un roi seul : L'apprentissage par différence temporelle en pratique

Applique l'apprentissage Q à une petite fin de partie d'échecs et rend la base de code RL “réelle” en séparant le cahier d'expériences des modules d'apprentissage et de formation.

• Apprentissage par différence temporelle (TD) : identification de l'erreur TD dans la mise à jour de l'apprentissage Q ; pourquoi les mises à jour TD pendant le jeu.
• Pourquoi l'apprentissage de Monte Carlo est trop lent pour les jeux d'échecs à récompense différée.
• Pile d'ingénierie : rl.py (Q-memory + TD update), trainer.py (episode loop, exploration schedule), notebook comme laboratoire.
• Coder les positions aux échecs sous forme d'état lisible par la machine (FEN) et former un agent tabulaire sur un espace d'état de fin de partie/puzzle délimité.
• Limites : pourquoi les méthodes tabulaires échouent pour les échecs complets (malédiction de la dimensionnalité) et la nécessité d'une approximation de la fonction.

Leçon 21 - Réseaux Q profonds : Des tables Q aux réseaux neuronaux

Introduit l'approximation de fonction pour RL en remplaçant la table Q par un réseau neuronal (DQN) et en l'appliquant à plusieurs petits jeux de société.

• Pourquoi les tables Q ne sont pas évolutives : trop d'états ; la généralisation nécessite un modèle capable de “deviner” des valeurs pour des positions non vues.
• Boucle d'apprentissage du Deep Q-Network (DQN) : tampon de relecture, réseau cible, mises à jour par mini-lots, ε-decay.
• Mettre en œuvre et expérimenter le DQN sur des jeux tels que Connect-4 (4Connect), Fox & Hounds, et Othello/Reversi.
• Diagnostics : courbes d'apprentissage, problèmes de stabilité (surestimation, divergence) et solutions pratiques.
• Comparer les approches : DQN contre évaluation de type NNUE et évaluation artisanale (HCE) pour discuter des compromis en matière d'architecture.

Leçon 22 - Les déploiements Monte Carlo et les SCTM sur Qirkat

Construit un environnement Qirkat complet, puis passe de déploiements aléatoires à une recherche arborescente Monte Carlo (MCTS) complète avec sélection UCT.

• Mettre en œuvre les règles de Qirkat backbone (plateau 5×5, C3 vide) et la règle de capture maximale qui impose des séquences de capture.
• Génération de mouvements qui énumère les lignes de capture, applique la capture obligatoire et filtre les captures de longueur maximale.
• Lignes de base Monte Carlo : déploiements aléatoires et évaluation des mouvements Monte Carlo à plat avant l'ajout de la réutilisation des arbres.
• Pipeline des SCTM : sélection, expansion, déploiement/évaluation, rétropropagation ; choix du mouvement final en fonction de l'UCT/du nombre de visites.
• Des journaux de jeu reproductibles et des outils d'audit pour une lecture étape par étape et un débogage.

Leçon 23 - AlphaZero sur Othello/Reversi

Amélioration des SCTM en recherche de type AlphaZero par l'ajout d'un réseau neuronal qui fournit une politique préalable et une estimation de la valeur, puis s'entraîne par auto-apprentissage.

• Faites le lien entre l'intuition et une minuscule démo AlphaZero ‘Connect2’, puis transférez les idées à Othello.
• Remplacer UCT par PUCT : combiner les statistiques de visite avec une politique apprise avant l'exploration du guide.
• Têtes de réseau neuronal : la politique (probabilités de mouvement) et la valeur (évaluation de la position) sont utilisées à la place des déroulements aléatoires.
• Boucle AlphaZero : auto-jeu → cibles d'entraînement (π, z) → mise à jour du réseau → répétition ; évaluation par le biais de tournois/logs.
• Codage des déplacements en fonction du chemin pour les séquences de capture de longueur variable, de sorte que les différents chemins de capture restent distincts.

Leçon 24 - AlphaZero sur Qirkat : PUCT, Policy/Value Nets, et Self-Play

Amélioration des SCTM en recherche de type AlphaZero par l'ajout d'un réseau neuronal qui fournit une politique préalable et une estimation de la valeur, puis s'entraîne par auto-apprentissage.

• Faites le lien entre l'intuition et une minuscule démo AlphaZero ‘Connect2’, puis transférez les idées à Qirkat.
• Remplacer UCT par PUCT : combiner les statistiques de visite avec une politique apprise avant l'exploration du guide.
• Têtes de réseau neuronal : la politique (probabilités de mouvement) et la valeur (évaluation de la position) sont utilisées à la place des déroulements aléatoires.
• Boucle AlphaZero : auto-jeu → cibles d'entraînement (π, z) → mise à jour du réseau → répétition ; évaluation par le biais de tournois/logs.
• Codage des déplacements en fonction du chemin pour les séquences de capture de longueur variable, de sorte que les différents chemins de capture restent distincts.

Leçon 25 - Dames turques (Dama) :

Alpha-Beta, MCTS guidés par le PUCT, Alpha Zero

Mise en œuvre de Turkish Checkers et comparaison de la recherche classique (alpha-bêta) avec MCTS à l'aide d'un moteur de recherche réutilisable et de journaux de simulation par lots.

• Moteur de jeu : représentation du plateau, mouvements légaux avec captures multi-sauts et encodage du chemin de déplacement.
• Fonction d'évaluation et agent de recherche Negamax/Alpha-Beta ; compromis entre la profondeur et la force.
• Agent MCTS pour le jeu de dames turc et comparaisons directes avec alpha-beta.
• Utilitaires universels de simulation de match (play_game) et de simulation par lots pour des expériences reproductibles.
• Journaux exportables (zippés) pour l'examen en classe et le débogage.