Codice Python

Ecco un esempio dettagliato di implementazione di un algoritmo di Reinforcement Learning (RL) usando la libreria Stable-Baselines3 con l'algoritmo PPO (Proximal Policy Optimization) nell'ambiente CartPole-v1 di OpenAI Gymnasium.

Requisiti

Assicurati di installare le librerie necessarie:

pip install stable-baselines3[extra] gymnasium matplotlib

Codice Python

# Importiamo le librerie necessarie
import gymnasium as gym  # Gymnasium è la versione aggiornata di OpenAI Gym
from stable_baselines3 import PPO  # Algoritmo PPO da Stable-Baselines3
from stable_baselines3.common.evaluation import evaluate_policy  # Funzione per valutare il modello
import matplotlib.pyplot as plt  # Per visualizzare i risultati

# Creazione dell'ambiente CartPole-v1
# CartPole-v1 è un classico problema di controllo dove l'obiettivo è bilanciare un'asta
# su un carrello spostandolo a sinistra o a destra.
env = gym.make("CartPole-v1", render_mode="rgb_array")  # Utilizziamo render_mode per il rendering

# Inizializzazione del modello PPO
# MlpPolicy indica che usiamo una rete neurale feedforward per apprendere la politica.
# verbose=1 consente di stampare i log durante l'addestramento.
model = PPO("MlpPolicy", env, verbose=1)

# Addestramento del modello
# Il modello interagirà con l'ambiente per 10.000 passi e aggiornerà la sua politica
# per massimizzare la ricompensa cumulativa.
print("Inizio addestramento...")
model.learn(total_timesteps=10000)
print("Addestramento completato!")

# Valutazione del modello addestrato
# La valutazione misura le prestazioni dell'agente in termini di punteggio medio.
mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=10, render=False)
print(f"Punteggio medio dopo l'addestramento: {mean_reward:.2f} ± {std_reward:.2f}")

# Salvataggio del modello addestrato
# Questo permette di riutilizzare il modello senza doverlo addestrare nuovamente.
model.save("ppo_cartpole_gymnasium")
print("Modello salvato come 'ppo_cartpole_gymnasium'.")

# (Opzionale) Caricamento del modello salvato
# model = PPO.load("ppo_cartpole_gymnasium", env=env)

# Test del modello
# Durante il test, l'agente utilizza la politica appresa per interagire con l'ambiente.
obs, info = env.reset()  # Reset iniziale dell'ambiente
done = False
rewards = []  # Per tracciare i reward ottenuti durante il test

print("Inizio test del modello...")
while not done:
    # Prevediamo l'azione migliore basata sull'osservazione attuale
    action, _states = model.predict(obs)
    # Eseguiamo l'azione nell'ambiente e raccogliamo il nuovo stato, reward, e flag di termine
    obs, reward, done, info = env.step(action)
    # Accumuliamo i reward
    rewards.append(reward)
    env.render()  # Visualizziamo il comportamento dell'agente
env.close()

# Visualizzazione dei risultati
# Creiamo un grafico dei reward accumulati durante il test
plt.plot(rewards)
plt.title("Rewards durante il test")
plt.xlabel("Passi")
plt.ylabel("Reward")
plt.show()

Spiegazione dettagliata del codice

Importazione delle librerie

import gymnasium as gym
from stable_baselines3 import PPO
from stable_baselines3.common.evaluation import evaluate_policy
import matplotlib.pyplot as plt
```
- `gymnasium`: Per creare e gestire l'ambiente RL.
- `stable-baselines3`: Contiene implementazioni di algoritmi RL come PPO.
- `matplotlib`: Per visualizzare i risultati.

Creazione dell'ambiente

env = gym.make("CartPole-v1", render_mode="rgb_array")

- CartPole-v1: Ambiente dove il carrello deve mantenere un'asta bilanciata.
- `render_mode="rgb_array"` consente il rendering visivo compatibile con Gymnasium.

Inizializzazione del modello PPO

model = PPO("MlpPolicy", env, verbose=1)

- PPO è un algoritmo di ottimizzazione della politica progettato per garantire stabilità e semplicità.
- `MlpPolicy` utilizza una rete neurale multi-layer perceptron (MLP) per apprendere la politica.
- `verbose=1` abilita i log per monitorare l'addestramento.

Addestramento

model.learn(total_timesteps=10000)

- L'agente interagisce con l'ambiente per **10.000 passi** per apprendere la politica ottimale.
- Durante l'addestramento, PPO utilizza aggiornamenti limitati per evitare cambiamenti drastici nella politica.

Valutazione

mean_reward, std_reward = evaluate_policy(model, env, n_eval_episodes=10, render=False)

- L'agente viene testato in 10 episodi per calcolare il punteggio medio e la deviazione standard.
- `render=False` disabilita la visualizzazione durante la valutazione.

Salvataggio e caricamento

model.save("ppo_cartpole_gymnasium")
# model = PPO.load("ppo_cartpole_gymnasium", env=env)

- Salviamo il modello addestrato per riutilizzarlo in futuro.
- Può essere ricaricato con `PPO.load()`.

Test del modello

obs, info = env.reset()
done = False
while not done:
    action, _states = model.predict(obs)
    obs, reward, done, info = env.step(action)
    rewards.append(reward)
    env.render()

- L'agente usa la politica appresa per scegliere le azioni migliori.
- Il ciclo termina quando l'episodio finisce (cioè quando `done=True`).

Visualizzazione dei risultati

plt.plot(rewards)
plt.title("Rewards durante il test")
plt.xlabel("Passi")
plt.ylabel("Reward")

- Creiamo un grafico che mostra come i reward cambiano durante il test.
- Questo aiuta a comprendere le prestazioni dell'agente.

Risultato atteso

1. Durante l'addestramento, vedrai log dettagliati che mostrano il progresso dell'ottimizzazione.
2. La valutazione darà un punteggio medio e una deviazione standard simili a:
Punteggio medio dopo l'addestramento: 500.00 ± 0.00
3. Durante il test, il modello bilancerà l'asta in modo ottimale, e il grafico mostrerà un aumento costante dei reward.