🎮 Q-Learning — Quand l'IA apprend à coups d'essais-erreurs ! 🤖💥
📖 Définition
Q-Learning = apprendre en se prenant des murs jusqu'à trouver le bon chemin ! Comme un rat dans un labyrinthe qui apprend qu'aller à gauche = récompense, aller à droite = décharge électrique. Après 1000 essais, il connaît le chemin parfait !
Principe :
- Reinforcement Learning : apprend par récompenses/punitions
- Q-Table : tableau qui note chaque action dans chaque situation
- Exploration vs Exploitation : essayer du nouveau vs répéter ce qui marche
- Bellman equation : mise à jour intelligente des valeurs
- Pas besoin de labels : l'agent découvre tout seul ! 🧠
⚡ Avantages / Inconvénients / Limites
✅ Avantages
- Apprentissage autonome : pas besoin d'exemples étiquetés
- Optimise sur le long terme : pas juste la prochaine action
- Model-free : pas besoin de connaître les règles du jeu
- Convergence garantie : trouve la solution optimale (si bien paramétré)
- Conceptuellement simple : juste un tableau à remplir
❌ Inconvénients
- Curse of dimensionality : explose avec beaucoup d'états/actions
- Exploration coûteuse : doit essayer TOUTES les possibilités
- Convergence lente : des milliers d'itérations nécessaires
- Q-table énorme : impraticable pour problèmes complexes
- Pas de généralisation : apprend par cœur chaque situation
⚠️ Limites
- États continus impossibles : position exacte = infini de valeurs
- Ne scale pas : Chess/Go = 10^120 états (RIP la mémoire)
- Oublie l'ancien : peut désapprendre ce qu'il savait
- Sensible aux paramètres : mauvais learning rate = désastre
- Remplacé par Deep Q-Learning : Q-table → neural network
🛠️ Tutorial pratique : Mon cas réel
📊 Setup
- Environnement : Frozen Lake 4x4 (OpenAI Gym)
- États : 16 cases (grille 4x4)
- Actions : 4 (haut, bas, gauche, droite)
- Config : 10000 épisodes, alpha=0.1, gamma=0.99, epsilon=0.1
- Hardware : CPU suffit (Q-Learning = léger)
📈 Résultats obtenus
Random agent (baseline):
- Win rate: 1.2% (juste de la chance)
- Moyenne steps: 50+ (tourne en rond)
- Aucune stratégie
Q-Learning après 1000 épisodes:
- Win rate: 45% (apprend!)
- Q-table partiellement remplie
- Évite certains trous
Q-Learning après 5000 épisodes:
- Win rate: 72% (bon agent)
- Q-table bien optimisée
- Chemin quasi-optimal
Q-Learning après 10000 épisodes:
- Win rate: 78% (excellent!)
- Convergence atteinte
- Stratégie stable
🧪 Test en conditions réelles
Environnement simple (Frozen Lake 4x4):
- États: 16 cases
- Q-table size: 16 × 4 = 64 valeurs
- Training time: 2 minutes
- Performance: 78% win rate ✅
Environnement moyen (Frozen Lake 8x8):
- États: 64 cases
- Q-table size: 64 × 4 = 256 valeurs
- Training time: 15 minutes
- Performance: 65% win rate ✅
Environnement complexe (CartPole):
- États: Continus (position, vitesse, angle)
- Q-table size: IMPOSSIBLE (infini)
- Solution: Discrétisation ou Deep Q-Learning
- Q-Learning vanilla: ❌ (ne marche pas)
Verdict : 🎯 Q-LEARNING = SUPER POUR PROBLÈMES SIMPLES
💡 Exemples concrets
Comment fonctionne Q-Learning
Imagine apprendre à jouer au Pac-Man sans connaître les règles :
Épisode 1: Aller vers fantôme
→ MORT (-100 points)
→ Q-table: "État(près fantôme) + Action(vers fantôme)" = -100
Épisode 2: Fuir fantôme
→ SURVIE (+1 point)
→ Q-table: "État(près fantôme) + Action(fuir)" = +1
Épisode 50: L'agent a compris
→ Près fantôme = TOUJOURS fuir
→ Voir pac-gomme = y aller
→ Q-table contient la stratégie optimale !
La Q-Table expliquée
C'est un tableau géant qui note chaque combinaison état-action :
↑ ↓ ← →
Case_1 0.5 0.2 -1.0 0.8 ← Meilleure action: droite (0.8)
Case_2 -0.3 0.9 0.1 0.4 ← Meilleure action: bas (0.9)
Case_3 0.0 0.0 0.0 0.0 ← Pas encore exploré
...
Mise à jour Q-value (équation de Bellman) :
Q(état, action) = Q(état, action) + α × [récompense + γ × max(Q(état_suivant)) - Q(état, action)]
α (learning rate): 0.1 = apprend lentement
γ (discount): 0.99 = récompenses futures importantes
Applications réelles
Jeux simples 🎮
- Tic-Tac-Toe, Connect-4
- Grid World, Frozen Lake
- Pac-Man simplifié
Robotique basique 🤖
- Navigation dans labyrinthe
- Contrôle bras robotique simple
- Équilibrage (avec discrétisation)
Optimisation 📊
- Gestion ressources simples
- Routage réseau basique
- Ordonnancement tâches
Pourquoi pas Chess/Go ? ❌
- Chess: 10^120 positions possibles
- Q-table: mémoire requise = 10^120 × 4 × 8 bytes = IMPOSSIBLE
- Solution: Deep Q-Learning (DQN) ou AlphaZero
📋 Fiche mémo : Q-Learning
🔍 Composants essentiels
Q-Table 📊
- Lignes = États possibles
- Colonnes = Actions possibles
- Valeurs = Qualité état-action (Q-value)
- Initialisée à 0 (ou random)
Exploration vs Exploitation 🎲
- Epsilon-greedy: avec probabilité ε, action aléatoire
- ε = 0.1 : 10% exploration, 90% exploitation
- Decay: ε diminue avec le temps (explore au début, exploite à la fin)
Hyperparamètres critiques ⚙️
- Alpha (α): learning rate (0.01-0.5)
- Gamma (γ): discount factor (0.9-0.99)
- Epsilon (ε): exploration rate (0.01-0.3)
🛠️ Algorithme simplifié
1. Initialiser Q-table à 0
2. Pour chaque épisode:
a. État = état_initial
b. Tant que pas terminé:
- Choisir action (epsilon-greedy)
- Exécuter action
- Observer récompense + nouvel_état
- Mettre à jour Q(état, action)
- État = nouvel_état
3. Répéter jusqu'à convergence
⚙️ Quand utiliser Q-Learning
✅ États discrets et peu nombreux (<1000)
✅ Actions discrètes et peu nombreuses (<10)
✅ Environnement déterministe ou peu stochastique
✅ Problème simple avec feedback clair
✅ Pas de contrainte temps/mémoire
❌ États continus (position, vitesse)
❌ Énorme espace d'états (Chess, Go, Atari)
❌ Actions continues (angle exact, force)
❌ Besoin de généralisation
❌ Production moderne (use Deep RL)
💻 Concept simplifié (code minimal)
# Q-Learning en pseudocode ultra-simple
class QLearning:
def __init__(self, num_states, num_actions):
# La fameuse Q-table !
self.Q = [[0 for _ in range(num_actions)]
for _ in range(num_states)]
self.alpha = 0.1 # Learning rate
self.gamma = 0.99 # Discount factor
self.epsilon = 0.1 # Exploration rate
def choose_action(self, state):
"""Epsilon-greedy: explore ou exploite"""
if random() < self.epsilon:
return random_action() # Explore
else:
return argmax(self.Q[state]) # Exploite
def learn(self, state, action, reward, next_state):
"""Mise à jour Q-value avec équation de Bellman"""
# Meilleure action possible dans l'état suivant
best_next = max(self.Q[next_state])
# Calcul de la "cible"
target = reward + self.gamma * best_next
# Mise à jour Q-value (learning)
self.Q[state][action] += self.alpha * (target - self.Q[state][action])
def train(self, env, episodes):
"""Entraînement complet"""
for episode in range(episodes):
state = env.reset()
done = False
while not done:
# Choisir et exécuter action
action = self.choose_action(state)
next_state, reward, done = env.step(action)
# Apprendre de l'expérience
self.learn(state, action, reward, next_state)
state = next_state
# La magie: après 10000 épisodes, la Q-table contient la stratégie optimale !
# L'agent sait quelle action faire dans chaque situation
Le concept clé : Q-Learning remplit progressivement une table qui associe à chaque (état, action) une valeur de "qualité". Après assez d'essais, l'agent connaît la meilleure action pour chaque situation ! 🎯
📝 Résumé
Q-Learning = apprentissage par essais-erreurs avec une Q-table qui stocke la qualité de chaque action dans chaque état. Exploration puis exploitation pour trouver la stratégie optimale. Super pour problèmes simples (petits états/actions) mais explose sur problèmes complexes (→ utilisez Deep Q-Learning). Pas besoin de labels, l'agent apprend juste avec récompenses/punitions ! 🎮✨
🎯 Conclusion
Q-Learning a révolutionné le Reinforcement Learning dans les années 90 en prouvant qu'un agent peut apprendre sans supervision juste avec des récompenses. Simple conceptuellement (juste un tableau à remplir) mais limité par la curse of dimensionality. Aujourd'hui remplacé par Deep Q-Learning (DQN) pour problèmes complexes, mais reste essentiel pédagogiquement et utile pour problèmes simples. De Q-Learning est né AlphaGo, AlphaZero, et tous les agents RL modernes. L'ancêtre qui a tout lancé ! 🚀🏆
❓ Questions/Réponses
Q : Mon agent Q-Learning tourne en rond et apprend rien, pourquoi ? R : Plusieurs causes possibles : (1) Epsilon trop bas = pas assez d'exploration, (2) Learning rate trop faible = apprend trop lentement, (3) Récompenses mal définies = pas de signal clair. Essaie epsilon=0.2, alpha=0.1, et vérifie que les récompenses sont bien différenciées !
Q : Combien d'épisodes faut-il pour que ça converge ? R : Dépend totalement du problème ! Frozen Lake 4x4 : 5000-10000 épisodes. Labyrinthe 10x10 : 50000+ épisodes. Plus l'espace d'états est grand, plus ça prend de temps. Si après 100k épisodes ça converge pas, ton problème est trop complexe pour Q-Learning vanilla !
Q : Je peux utiliser Q-Learning pour Atari / Chess / jeux complexes ? R : Non, utilise Deep Q-Learning (DQN) ! Q-Learning vanilla nécessite une Q-table qui tient en mémoire. Atari : millions d'états = impossible. Chess : 10^120 états = RIP. DQN remplace la Q-table par un neural network qui apprend à approximer les Q-values. C'est ça que DeepMind a utilisé pour Atari !
🤓 Le saviez-vous ?
Q-Learning a été inventé par Chris Watkins en 1989 dans sa thèse de PhD ! Pendant 25 ans, c'est resté un truc théorique peu utilisé car trop limité (curse of dimensionality). Puis en 2013, DeepMind a créé Deep Q-Network (DQN) en combinant Q-Learning avec des neural networks, et BAM : leur agent a appris à jouer à 49 jeux Atari au niveau humain ! La révolution est venue quand ils ont montré la vidéo de l'agent jouant à Breakout : au début il est nul, puis il découvre qu'il peut creuser un tunnel sur le côté pour envoyer la balle derrière les briques et tout détruire ! L'agent avait inventé une stratégie que les humains mettent des heures à découvrir. Ce moment a lancé le boom du Deep RL. Fun fact : Watkins ne pensait jamais que son algo deviendrait la base de l'IA qui bat les humains 30 ans plus tard ! 🎮🧠⚡
Théo CHARLET
Étudiant TSSR - Spécialisation IA/ML
Créateur d'AG-BPE (Attention-Guided Byte-Pair Encoding)
🔗 LinkedIn: https://www.linkedin.com/in/théo-charlet
🚀 En recherche de stage