Mise en œuvre de l’apprentissage Q en Python

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

Définition de l’environnement

Nous définissons un monde en grille simple de 4×4, 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

Initialisation de la table Q

La table Q est initialisée avec des zeros 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émentation de 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

Évaluation de la politique apprise

Après l’entraînement, nous évaluons la politique en suivant les actions optimales enregistrées dans la table 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)

Visualisation de la table Q

Nous pouvons visualiser la table 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 offre plusieurs avantages :

• Simple et facile à implémenter.
• Peut gérer des environnements stochastiques.
• Converge vers la politique optimale avec une exploration suffisante.

Limites de l’apprentissage Q

L’apprentissage Q présente certaines limites :

• Ne s’adapte pas bien aux environnements comportant de grands espaces état-action.
• L’apprentissage peut être lent dans les environnements complexes.
• 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’une table Q.
• Évalué la politique apprise et visualisé la table Q.

Ensuite, nous explorerons l’apprentissage Q profond, qui utilise des réseaux de neurones pour gérer les environnements comportant de grands espaces état-action.