Apprentissage par renforcement : value iteration et Q-learning en Python

Le concept en termes simples

En apprentissage par renforcement, un agent agit dans un environnement et reçoit des récompenses. Il apprend la valeur de chaque état ou action pour choisir les actions qui rapportent le plus de récompense au fil du temps.

Apprenez à un agent à atteindre un but : calculez les valeurs des états par value iteration, puis apprenez-les par essais et erreurs avec le Q-learning.

Idées clés

Le facteur d'actualisation γ donne plus de valeur aux récompenses qui arrivent tôt.
La value iteration a besoin d'un modèle de l'environnement ; le Q-learning apprend par l'expérience.
Q(s, a) est la récompense totale attendue en effectuant l'action a dans l'état s.
L'exploration (ici 20 % de coups aléatoires) est nécessaire pour que l'agent découvre le but.

Quand l’utiliser ?

Comprendre ce qui se passe à l'intérieur des réseaux de neurones et des bibliothèques d'IA.
Apprendre l'idée avant de l'implémenter dans les défis correspondants.
Se préparer aux cours d'apprentissage automatique, aux entretiens et aux projets.

À vous de jouer

Appuyez sur Lecture à gauche pour propager les valeurs depuis le but dans toute la grille. À droite, regardez l'agent apprendre le même chemin par essais et erreurs.

Code d’exemple

Exécuter le code →

main.py

import random

# A corridor of 5 cells: start in cell 0, reward +10 for reaching cell 4.
N, GOAL, GAMMA = 5, 4, 0.9

# Value iteration: a cell is worth its reward plus the discounted best neighbour.
values = [0.0] * N
for _ in range(50):
    values = [0.0 if s == GOAL else max((10 if n == GOAL else 0) + GAMMA * values[n]
              for n in (max(0, s - 1), min(N - 1, s + 1))) for s in range(N)]
print("state values:", [round(v, 2) for v in values])

# Q-learning learns the same thing from trial and error.
random.seed(0)
Q = [[0.0, 0.0] for _ in range(N)]   # actions: 0 = left, 1 = right
for episode in range(200):
    s = 0
    while s != GOAL:
        a = random.randrange(2) if random.random() < 0.2 else Q[s].index(max(Q[s]))
        n = max(0, s - 1) if a == 0 else min(N - 1, s + 1)
        reward = 10 if n == GOAL else 0
        target = reward + (0 if n == GOAL else GAMMA * max(Q[n]))
        Q[s][a] += 0.5 * (target - Q[s][a])   # move the estimate toward the target
        s = n
print("best action per cell:", ["right" if q[1] >= q[0] else "left" for q in Q[:GOAL]])
print("Q(0, right):", round(Q[0][1], 2))

Résultat attendu

state values: [7.29, 8.1, 9.0, 10.0, 0.0]
best action per cell: ['right', 'right', 'right', 'right']
Q(0, right): 7.29

Fonctionnement

La value iteration répète la mise à jour de Bellman, où la valeur d'une case est la meilleure récompense plus la valeur actualisée de la case suivante ; on obtient 10, 9, 8.1 et 7.29 en s'éloignant du but. Le Q-learning ne connaît pas les règles. Après chaque pas, il rapproche son estimation de reward + γ·max Q(next) et apprend à toujours aller à droite.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices pratiques

Modifiez les entrées et testez les cas limites avant d’utiliser des données plus volumineuses.

Modifiez les entrées ou les poids et prédisez la sortie avant d'exécuter.
Affichez les valeurs intermédiaires pour suivre chaque étape du calcul.
Résolvez les défis liés ci-dessous pour implémenter l'idée vous-même.

Exécuter dans l’IDE Python →

S'entraîner avec un défi

Utilisez le contenu de cette leçon pour résoudre un vrai problème. Chaque défi s'exécute dans le navigateur, avec des tests instantanés et une revue par l'IA.

Tous les défis