Conception
d'une IA de jeu vidéo
avec l'apprentissage par renforcement
Vincent Ogloblinsky - @vogloblinsky
Vincent Ogloblinsky
Compodoc maintainer
Architecte logiciel web
Indie hacker on side-projects
Agenda
1.
L'IA dans les jeux vidéos/recherche
2.
Apprentissage par renforcement
3.
Architecture actor-critic
4.
Implémentation & défis rencontrés
5.
Démo
6.
Bilan & perspectives
L'IA
dans les
jeux vidéos / recherche
L'IA dans les jeux vidéos / recherche
PACMAN - 1980
Premiers patterns fixes d'IA pour les 3 fantômes
Illusion d'intelligence et de personnalité distincte
L'IA dans les jeux vidéos / recherche
DOOM - 1993
Des ennemis réactifs et stratégiques, simulant une intelligence pour rendre chaque affrontement imprévisible.
L'IA dans les jeux vidéos / recherche
LES SIMS - 2000
Une IA basée sur des besoins et émotions qui donne l'illusion d'une personnalité autonome.
L'IA dans les jeux vidéos / recherche
CIVILIZATION VI - 2010
L'IA utilise des stratégies adaptatives et des comportements complexes pour simuler des leaders humains crédibles et imprévisibles.
L'IA dans les jeux vidéos / recherche
DEEP BLUE - 1997
L'IA utilise une recherche exhaustive et des heuristiques pour simuler une intelligence stratégique dans la partie d’échecs.
L'IA dans les jeux vidéos / recherche
AlphaGo - 2016
Combine l'apprentissage par renforcement et les réseaux neuronaux pour simuler une intuition stratégique et imprévisible dans le jeu de go.
L'IA dans les jeux vidéos / recherche
AlphaStart - 2019
Utilise l'apprentissage par renforcement et la simulation pour adopter des stratégies complexes et adaptatives dans StarCraft II.
Apprentissage par renforcement
Apprentissage par renforcement - What
L'IA explore son environnement
Elle teste différentes actions
Elle reçoit des récompenses (positives ou négatives)
Elle s'améliore en maximisant les récompenses
Apprentissage par renforcement - Why
❌ Pas de dataset d'entraînement existant
❌ Règles complexes difficiles à programmer
❌ Actions continues (pas de boutons discrets)
✅ L'IA doit apprendre par l'expérience
Apprentissage par renforcement - Where
Jeu local (solo vs IA), multijoueur local ou online
Mode jeu classique ou cible
Apprentissage par renforcement - Where
Mode cible : Viser des zones de score sur la planche
Actions continues (force, direction, rotation)
Apprentissage par renforcement - Where
Physique complexe avec collisions
6 palets par joueur, premier à 70 gagne
Actions discrètes (classiques) :
Choix parmi un ensemble fini : ↑ ↓ A B
Exemples : déplacements sur grille, boutons de manette
Apprentissage par renforcement - Where
Actions continues (notre défi) :
Valeurs dans un intervalle infini : force ∈ [1, 6]
Exemples : angle de tir, intensité, rotation précise
Du simple au complexe
Mode cible : Maximiser les points individuels
Apprentissage par renforcement - Finalité
Mode traditionnel : Placer ses palets près du "maître"
Architecture actor-critic
Architecture actor-critic
2 familles d'apprentissage par renforcement :
Policy-based : apprendre directement la stratégie optimale
Value-based : apprendre directement la valeur des états/actions
Architecture actor-critic
Deux réseaux de neurones qui collaborent
Actor : Décide des actions à prendre
Critic : Évalue la qualité des décisions
Architecture actor-critic
Réseau de neurones : système informatique inspiré du cerveau humain, composé de plusieurs couches de petits éléments appelés neurones
Ces neurones traitent des informations en recevant des données, en les transformant, puis en transmettant le résultat aux neurones suivants, pour finalement produire une réponse ou une décision.
Architecture actor-critic
Réduit la variance (instabilité)
Critic évalue rapidement les actions plutôt qu'à la fin (recette de cuisine par ex)
L'inverse, apprendre avec une variance forte revient à n'apprendre qu'à la fin de la recette (avis des invités)
Implémentation et défis rencontrés
Implémentation et défis rencontrés
🎮 Le réseau Actor (Le Joueur)
Entrées : état du jeu encodé sur 110 dimensions :
- type de planche
- type de palet
- rôle, position, score et status de chaque palet
2 couches cachées :
- Couche 1 : 256 neurones
- Couche 2 : 128 neurones
7 sorties spécialisées pour les actions continues :
- rotation (direction et intensité)
- translation (direction et intensité)
- force du lancer
- inclinaison du palet (2 axes)
~62k paramètres
Implémentation et défis rencontrés
🎮 Le réseau Actor (Le Joueur)
110 entrées
2 couches cachées
7 sorties
~62k paramètres
Implémentation et défis rencontrés
Entrées :
Etat du jeu encodé sur 110 dimensions
Type de palet actuel → 1 entrée
Type de planche → 1 entrée
États des 12 palets : 108 entrées
Status → 1 entrée
Rôle du palet actuel → 1 entrée
Score → 1 entrée
Position → 3 entrées
Orientations → 3 entrées
🎮 Le réseau Actor (Le Joueur)
~62k paramètres
Implémentation et défis rencontrés
🎮 Le réseau Actor (Le Joueur)
Couche 1 : 256 neurones
Capture des patterns complexes et des interactions entre les 15 dimensions d'entrée
Couche 2 : 128 neurones
Raffine et combine ces patterns pour les sorties spécifiques
Implémentation et défis rencontrés
7 sorties spécialisées pour les actions continues :
- rotation (direction et intensité)
- translation (direction et intensité)
- force du lancer
- inclinaison du palet (2 axes)
🎮 Le réseau Actor (Le Joueur)
Implémentation et défis rencontrés
🎮 Le réseau Actor (Le Joueur)
Avec 110 dimensions d'entrée, l'espace des états est relativement complexe :
Sous-dimensionnement (ex: 32-64 neurones) → Risque de sous-apprentissage
Sur-dimensionnement (ex: 512-1024 neurones) → Risque de surapprentissage
PPO (Proximal Policy Optimization) : souvent 64-256 neurones
A3C (Actor-Critic) : typiquement 128-512 neurones
DDPG : architectures similaires 256-128
Bon compromis entre capacité d'apprentissage et efficacité computationnelle pour un jeu avec actions continues.
Implémentation et défis rencontrés
🧠 Le réseau Critic (Le Coach)
1 sortie spécialisée :
Évalue la qualité d'un état donné pour guider l'apprentissage de l'Actor.
Total : ~61k paramètres
110 entrées
2 couches cachées
Implémentation et défis rencontrés
Babylon.js (3D)
Rapier.js (Physique)
Jeu
TypeScript
Playwright
contrôle navigateur
Tensorflow.js
IA Actor-critic
Hooks mis à disposition pour la couche supérieure
- récupération état du jeu
- pilotage des actions (lancer, rotation etc)
Script global pilotant Playwright et Tensorflow.js
Implémentation et défis rencontrés
Cycle d'apprentissage :
1. État initial → l'Actor choisit les actions (translation, rotation, etc)
2. Exécution dans le jeu (9s d'attente - physique)
3. Récompense calculée
4. Critic évalue la qualité
5. Mise à jour des réseaux
6. Répéter...
Implémentation et défis rencontrés
export interface GameState {
mode: string;
players: Player[];
type: string;
planche: Planche;
}export type PlancheType = 'BOIS' | 'PLOMB';
export interface Planche {
type: PlancheType;
position: Position;
}export interface Player {
palets: Palet[];
}export type PaletType = 'FONTE' | 'LAITON';
export type PaletStatus = 'ALANCER' | 'VALID' | 'INVALID';
export type PaletRole = 'MAIN' | 'NORMAL';
export interface Palet {
type: PaletType;
role: PaletRole;
status: PaletStatus;
position: Position;
score: number;
}Implémentation et défis rencontrés
Obstacles :
🎯 Actions continues
- Plus complexe que des actions discrètes
- Espace d'exploration immense
⚖️ Équilibrage exploration/exploitation
- Trop d'exploration → pas d'apprentissage
- Pas assez → stratégies sous-optimales
🎲 Non-déterminisme physique
- Collisions entre palets imprévisibles
- Même action ≠ même résultat
Implémentation et défis rencontrés
Solutions
🎯 Normalisation des actions (sorties du réseau neuronal vers les vraies valeurs du jeu (degrés, vitesse, distance)
rotation: tanh(-1 à 1) → (0 à 200)
📊 Métriques détaillées
- Logs JSON + TensorBoard
- Suivi épisode par épisode et lancer par lancer
🔄 Entraînement progressif
- Checkpoints réguliers
- Sauvegarde/rechargement des modèles
Implémentation et défis rencontrés
Démo
Bilan & perspectives
Bilan & perspectives
L'Actor-Critic fonctionne bien pour les actions continues
L'importance du monitoring et des métriques
La patience nécessaire pour l'entraînement
Commencer simple, complexifier progressivement
L'IA peut découvrir des stratégies inattendues
Bilan & perspectives
Keep It Simple Stupid - Bon sens paysan - Pragmatic Driven Development
Apprentissage du mode traditionnel
Ressources
Merci pour votre attention !
Des questions ?
Slides : https://bit.ly/42ZSJ01
Crédit photos - Unsplash.com
Feedback
Conception d'une IA de jeu vidéo avec l'apprentissage par renforcement
By Vincent Ogloblinsky
Conception d'une IA de jeu vidéo avec l'apprentissage par renforcement
Dans ce talk, venez découvrir la conception d'une intelligence artificielle capable de jouer à un jeu vidéo de palet "fonte/laiton sur planche bois/plomb" grâce à l'apprentissage par renforcement. Je vous emmènerai dans les coulisses de ce projet où j'ai implémenté une architecture Actor-Critic - deux réseaux de neurones collaborant comme un joueur et son coach personnel. Cette approche m'a permis de créer une IA capable d'apprendre des stratégies complexes pour un jeu en tour par tour impliquant des actions continues (force, direction, rotation) tout en maintenant un apprentissage stable. Nous explorerons: les fondamentaux de l'apprentissage par renforcement appliqués aux jeux vidéo pourquoi l'architecture Actor-Critic est idéale pour les jeux à actions continues l'implémentation technique avec TensorFlow.js et Playwright pour l'automatisation les défis rencontrés lors de l'entraînement de l'IA les résultats obtenus, l'intégration dans le jeu final et les leçons apprises Cette session s'adresse aux développeurs curieux d'explorer l'IA dans les jeux vidéo, avec des démonstrations concrètes et des conseils pratiques pour implémenter vos propres solutions d'apprentissage par renforcement.
