Apprentissage Q profond

L’apprentissage Q profond est une extension de l’apprentissage Q qui utilise un réseau de neurones pour approximer la table Q. Cela permet à l’apprentissage par renforcement de s’adapter à des environnements comportant de grands espaces état-action ou des espaces continus.

Pourquoi l’apprentissage Q profond ?

L’apprentissage Q profond remédie aux limites de l’apprentissage Q traditionnel :

• Gère les espaces d’états de grande dimension, par exemple les images.
• Évite de devoir stocker de grandes tables Q en mémoire.
• Généralise les connaissances entre les états grâce aux réseaux de neurones.

L’algorithme DQN

L’apprentissage Q profond utilise un réseau de neurones appelé réseau Q pour approximer les valeurs Q. Les principales étapes sont les suivantes :

1. Initialiser le réseau Q avec des poids aléatoires.
2. Interagir avec l’environnement pour recueillir des tuples d’expérience (state, action, reward, next_state).
3. Mettre à jour le réseau Q à l’aide de l’équation de Bellman :

Q(s, a) ≈ r + γ max(Q(s', a'))

Construction du réseau Q

Le réseau Q est un réseau neuronal simple à propagation avant qui reçoit l’état actuel en entrée et produit les valeurs Q de toutes les actions possibles en sortie :

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Define the Q-Network
q_network = Sequential([
    Dense(24, activation='relu', input_shape=(state_space_size,)),
    Dense(24, activation='relu'),
    Dense(action_space_size, activation='linear')
])

q_network.compile(optimizer='adam', loss='mse')

Rejeu d’expérience

L’apprentissage Q profond utilise une technique appelée rejeu d’expérience pour améliorer l’apprentissage :

• Stocker les expériences (state, action, reward, next_state) dans un tampon mémoire.
• Prélever aléatoirement des lots d’expériences à l’aide de sample pour entraîner le réseau Q.

from collections import deque

# Initialize replay memory
memory = deque(maxlen=2000)

# Add experience to memory
memory.append((state, action, reward, next_state, done))

Entraînement du réseau Q

Nous entraînons le réseau Q à partir des expériences du tampon mémoire :

import numpy as np

# Sample a batch of experiences
batch_size = 32
batch = random.sample(memory, batch_size)

# Train the Q-Network
for state, action, reward, next_state, done in batch:
    target = reward
    if not done:
        target += gamma * np.max(q_network.predict(next_state[np.newaxis, ...]))
    q_values = q_network.predict(state[np.newaxis, ...])
    q_values[0][action] = target
    q_network.fit(state[np.newaxis, ...], q_values, epochs=1, verbose=0)

Réseaux cibles

Pour stabiliser l’entraînement, DQN utilise un réseau cible :

• Maintenir un réseau distinct pour calculer les valeurs Q cibles.
• Copier périodiquement les poids du réseau Q vers le réseau cible.

Avantages de l’apprentissage Q profond

L’apprentissage Q profond offre plusieurs avantages :

• Gère les espaces d’états de grande dimension, comme les images.
• Généralise les connaissances entre les états grâce aux réseaux de neurones.
• Peut résoudre des tâches complexes comme les jeux Atari et la commande de robots.

Résumé et prochaines étapes

Dans cette leçon, nous avons :

• Découvert les principes fondamentaux de l’apprentissage Q profond.
• Construit un réseau Q pour approximer les valeurs Q.
• Étudié le rejeu d’expérience et les réseaux cibles pour obtenir un entraînement stable.

Ensuite, nous explorerons OpenAI Gym et appliquerons l’apprentissage par renforcement dans des environnements simulés.