Reinforcement Learning: un'introduzione con esempi in Python

I modelli di reinforcement learning (RL), sia di base sia profondi, a volte possono sembrare intelligenze artificiali da fantascienza più di qualunque large language model attuale. Vediamo come l'RL permette a questo agente di completare un livello molto difficile in Super Mario:

All'inizio, l'agente non ha idea di come si giochi. Non conosce i comandi, come progredire, quali siano gli ostacoli o cosa faccia finire la partita. Deve imparare tutto questo senza alcun intervento umano, solo grazie alla potenza degli algoritmi di reinforcement learning.

Gli agenti RL possono risolvere problemi senza soluzioni predefinite o azioni programmate esplicitamente e, cosa fondamentale, senza grandi quantità di dati. Ecco perché l'RL sta avendo un impatto significativo in molti settori. Per esempio, viene usato in:

• Auto a guida autonoma: gli agenti RL possono imparare strategie di guida ottimali in base al traffico e alle regole della strada.
• Robotica: è possibile addestrare robot a svolgere compiti complessi in ambienti dinamici tramite RL.
• Giochi: gli agenti di IA possono apprendere strategie complesse in giochi come Go o StarCraft II utilizzando tecniche RL.

Il reinforcement learning è un campo in rapida evoluzione con un enorme potenziale. Con il progredire della ricerca, possiamo aspettarci applicazioni ancora più rivoluzionarie in aree come la gestione delle risorse, la sanità e l'apprendimento personalizzato.

Per questo, ora è un ottimo momento per scoprire questo affascinante ambito del machine learning. In questo tutorial, ti aiuteremo a capire i fondamenti del reinforcement learning e spiegheremo passo dopo passo concetti come agente, ambiente, azione, stato, ricompense e altro.

Agente e ambiente

Diciamo che vuoi insegnare al tuo gatto, Bob, a usare più tiragraffi in una stanza invece dei tuoi costosi mobili. In termini di reinforcement learning, Bob è l'agente, cioè colui che impara e prende decisioni. Deve imparare cosa è consentito graffiare (tappeti e tiragraffi) e cosa no (divani e tende).

La stanza è l'ambiente con cui il nostro agente interagisce. Fornisce sfide (mobili invitanti) e l'obiettivo desiderato (un tiragraffi soddisfacente).

In RL esistono due tipi principali di ambienti:

• Ambienti discreti: se la stanza si trasformasse in un classico videogioco arcade a griglia, Bob potrebbe muoversi solo in quattro direzioni. In questi ambienti, sia le azioni di Bob sia le variazioni della stanza hanno un numero limitato di opzioni.
• Ambienti continui: una stanza reale consente possibilità quasi infinite per disporre tiragraffi e mobili. Inoltre, Bob è libero di fare tutto ciò che i gatti fanno di solito ogni giorno. Ecco perché la nostra stanza è un ambiente continuo con infinite possibilità per Bob e per la stanza.

La nostra stanza è anche un ambiente statico. I mobili non si muovono e i tiragraffi restano al loro posto.

Ma se sposti a caso mobili e tiragraffi ogni poche ore (come i diversi livelli del gioco Super Mario), la stanza diventerebbe un ambiente dinamico, più difficile da imparare per un agente perché le cose continuano a cambiare.

Azioni e stati

Due aspetti importanti di tutti i problemi di reinforcement learning sono lo spazio degli stati e lo spazio delle azioni.

Lo spazio degli stati rappresenta tutti i possibili stati (situazioni) in cui si trovano l'agente e l'ambiente in un dato momento. La dimensione dello spazio degli stati dipende dal tipo di ambiente:

• Spazio degli stati finito: quando l'ambiente è discreto, il numero di stati possibili è finito o al più numerabile. Esempi: giochi da tavolo, videogiochi a griglia o tris.
• Spazio degli stati infinito: quando l'ambiente è continuo, il suo spazio degli stati è illimitato. Esempi: videogiochi con personaggi e ambienti complessi, robot che imparano a camminare o, nel nostro caso, gatti che imparano a usare un tiragraffi.

Lo spazio delle azioni è l'insieme di tutte le cose che Bob può fare nell'ambiente. Nel nostro esempio del tiragraffi, le azioni di Bob potrebbero essere graffiare il tiragraffi, schiacciare un pisolino sul divano o persino rincorrersi la coda.

Analogamente allo spazio degli stati, il numero di azioni che Bob può compiere dipende dall'ambiente:

• Ambienti discreti: in un gioco a griglia, Bob potrebbe avere un numero limitato di azioni, come muoversi su, giù, a sinistra o a destra e graffiare.
• Ambienti continui: in una stanza reale, Bob potrebbe avere una gamma più ampia di azioni, come muoversi in qualsiasi direzione, saltare o persino (si spera di no) rosicchiare i cavi.

Quando Bob inizia la sua avventura con il tiragraffi, l'ambiente si trova in uno stato predefinito, chiamiamolo stato zero. Nel nostro caso, potrebbe essere la stanza con il tiragraffi già posizionato. Ogni azione che compie porta l'ambiente in nuovi stati successivi.

Ricompense, passi temporali ed episodi

Per raggiungere il suo obiettivo complessivo, Bob ha bisogno di incentivi o ricompense.

La maggior parte dei problemi di RL ha ricompense predefinite. Per esempio, negli scacchi, catturare un pezzo è una ricompensa positiva, mentre subire uno scacco è una ricompensa negativa.

Nel nostro caso, potremmo dare a Bob dei premietti se osserviamo un'azione positiva, come non graffiare i mobili per un po' o se trova effettivamente uno dei tiragraffi. Potremmo anche punirlo con qualche spruzzo d'acqua in faccia se rovina le tende con le unghie.

Per misurare i progressi del percorso di apprendimento di Bob, possiamo pensare alle sue azioni in termini di passi temporali. Per esempio, al passo temporale t₁ Bob esegue l'azione a₁, che porta a un nuovo stato s₁ (s₀ era lo stato predefinito). Potrebbe anche ricevere una ricompensa r₁.

Una collezione di passi temporali è detta episodio. Un episodio inizia sempre in uno stato predefinito (mobili e tiragraffi sono sistemati) e termina quando si raggiunge l'obiettivo (si trova un tiragraffi) o quando l'agente fallisce (graffia i mobili). A volte un episodio può anche terminare in base al tempo trascorso (come negli scacchi).

Esplorazione vs. sfruttamento

Come un abile giocatore di scacchi, Bob non dovrebbe cercare un tiragraffi qualsiasi. Dovrebbe puntare a quello che rende i premietti più abbondanti. Questo mette in luce un dilemma classico nel reinforcement learning: esplorazione vs. sfruttamento.

Anche se un tiragraffi invitante può offrire una gratificazione immediata, un'esplorazione più strategica potrebbe portare a un premio da jackpot più avanti. Proprio come un giocatore di scacchi potrebbe rinunciare a una cattura per ottenere una posizione superiore, Bob potrebbe inizialmente graffiare un tiragraffi subottimale (esplorazione) per scoprire il paradiso definitivo dei graffi (sfruttamento). Questa strategia di lungo periodo è cruciale per massimizzare le ricompense in ambienti complessi.

In altre parole, Bob deve bilanciare lo sfruttamento (restare su ciò che funziona meglio) con l'esplorazione (avventurarsi di tanto in tanto alla ricerca di nuovi tiragraffi). Esplorare troppo può far perdere tempo, soprattutto in ambienti continui, mentre sfruttare troppo può far perdere opportunità migliori.

Per fortuna, ci sono strategie intelligenti che Bob può adottare:

• Apprendimento epsilon-greedy: immaginiamo per un attimo che Bob abbia un particolare "gratta-metro" che genera numeri casuali. Se il numero generato è inferiore a una soglia predefinita chiamata epsilon, Bob prova una superficie da graffiare a caso (esplorazione). Ma se il numero è maggiore di epsilon, Bob sceglie il tiragraffi che in passato gli è piaciuto di più (sfruttamento).
• Esplorazione di Boltzmann: se Bob continua a graffiare cose che non danno buone sensazioni (ottenendo ricompense negative), è più probabile che esplori nuove opzioni (maggiore esplorazione). Ma quando trova il tiragraffi perfetto (ricompense positive), rimarrà su quel punto felice (sfruttamento).

Usando queste strategie (o altre fuori dall'ambito di questo tutorial), Bob può trovare un equilibrio tra esplorare l'ignoto e restare su ciò che funziona.

Algoritmi di reinforcement learning

Bob non può capire da solo come massimizzare il numero di premietti. Ha bisogno di metodi e strumenti che guidino le sue decisioni in ogni stato dell'ambiente. Qui entrano in gioco gli algoritmi di reinforcement learning.

In un'ottica più ampia, gli algoritmi di reinforcement learning possono essere classificati in base a come fanno interagire gli agenti con l'ambiente e imparare dall'esperienza. Le due categorie principali sono model-based e model-free.

Reinforcement learning model-based

Negli algoritmi model-based, l'agente (come Bob) costruisce un modello interno dell'ambiente. Questo modello rappresenta le dinamiche dell'ambiente, incluse le transizioni di stato e le probabilità di ricompensa. L'agente può quindi usare questo modello per pianificare e valutare diverse azioni prima di eseguirle nell'ambiente reale.

Questo approccio ha il vantaggio di essere più efficiente in termini di campioni, soprattutto in ambienti complessi. Significa che Bob potrebbe richiedere meno tentativi di graffio per identificare il tiragraffi ottimale rispetto a metodi puramente per tentativi ed errori. E questo perché Bob può pianificare e valutare prima di agire.

Lo svantaggio è che costruire un modello accurato può essere difficile, specialmente per ambienti complessi. Il modello potrebbe non riflettere fedelmente l'ambiente reale, portando a comportamenti subottimali.

Un comune algoritmo RL model-based è Dyna-Q, che in realtà combina apprendimento model-based e model-free. Costruisce un modello dell'ambiente e lo utilizza per pianificare le azioni, imparando contemporaneamente direttamente dall'esperienza tramite il Q-learning model-free (che spiegheremo tra poco).

Reinforcement learning model-free

Questo approccio punta a imparare direttamente dall'interazione con l'ambiente senza costruire esplicitamente un modello interno. L'agente (Bob) impara il valore degli stati e delle azioni o la strategia ottimale tramite tentativi ed errori.

Il RL model-free offre un approccio più semplice negli ambienti in cui è difficile costruire un modello accurato. Per Bob, ciò significa che non deve creare una mappa mentale complessa della stanza: può imparare graffiando e sperimentando le conseguenze.

Il RL model-free eccelle in ambienti dinamici in cui le regole possono cambiare. Se cambia la disposizione dei mobili della stanza, Bob può adattare l'esplorazione e imparare i nuovi punti ottimali per graffiare.

Tuttavia, imparare solo tramite tentativi ed errori può essere meno efficiente in termini di campioni. Bob potrebbe dover graffiare molti mobili prima di trovare costantemente il tiragraffi più gratificante.

Alcuni comuni algoritmi RL model-free includono:

• Q-Learning: l'algoritmo apprende un valore Q per ogni coppia stato-azione. Il valore Q rappresenta la ricompensa futura attesa eseguendo una specifica azione in un certo stato. L'agente può quindi scegliere l'azione con il valore Q più alto per massimizzare la ricompensa a lungo termine (lo spiegheremo più in dettaglio nella sezione successiva).
• SARSA (State-Action-Reward-State-Action): simile al Q-learning, ma apprende una funzione di valore per ogni coppia stato-azione. Aggiorna il valore in base alla ricompensa ricevuta dopo aver compiuto un'azione e al successivo stato osservato.
• Metodi a gradiente di politica (policy gradient): questi algoritmi apprendono direttamente la funzione di policy, che mappa stati in azioni. Usano gradienti per aggiornare la policy nella direzione che si prevede porti a ricompense più alte. Esempi: REINFORCE e Proximal Policy Optimization (PPO).
• Deep Q-Networks (DQN): questo algoritmo combina il Q-learning con reti neurali profonde per gestire spazi degli stati ad alta dimensionalità, tipici di ambienti complessi come i videogiochi.

La scelta dell'algoritmo dipende da vari fattori: la complessità dell'ambiente, la disponibilità di risorse o il livello di interpretabilità desiderato.

Gli approcci model-based possono essere preferibili per ambienti più semplici in cui è fattibile costruire un modello accurato. Gli approcci model-free, invece, sono spesso più pratici per scenari reali complessi.

Inoltre, con l'ascesa del deep learning, i Deep Q-Networks (DQN) e altri algoritmi di deep RL stanno diventando sempre più popolari per affrontare compiti complessi con spazi degli stati ad alta dimensionalità.

Q-learning

Concentriamoci ora su un singolo algoritmo e approfondiamo il Q-learning.

Panoramica ad alto livello

Il Q-learning è un algoritmo model-free che insegna agli agenti la strategia vincente ottimale attraverso interazioni intelligenti con l'ambiente.

Torniamo al nostro esempio del gatto e immaginiamo di risolvere una versione arcade del problema con un ambiente discreto e un insieme finito di azioni.

Diciamo di fornire a Bob una tabella. Le colonne rappresentano le azioni disponibili, mentre ogni riga associa l'azione a uno specifico stato dello spazio degli stati.

All'inizio riempiamo la tabella di zeri, che rappresentano i valori Q iniziali: per questo la chiamiamo Q-table.

Poi avviamo un ciclo di interazione dallo stato predefinito (l'inizio di un episodio. Nel ciclo, Bob compie l'azione con il valore Q più alto per lo stato dato. Tuttavia, al primo passaggio nel ciclo non ci sarà alcun valore Q più alto a guidare l'azione di Bob, dato che inizialmente tutti i valori Q sono zero.

Qui entrano in gioco le strategie di esplorazione (come l'esplorazione casuale o epsilon-greedy). Queste strategie aiutano Bob a raccogliere informazioni quando la Q-table è vuota.

Una volta aggiornata la Q-table, Bob avvia di nuovo un ciclo di interazione. L'azione che compie produce una ricompensa e un nuovo stato. Quindi calcoliamo nuovi valori Q per ciascuna azione che Bob può compiere nel nuovo stato (tra poco mostreremo come calcolare i valori Q).

L'episodio continua fino alla terminazione (Bob può compiere un numero qualsiasi di passi in ogni episodio), e poi si ricomincia. Ogni episodio successivo avrà una Q-table più ricca, rendendo Bob più intelligente.

Ecco una panoramica ad alto livello dei passaggi coinvolti:

1. Inizializziamo una Q-table e la riempiamo con valori iniziali.
2. Avviamo un episodio.
3. L'agente compie un'azione.
4. Misuriamo la ricompensa ricevuta.
5. Si raggiunge un nuovo stato.
6. Si calcola un nuovo valore Q per il nuovo stato.
7. L'episodio termina per fallimento, vittoria o time-out.
8. L'ambiente viene reimpostato.
9. Ripetiamo i passaggi 2-8 per il numero di episodi desiderato.

Passaggi come uno e due possono essere immediati, ma gli altri richiedono più spiegazioni.

Come sceglie l'azione l'agente?

Al passo temporale 1, quando Bob compie la sua prima azione, sarà casuale, dato che tutti i valori Q sono zero. Nei passi successivi, Bob deve considerare l'equilibrio tra esplorazione e sfruttamento.

Per aiutarlo, diamo a Bob un iperparametro chiamato epsilon con un valore piccolo, in genere 0,1. Poi diciamo a Bob di generare un numero casuale tra 0 e 1 e, se il numero è inferiore a epsilon, di scegliere un'azione casuale indipendentemente dal suo valore Q.

Se è maggiore di epsilon, Bob sceglierà l'azione con il valore Q più alto. In questo modo, Bob esplorerà per una frazione epsilon (0,1 o 10%) del tempo e sfrutterà per (1 - epsilon, ovvero 0,9 o 90%) del tempo.

Quanto appena descritto si chiama politica epsilon-greedy. Le politiche definiscono come l'agente compie azioni e come si calcolano i valori Q.

Come si misura la ricompensa?

Le regole per calcolare la ricompensa sono di solito definite da chi crea l'ambiente. Per esempio, potresti decidere di dare a Bob un premietto per usare un tappeto da graffiare e cinque premietti per saltare abbastanza in alto da graffiare quello sul muro. Potresti anche punire Bob se graffia oggetti di valore.

Ma la maggior parte del tempo non ci sarà alcuna ricompensa, perché Bob dormirà, camminerà o giocherà.

Come si aggiorna la Q-table?

La formula per calcolare il valore Q può incutere timore, quindi vediamola prima per intero e poi spieghiamola passo dopo passo:

Consideriamo l'inizio della formula:

Questa parte dice: "Dato lo stato e l'azione precedenti, il nuovo valore Q è calcolato come (...)".

La parte sotto è il valore Q attuale (che sta per diventare quello vecchio) che l'agente ha usato per compiere l'azione.

Ora consideriamo la parte finale:

S_t+1 è il nuovo stato risultante dall'esecuzione dell'azione A_t. Quindi, questa parte trova il valore Q più grande tra tutte le azioni (a) in quel nuovo stato. Moltiplichiamo tale valore per un parametro γ chiamato gamma (fattore di sconto) e sommiamo il risultato alla ricompensa ricevuta.

Se impostiamo gamma vicino a 1, diamo un peso maggiore alle ricompense future. Se lo abbassiamo verso zero, enfatizziamo di più la ricompensa corrente R_t+1. Ciò significa che gamma è un altro parametro che possiamo usare per bilanciare esplorazione e sfruttamento.

Infine, abbiamo alfa (α), che controlla la velocità di addestramento e varia da 0 a 1. Valori vicini a 1 rendono gli aggiornamenti dei valori Q più ampi, quindi l'agente impara più rapidamente, rendendo più pesante il lato destro del segno più. Al contrario, valori vicini a 0 rendono più pesante il lato sinistro, che contiene il valore Q attuale.

Usare il learning rate per controllare la velocità di addestramento assicura che l'agente non progredisca troppo rapidamente dimenticando informazioni vecchie. Garantisce anche che non impari troppo lentamente, rischiando di perdere informazioni importanti.

Questa è la parte più impegnativa per capire il Q-learning, e spero che tu abbia colto a grandi linee come funziona.

Reinforcement learning in Python con Gymnasium

Come per tutto, in Python esistono framework per risolvere problemi di reinforcement learning. Il più popolare è Gymnasium, che include oltre 2000 ambienti preconfigurati (tutti ben documentati).

$ pip install "gymnasium[atari]"
$ pip install autorom[accept-rom-license]
$ AutoROM --accept-license

import gymnasium as gym
env = gym.make("ALE/Breakout-v5")

L'ambiente che abbiamo appena caricato si chiama Breakout. Ecco come appare:

L'obiettivo qui è che la barretta (l'agente) impari a eliminare tutti i mattoncini tramite tentativi ed errori. Le regole del gioco determinano penalità e ricompense.

Concluderemo l'articolo mostrando come eseguire episodi di interazione e visualizzare i progressi dell'agente con una GIF come quella sopra.

Ecco il codice per il ciclo di interazione:

epochs = 0

frames = []  # for animation
done = False

env = gym.make("ALE/Breakout-v5", render_mode="rgb_array")
observation, info = env.reset()

while not done:
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action)

    # Put each rendered frame into dict for animation
    frames.append(
        {
            "frame": env.render(),
            "state": observation,
            "action": action,
            "reward": reward,
        }
    )

    epochs += 1
    if epochs == 1000:
        break

Abbiamo appena eseguito mille passi temporali, in altre parole, l'agente ha compiuto 1000 azioni. Tuttavia, tutte queste azioni sono puramente casuali: non sta imparando dagli errori passati. Per verificarlo, possiamo usare la variabile frames per creare una GIF:

from moviepy.editor import ImageSequenceClip
# !pip install moviepy - if you don’t have moviepy

def create_gif(frames: dict, filename, fps=100):
    """
    Creates a GIF animation from a list of RGBA NumPy arrays.

    Args:
        frames: A list of RGBA NumPy arrays representing the animation frames.
        filename: The output filename for the GIF animation.
        fps: The frames per second of the animation (default: 10).
    """
    rgba_frames = [frame["frame"] for frame in frames]

    clip = ImageSequenceClip(rgba_frames, fps=fps)
    clip.write_gif(filename, fps=fps)

# Example usage
create_gif(frames, "animation.gif") #saves the GIF locally

Nota: se compare l'errore "RuntimeError: No ffmpeg exe could be found", prova ad aggiungere le due righe di codice seguenti prima di importare moviepy:

from moviepy.config import change_settings
change_settings({"FFMPEG_BINARY": "/usr/bin/ffmpeg"})

Il nostro primo snippet ha restituito lo stato dell'ambiente come array RGBA per ogni passo temporale, e sono memorizzati in frames. Mettendo insieme tutti i frame con la libreria moviepy, possiamo creare la GIF che hai visto prima:

Come nota a margine, puoi regolare il parametro fps per rendere la GIF più veloce se esegui molti passi temporali.

Ora che vediamo che l'agente sta semplicemente eseguendo azioni casuali, è il momento di provare qualche algoritmo. Puoi farlo passo dopo passo in questo corso su Reinforcement Learning with Gymnasium in Python, dove esplorerai molti algoritmi, tra cui Q-learning, SARSA e altro.

Assicurati di usare la funzione che abbiamo appena creato per animare i progressi dei tuoi agenti e divertiti!

Conclusione

Il reinforcement learning è una delle cose più intriganti dell'informatica e del machine learning. In questo tutorial, abbiamo visto i concetti fondamentali dell'RL, dagli agenti e ambienti fino agli algoritmi model-free come il Q-learning.

Tuttavia, creare agenti di livello mondiale capaci di risolvere problemi complessi come scacchi o videogiochi richiederà tempo e pratica. Ecco quindi alcune risorse che possono aiutarti lungo il percorso:

• Introduzione al Q-Learning: un tutorial per principianti
• Reinforcement Learning with Gymnasium in Python
• Documentazione di Python Gymnasium

Grazie per la lettura!