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émos
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 de 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
Neurones : reçoivent des données, les traitent/transforment, puis en transmettant le résultat aux neurones suivants, etc, pour finalement produire une réponse ou une décision.
Architecture actor-critic - avantages
Réduit la variance (instabilité)
Le Critic évalue rapidement les actions plutôt qu'à la fin (recette de cuisine par ex)
A l'inverse, apprendre avec une variance forte revient à n'apprendre qu'à la fin de la recette (avis des invités)
Meilleure exploration
Implémentation et défis rencontrés
Implémentation et défis rencontrés
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)
🎮 Le réseau Actor (le joueur)
~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
Orientation → 3 entrées
🎮 Le réseau Actor (le joueur)
~62k paramètres
Implémentation et défis rencontrés
Couche 1 : 256 neurones
Capture des patterns complexes et des interactions entre les 110 dimensions d'entrée
Couche 2 : 128 neurones
Raffine et combine ces patterns pour les sorties spécifiques
🎮 Le réseau Actor (le joueur)
~62k paramètres
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 neurones
Bon compromis entre capacité d'apprentissage et efficacité computationnelle pour un jeu avec actions continues.
Implémentation et défis rencontrés
7 sorties spécialisées pour les actions continues :
- rotation (direction et valeur)
- translation (direction et valeur)
- force du lancer
- inclinaison du palet (2 axes)
🎮 Le réseau Actor (le joueur)
Implémentation et défis rencontrés
🧠 Le réseau Critic (le coach)
1 sortie :
É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 via objet global window
- 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 → surapprentissage
- 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 (entrée/sorties du réseau neuronal vers les vraies valeurs du jeu (degrés, vitesse, distance)
rotation: -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
Implémentation et défis rencontrés
Démos
Bilan & perspectives
Bilan et perspectives
L'Actor-Critic fonctionne bien pour les actions continues
Importance du monitoring et des métriques
La patience nécessaire pour l'entraînement
L'IA peut découvrir des stratégies inattendues
Apprentissage du mode traditionnel
Stratégies de jeu / lancer + placement du palet
Conseils
Keep It Simple Stupid - Bon sens paysan - Pragmatic Driven Development
Commencer simple, complexifier progressivement
Prototyper et valider votre idée/gameplay "le plus tôt possible"
Ressources
Série Rematch
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.
