Implémenter l’apprentissage Q en Python

Dans cette leçon, nous allons implémenter un algorithme simple d’apprentissage Q en Python. L’agent apprendra à se déplacer dans un monde quadrillé afin de maximiser ses récompenses.

Définir l’environnement

Nous définissons un monde quadrillé simple de 4×4 cases, dans lequel l’agent commence dans le coin supérieur gauche et doit atteindre le coin inférieur droit pour recevoir une récompense.

import numpy as np

# Define the environment
num_states = 16  # 4x4 grid
num_actions = 4  # Up, Down, Left, Right

# Define rewards (-1 for each step, +10 for the goal)
rewards = np.zeros(num_states)
rewards[-1] = 10

Initialiser le tableau Q

Le tableau Q est initialisé avec des zéros pour toutes les paires état-action.

# Initialize the Q-Table
q_table = np.zeros((num_states, num_actions))

print("Initial Q-Table:")
print(q_table)

Implémenter l’algorithme d’apprentissage Q

Nous utilisons les paramètres suivants :

• α (taux d’apprentissage) : contrôle la mesure dans laquelle les nouvelles informations remplacent les anciennes.
• γ (facteur d’actualisation) : pondère les récompenses futures par rapport aux récompenses immédiates.
• ε (taux d’exploration) : établit un équilibre entre l’exploration et l’exploitation.

# Parameters
alpha = 0.1  # Learning rate
gamma = 0.9  # Discount factor
epsilon = 0.1  # Exploration rate

# Q-Learning loop
num_episodes = 1000
for episode in range(num_episodes):
    state = 0  # Start at the first state
    done = False
    while not done:
        # Exploration or exploitation
        if np.random.rand() < epsilon:
            action = np.random.randint(num_actions)  # Explore
        else:
            action = np.argmax(q_table[state])  # Exploit

        # Transition to the next state
        next_state = (state + action) % num_states  # Simplified transition logic
        reward = rewards[next_state]

        # Update Q-value
        q_table[state, action] = q_table[state, action] + alpha * (
            reward + gamma * np.max(q_table[next_state]) - q_table[state, action]
        )

        # Move to the next state
        state = next_state
        done = state == num_states - 1

Évaluer la politique apprise

Après l’entraînement, nous évaluons la politique en suivant les actions optimales stockées dans le tableau Q :

# Evaluate the policy
state = 0
optimal_path = [state]
while state != num_states - 1:
    action = np.argmax(q_table[state])
    state = (state + action) % num_states  # Simplified transition logic
    optimal_path.append(state)

print("Optimal Path:", optimal_path)

Visualiser le tableau Q

Nous pouvons visualiser le tableau Q pour comprendre les valeurs apprises pour chaque paire état-action :

import matplotlib.pyplot as plt
import seaborn as sns

# Visualize Q-Table
plt.figure(figsize=(10, 8))
sns.heatmap(q_table, annot=True, fmt=".2f", cmap="coolwarm")
plt.title("Q-Table Heatmap")
plt.xlabel("Actions")
plt.ylabel("States")
plt.show()

Avantages de l’apprentissage Q

L’apprentissage Q présente plusieurs avantages :

• Il est simple et facile à implémenter.
• Il peut gérer des environnements stochastiques.
• Il converge vers la politique optimale avec une exploration suffisante.

Limites de l’apprentissage Q

L’apprentissage Q présente certaines limites :

• Il s’adapte mal aux environnements dont les espaces état-action sont vastes.
• L’apprentissage peut être lent dans les environnements complexes.
• Il nécessite une représentation bien définie des états et des actions.

Résumé et prochaines étapes

Dans cette leçon, nous avons :

• implémenté un algorithme simple d’apprentissage Q en Python ;
• entraîné un agent à se déplacer dans un monde quadrillé à l’aide d’un tableau Q ;
• évalué la politique apprise et visualisé le tableau Q.

Ensuite, nous découvrirons l’apprentissage Q profond, qui utilise des réseaux neuronaux pour gérer les environnements dont les espaces état-action sont vastes.