Disordine

GPT-5: uno step verso un'AI più completa

Giovedì, 7 Agosto 2025. OpenAI ha reso disponibile GPT-5, evoluzione e integrazione tra i modelli GPT-Series e o-Series. È progettato per gestire compiti complessi mediante un’architettura modulare costituita da due componenti principali: uno ottimizzato per risposte rapide (fast), e un modulo dedicato al ragionamento elaborato (thinking). Un router in tempo reale seleziona quale modulo attivare in funzione della complessità del prompt, del comportamento dell’utente e della correttezza delle risposte. Questo router si adatta dinamicamente, apprende da dati sulle preferenze e migliora decisio...

OpenAI rilascia i modelli GPT-OSS: disponibili due LLM open-weight da 20B e 120B parametri

Mercoledì, 6 Agosto 2025. OpenAI ha annunciato ( https://openai.com/it-IT/index/introducing-gpt-oss/ ) la disponibilità di due nuovi modelli linguistici di grandi dimensioni (LLM) denominati GPT-OSS, resi pubblici con pesi open-weight e licenza Apache 2.0. Si tratta dei primi modelli di questo tipo pubblicati da OpenAI dall’epoca di GPT-2. I modelli rilasciati sono: gpt-oss-120b – un modello con 120 miliardi di parametri gpt-oss-20b – un modello con 20 miliardi di parametri Entrambi sono disponibili per il download e l'esecuzione locale, con piena compatibilit&...

Microsoft presenta Majorana 1: il primo processore quantistico al mondo basato su qubit topologici

Venerdì, 21 Febbraio 2025. Microsoft ha annunciato Majorana 1, un Quantum Processing Unit (QPU) che rappresenta un importante passo avanti nel percorso verso il calcolo quantistico pratico. La particolarità di questo processore risiede nell’uso di qubit topologici, una tecnologia che garantisce maggiore stabilità e riduce gli errori, grazie a un’architettura intrinsecamente protetta. Majorana 1 è progettato per scalare fino a un milione di qubit su un singolo chip, aprendo nuove prospettive per lo sviluppo di computer quantistici in grado di affrontare problemi complessi oggi irrisolvibi...

L'IA generativa rivoluziona la crescita economica globale e il mercato del lavoro

Giovedì, 30 Marzo 2023. Un recente studio di Goldman Sachs, "The Potentially Large Effects of Artificial Intelligence on Economic Growth" (Briggs, Kodnani et al.), esamina gli effetti potenzialmente significativi dell'intelligenza artificiale (IA) generativa sulla crescita economica. L'IA generativa, caratterizzata dall'uso generalizzato, dalla capacità di generare contenuti simili a quelli umani e dalle interfacce intuitive, potrebbe cambiare radicalmente il mercato del lavoro e aumentare la produttività a livello globale. Le tecnologie IA generative, come ChatGPT, DALL-E ...

Plug-in per ChatGPT: nuove capacità e accesso real time al web

Mercoledì, 29 Marzo 2023. OpenAI ha lanciato il supporto ai plug-in per ChatGPT, consentendo l'ampliamento delle capacità del chatbot e permettendogli, per la prima volta, di accedere a dati in tempo reale dal web. Fino ad ora, ChatGPT era limitato dall'impossibilità di attingere a informazioni al di fuori del dataset di addestramento, fermo a più di un anno fa. OpenAI afferma che i plug-in permetteranno al bot di interagire con siti web specifici, trasformando potenzialmente il sistema in un'interfaccia per vari servizi. In un video dimostrativo, un utente utilizza ChatGPT per tr...

La rivoluzione AI e la corsa dei colossi della tecnologia

Martedì, 28 Marzo 2023. In una call su Microsoft Teams, Jared Spataro, responsabile del software di produttività di Microsoft, dimostra come l'intelligenza artificiale (AI) riesca ad elaborare un riassunto accurato della conversazione in corso, praticamente in tempo reale. Microsoft sta implementando l'intelligenza artificiale in quasi tutti i suoi prodotti e in particolare nella suite Microsoft 365 attraverso Copilot, appoggiandosi su ChatGPT. Alphabet, la casa madre di Google, sta seguendo la stessa strada con prodotti come Gmail e Sheets. Negli ultimi mesi, anche gli altri giganti della tecnologi...

PPO: Proximal Policy Optimization

Giovedì, 15 Ottobre 2026 | Reinforcement Learning |

Limiti dell'approccio Policy Gradient

I metodi basati sul policy gradient cercano di risolvere un problema di ottimizzazione diretta della policy, ossia di trovare i parametri \( \theta \) che massimizzano il valore atteso cumulativo delle ricompense future:

\( \max_\theta J(\pi_\theta) \doteq \mathbb{E}_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{\infty} \gamma^t r_t \right] \)

Per risolvere questo problema, si applica l’ascesa stocastica del gradiente rispetto ai parametri della policy, utilizzando il gradiente di policy definito come:

\( g = \nabla_\theta J(\pi_\theta) = \mathbb{E}_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{\infty} \gamma^t \nabla_\theta \log \pi_\theta(a_t|s_t) A^{\pi_\theta}(s_t, a_t) \right] \)

In questa formulazione, \( A^{\pi_\theta}(s_t, a_t) \) rappresenta la funzione di advantage, che misura quanto l’azione presa in uno stato è migliore o peggiore della media rispetto alla policy corrente.

Evidenziamo due limitazioni principali del metodo "vanilla" di Policy Gradient:

Bassa efficienza del campionamento: per stimare accuratamente il gradiente è necessario raccogliere molte traiettorie di interazione con l’ambiente, rendendo il processo lento e costoso, con limitato riuso.
Lo spazio dei parametri non coincide con lo spazio delle policy: piccoli cambiamenti nei parametri \( \theta \) possono corrispondere a variazioni molto grandi o molto piccole nel comportamento della policy. Nel caso tabulare, lo spazio delle policy può essere descritto come l’insieme di tutte le matrici di probabilità \( \Pi = \left\{ \pi : \pi \in \mathbb{R}^{|S| \times |A|}, \ \sum_a \pi_{sa} = 1, \ \pi_{sa} \ge 0 \right\} \).
Poiché gli aggiornamenti vengono effettuati sui parametri \( \theta \) e non direttamente sulle probabilità, non è garantito che un piccolo passo in \( \theta \) corrisponda a una piccola variazione della policy. Ciò comporta che la dimensione del passo (learning rate) sia critica e difficile da regolare, poiché un valore troppo grande può far divergere la policy, mentre uno troppo piccolo rallenta drasticamente la convergenza.

Approfondendo il tema dell'efficienza nel campionamento (sample efficiency), rileviamo che nei metodi “vanilla”, infatti, ogni batch di dati raccolto viene utilizzato solo per un singolo aggiornamento del gradiente e poi scartato, il che comporta un notevole spreco di informazioni utili.

La ragione di questa limitazione è che il policy gradient è un’aspettativa on-policy: i campioni utilizzati per stimare il gradiente devono provenire dalla stessa policy che si sta attualmente aggiornando. Utilizzare dati provenienti da una policy differente con un approccio off-policy (meno stabile) introdurrebbe un bias nella stima.

Un’opportunità interessante per migliorare l’efficienza consiste nel riutilizzare i dati già raccolti per eseguire più passi di gradiente prima di aggiornare la policy e raccogliere nuovi campioni. In questo modo, ogni batch di dati contribuisce maggiormente all’apprendimento, riducendo il numero complessivo di interazioni necessarie con l’ambiente.

Tuttavia, ciò introduce una nuova sfida: anche se teoricamente è possibile usare più volte gli stessi dati, non è chiaro quanti passi di aggiornamento sia ottimale eseguire prima che la stima del gradiente diventi troppo incoerente rispetto alla policy corrente.

Negli algoritmi di ottimizzazione della policy, l’obiettivo è definire una regola di aggiornamento che sia il più efficiente possibile e che tenga conto della reale distanza tra le policy nello spazio delle policy, invece che nella semplice distanza dei parametri. Questo è importante perché piccole variazioni nei parametri della funzione che rappresenta la policy possono produrre grandi cambiamenti nel comportamento dell’agente.

Idealmente, vogliamo quindi un aggiornamento che:

utilizzi in modo efficiente i rollouts raccolti dalla policy più recente;
faccia passi di aggiornamento che rispettino la distanza nello spazio delle policy, garantendo una transizione stabile da una policy all’altra.

Performance delle Policy e ottimizzazione

Per determinare una regola di aggiornamento corretta, è necessario comprendere come la performance di due policy diverse sia correlata. Per due policy qualsiasi \( \pi \) e \( \pi' \), si può dimostrare che la differenza di performance può essere espressa come:

\( J(\pi') - J(\pi) = \mathbb{E}_{\tau \sim \pi'} \left[ \sum_{t=0}^{\infty} \gamma^t A^{\pi}(s_t, a_t) \right] \)

Questa equazione mostra che la differenza tra i rendimenti medi delle due policy dipende dal valore atteso dell’advantage function della policy originale \( \pi \), calcolato su traiettorie campionate dalla nuova policy \( \pi' \).

Una forma equivalente che è possibile dimostrare, più compatta, è:

\( J(\pi') - J(\pi) = \frac{1}{1-\gamma} \, \mathbb{E}_{s \sim d^{\pi'},\, a \sim \pi'} \left[ A^{\pi}(s, a) \right] \)

dove \( d^{\pi}(s) \) rappresenta la distribuzione stazionaria scontata degli stati sotto la policy \( \pi \), definita come:

\( d^{\pi}(s) = (1 - \gamma) \sum_{t=0}^{\infty} \gamma^t P(s_t = s \, | \, \pi) \)

In termini intuitivi, questo lemma afferma che per valutare quanto una nuova policy \( \pi' \) sia migliore o peggiore della precedente, è sufficiente osservare il vantaggio medio che le azioni scelte da \( \pi' \) producono rispetto alle azioni medie della policy di riferimento \( \pi \).

Possiamo chiederci come usare questa relazione per migliorare la policy. Supponiamo che \( \pi \) rappresenti la policy attuale e \( \pi' \) quella nuova che vogliamo ottimizzare. L’obiettivo dell’improvement è massimizzare il valore atteso della nuova policy:

\( \max_{\pi'} J(\pi') = \max_{\pi'} \, [ J(\pi') - J(\pi) ] \) = \( \max_{\pi'} \, \mathbb{E}_{\tau \sim \pi'} \left[ \sum_{t=0}^{\infty} \gamma^t A^{\pi}(s_t, a_t) \right] \)

Questa formulazione è interessante perché definisce il miglioramento della nuova policy \( \pi' \) in funzione degli advantage calcolati rispetto alla vecchia policy \( \pi \). In altre parole, ci permette di capire se e quanto la nuova policy supera la precedente, basandoci sul vantaggio medio delle sue azioni.

Tuttavia, questa espressione presenta un limite importante: per calcolare l’aspettativa dobbiamo comunque disporre di traiettorie campionate dalla nuova policy \( \pi' \), che ancora non conosciamo. Questo rende il metodo non immediatamente utilizzabile nella pratica.

Il problema quindi diventa: come stimare \( J(\pi') \) — cioè la performance della nuova policy — utilizzando solo i dati raccolti dalla policy precedente \( \pi \)?

Possiamo riscrivere l’identità che descrive la performance relativa tra due policy, evidenziando come la differenza tra le loro prestazioni possa essere stimata anche utilizzando i campioni provenienti dalla policy originale. Possiamo riscrivere questa espressione come:

\( J(\pi') - J(\pi) = \frac{1}{1 - \gamma} \, \mathbb{E}_{s \sim d^{\pi'}, \, a \sim \pi'} \left[ A^{\pi}(s, a) \right] \)

Dove \( d^{\pi'}(s) \) è la distribuzione stazionaria scontata degli stati secondo la nuova policy \( \pi' \).

Tuttavia, questa formulazione richiede ancora campioni generati da \( \pi' \). Per superare questo vincolo, possiamo introdurre un cambio di misura di probabilità che ci consente di esprimere l’aspettativa in termini della policy precedente \( \pi \). Questo porta alla forma:

\( J(\pi') - J(\pi) = \frac{1}{1 - \gamma} \, \mathbb{E}_{s \sim d^{\pi'}, \, a \sim \pi} \left[ \frac{\pi'(a|s)}{\pi(a|s)} \, A^{\pi}(s, a) \right] \)

Il termine in rosso, \( \frac{\pi'(a|s)}{\pi(a|s)} \), è noto come importance sampling ratio e permette di “correggere” la distribuzione dei campioni, pesandoli in base a quanto la nuova policy differisce da quella precedente.

Questo passaggio è fondamentale, perché consente di stimare la differenza di performance tra due policy diverse utilizzando solo i dati raccolti dalla vecchia policy \( \pi \), evitando la necessità di eseguire nuovi rollouts ogni volta che la policy viene aggiornata.
Per semplificare il calcolo della differenza di performance tra due policy \( \pi \) e \( \pi' \), possiamo fare una approssimazione utile assumendo che le rispettive distribuzioni stazionarie degli stati siano simili, ovvero \( d^{\pi'} \approx d^{\pi} \) .

Sotto questa ipotesi, possiamo riscrivere l’identità della performance relativa come:

\( J(\pi') - J(\pi) \approx \frac{1}{1-\gamma} \, \mathbb{E}_{s \sim d^{\pi},\, a \sim \pi} \left[ \frac{\pi'(a|s)}{\pi(a|s)} A^{\pi}(s, a) \right] \doteq \mathcal{L}_{\pi}(\pi') \)

Questa approssimazione è in genere valida quando le due policy sono “abbastanza vicine” — cioè quando \( \pi' \) non differisce troppo da \( \pi \). La vicinanza tra policy può essere quantificata attraverso la divergenza di Kullback–Leibler (KL-divergence). Infatti, i limiti di performance relativi mostrano che:

\( \big| J(\pi') - (J(\pi) + \mathcal{L}_{\pi}(\pi')) \big| \le C \sqrt{ \mathbb{E}_{s \sim d^{\pi'}} \left[ D_{KL}(\pi' \| \pi)[s] \right] } \)

Dove \( C \) è una costante di proporzionalità. In altre parole, se la divergenza KL tra le due policy è piccola, l’approssimazione è molto accurata.

La divergenza di Kullback–Leibler misura quanto una distribuzione di probabilità \( P \) differisce da un’altra \( Q \) ed è definita come:

\( D_{KL}(P \| Q) = \sum_x P(x) \log \frac{P(x)}{Q(x)} \)

Ha alcune proprietà fondamentali:

\( D_{KL}(P \| P) = 0 \)
\( D_{KL}(P \| Q) \ge 0 \)
Non è simmetrica: \( D_{KL}(P \| Q) \neq D_{KL}(Q \| P) \)

Nel contesto delle policy, la KL-divergence misura la differenza tra due distribuzioni di azioni condizionate dallo stato:

\( D_{KL}(\pi' \| \pi)[s] = \sum_{a \in A} \pi'(a|s) \log \frac{\pi'(a|s)}{\pi(a|s)} \)

Più questo valore è piccolo, più le due policy si comportano in modo simile nello stesso stato.

Perché questa approssimazione è utile

Grazie all’assunzione \( d^{\pi'} \approx d^{\pi} \), possiamo stimare il miglioramento della policy \( \pi' \) utilizzando solo traiettorie raccolte dalla policy precedente \( \pi \). Ciò consente di ottimizzare \( \mathcal{L}_{\pi}(\pi') \) senza dover eseguire nuovi rollouts a ogni aggiornamento.

\( \mathcal{L}_{\pi}(\pi') = \frac{1}{1-\gamma} \, \mathbb{E}_{s \sim d^{\pi},\, a \sim \pi} \left[ \frac{\pi'(a|s)}{\pi(a|s)} A^{\pi}(s, a) \right] \)

Questo equivale a stimare il gradiente della policy usando l’importance sampling, ma con pesi che dipendono solo dalle probabilità relative tra \( \pi' \) e \( \pi \). Poiché questi pesi non dipendono dalla lunghezza della traiettoria, l’approccio rimane stabile e computazionalmente efficiente.

L’approssimazione \( J(\pi') - J(\pi) \approx \mathcal{L}_{\pi}(\pi') \) consente di riscrivere la differenza di performance tra due policy come una funzione ottimizzabile utilizzando i dati raccolti dalla policy precedente \( \pi \).

In particolare, si definisce:

\( \mathcal{L}_{\pi}(\pi') = \frac{1}{1 - \gamma} \mathbb{E}_{s \sim d^{\pi},\, a \sim \pi} \left[ \frac{\pi'(a|s)}{\pi(a|s)} A^{\pi}(s, a) \right] = \mathbb{E}_{\tau \sim \pi} \left[ \sum_{t=0}^{\infty} \gamma^t \frac{\pi'(a_t|s_t)}{\pi(a_t|s_t)} A^{\pi}(s_t, a_t) \right] \)

Questa formulazione presenta un vantaggio pratico: possiamo ottimizzare la nuova policy \( \pi' \) sfruttando le traiettorie già campionate dalla policy precedente \( \pi \), senza dover generare nuovi dati a ogni iterazione.

PPO con Adaptive KL Penalty

La Proximal Policy Optimization (PPO) è una famiglia di metodi che mira a evitare che la policy aggiornata si discosti troppo da quella precedente in ogni iterazione di training. L’idea di fondo è quella di penalizzare gli aggiornamenti eccessivi, mantenendo la stabilità dell’apprendimento e al contempo migliorando la performance.

Una delle varianti principali è la Adaptive KL Penalty, che introduce una penalizzazione adattiva basata sulla divergenza di Kullback–Leibler (KL) tra la nuova policy e quella precedente. In questo caso, l’aggiornamento dei parametri della policy è ottenuto risolvendo il seguente problema di ottimizzazione non vincolato:

\( \theta_{k+1} = \arg\max_{\theta} \, \mathcal{L}_{\theta_k}(\theta) - \beta_k \, \bar{D}_{\mathrm{KL}}(\theta \| \theta_k) \)

dove

\( \bar{D}_{\mathrm{KL}}(\theta \| \theta_k) = \mathbb{E}_{s \sim d^{\pi_k}} \left[ D_{\mathrm{KL}}\big(\pi_{\theta_k}(\cdot|s), \pi_{\theta}(\cdot|s)\big) \right]. \)

Il termine \(\beta_k\) è un coefficiente di penalità che si adatta dinamicamente tra le iterazioni per regolare quanto fortemente la nuova policy deve rimanere vicina alla precedente, in modo da rispettare un vincolo approssimato sulla divergenza KL. Questo meccanismo consente di bilanciare stabilità e velocità di apprendimento durante l’ottimizzazione della policy.

L’algoritmo PPO con penalità adattiva KL regola dinamicamente la distanza consentita tra la policy corrente e quella aggiornata, mantenendo l’ottimizzazione stabile. Il processo si articola come segue:

Input: parametri iniziali della policy \( \theta_0 \), penalità KL iniziale \( \beta_0 \), divergenza KL target \( \delta \)
Per ogni iterazione \( k = 0, 1, 2, \dots \):
- Raccogliere un set di traiettorie parziali \( \mathcal{D}_k \) secondo la policy corrente \( \pi_k = \pi(\theta_k) \)
- Stimare i vantaggi \( \hat{A}_t^{\pi_k} \) usando un algoritmo di stima dei vantaggi
- Aggiornare la policy risolvendo:
  \( \theta_{k+1} = \arg\max_{\theta} \mathcal{L}_{\theta_k}(\theta) - \beta_k \, \bar{D}_{\mathrm{KL}}(\theta \| \theta_k) \)
  mediante K passi di mini-batch SGD (ad esempio con Adam)
- Adattare la penalità KL:
  - Se \( \bar{D}_{\mathrm{KL}}(\theta_{k+1} \| \theta_k) \ge 1.5 \delta \), allora \( \beta_{k+1} = 2 \beta_k \)
  - Se \( \bar{D}_{\mathrm{KL}}(\theta_{k+1} \| \theta_k) \le \delta / 1.5 \), allora \( \beta_{k+1} = \beta_k / 2 \)

Questo approccio consente alla penalità KL di adattarsi rapidamente al comportamento della policy, senza richiedere un valore iniziale particolarmente preciso. Anche se alcune iterazioni possono violare temporaneamente il vincolo di divergenza KL, la maggior parte delle iterazioni resta entro i limiti, garantendo stabilità e miglioramento progressivo della policy.

PPO con Clipped Objective

La seconda variante di Proximal Policy Optimization (PPO) è nota come Clipped Objective, ed è stata introdotta per limitare direttamente l’entità dell’aggiornamento della policy senza richiedere un termine di penalità esplicito.

L’idea centrale è definire un rapporto di probabilità tra la nuova e la vecchia policy:

\( r_t(\theta) = \frac{\pi_{\theta}(a_t|s_t)}{\pi_{\theta_k}(a_t|s_t)} \)

A partire da questo rapporto, la nuova funzione obiettivo è definita come:

\( \mathcal{L}_{\theta_k}^{\text{CLIP}}(\theta) = \mathbb{E}_{\tau \sim \pi_k} \left[ \sum_{t=0}^{T} \min \left( r_t(\theta) \, \hat{A}_t^{\pi_k}, \, \text{clip}(r_t(\theta), 1 - \epsilon, 1 + \epsilon) \, \hat{A}_t^{\pi_k} \right) \right] \)

dove \(\epsilon\) è un iperparametro (tipicamente \(\epsilon = 0.2\)) che controlla quanto la nuova policy può differire dalla precedente. La funzione clip taglia i valori di \(r_t(\theta)\) al di fuori dell’intervallo \([1 - \epsilon, 1 + \epsilon]\), impedendo grandi variazioni nella probabilità delle azioni e garantendo stabilità.

In questo modo, PPO favorisce miglioramenti “prossimali”: la policy può evolvere verso azioni migliori, ma non troppo rapidamente, evitando così instabilità e oscillazioni. L’aggiornamento dei parametri avviene quindi massimizzando:

\( \theta_{k+1} = \arg\max_{\theta} \, \mathcal{L}_{\theta_k}^{\text{CLIP}}(\theta) \)

Questa formulazione ha il vantaggio di mantenere la semplicità computazionale e la stabilità del metodo, eliminando la necessità di regolare dinamicamente un termine di penalità, come avviene nella variante con KL adattiva.

Il grafico a sinistra mostra \(\mathcal{L}^{\text{CLIP}}\) quando la funzione di vantaggio A>0 e il grafico sulla destra quando A<0:

Il meccanismo di clipping nel PPO serve a mantenere la nuova policy vicina a quella precedente, rendendo la funzione obiettivo più “pessimistica” rispetto alle performance ottenute quando la nuova policy si allontana troppo dai parametri originali \( \theta_k \).

In altre parole, il clipping limita l’effetto delle variazioni eccessive di \( r_t(\theta) = \pi_{\theta}(a_t|s_t)/\pi_{\theta_k}(a_t|s_t) \) sulla funzione di vantaggio \( \hat{A}_t \). Quando l’aggiornamento della policy produce un valore di \( r_t(\theta) \) troppo grande o troppo piccolo, la funzione obiettivo viene “tagliata” (clipped), riducendo il contributo positivo al gradiente e scoraggiando aggiornamenti troppo aggressivi.

Il grafico riportato mostra il confronto tra diverse funzioni obiettivo in funzione del fattore di interpolazione lineare \( \alpha \) tra i parametri \( \theta_{k+1} \) e \( \theta_k \) dopo un aggiornamento con PPO-Clip:

\( \hat{\mathbb{E}}_t[\mathrm{KL}_t] \): rappresenta la divergenza KL tra le policy.
\( L^{\mathrm{CPI}} = \hat{\mathbb{E}}_t[r_t A_t] \): l’obiettivo del classico policy gradient.
\( \hat{\mathbb{E}}_t[\text{clip}(r_t, 1 - \epsilon, 1 + \epsilon)A_t] \): la versione con valori tagliati (clipped).
\( L^{\mathrm{CLIP}} = \hat{\mathbb{E}}_t[\min(r_t A_t, \text{clip}(r_t, 1 - \epsilon, 1 + \epsilon)A_t)] \): l’obiettivo finale usato da PPO.

Dal confronto emerge che \( L^{\mathrm{CLIP}} \) cresce più lentamente e si appiattisce rispetto a \( L^{\mathrm{CPI}} \) quando la policy si allontana, garantendo così una maggiore stabilità e impedendo aggiornamenti eccessivi che potrebbero compromettere la performance complessiva.

In sintesi, il clipping introduce un controllo automatico sulla magnitudine degli aggiornamenti della policy, rendendo l’ottimizzazione più stabile e prevenendo la divergenza del modello.

L’algoritmo PPO con Clipped Objective rappresenta una delle versioni più efficaci e semplici del Proximal Policy Optimization. A differenza della variante con penalità KL, questo metodo controlla implicitamente la distanza tra le policy successive attraverso il meccanismo di “clipping” applicato alla funzione obiettivo.

Input: parametri iniziali della policy \( \theta_0 \), soglia di clipping \( \epsilon \)
Per ogni iterazione \( k = 0, 1, 2, \dots \):
- Raccogliere un insieme di traiettorie parziali \( \mathcal{D}_k \) eseguendo la policy \( \pi_k = \pi(\theta_k) \)
- Stimare i vantaggi \( \hat{A}_t^{\pi_k} \) usando un algoritmo di stima appropriato
- Aggiornare la policy risolvendo:
  \( \theta_{k+1} = \arg\max_{\theta} \mathcal{L}_{\theta_k}^{\text{CLIP}}(\theta) \)
  attraverso K passi di mini-batch SGD (ad esempio con l’ottimizzatore Adam)
- La funzione obiettivo è definita come:
  \( \mathcal{L}_{\theta_k}^{\text{CLIP}}(\theta) = \mathbb{E}_{\tau \sim \pi_k} \left[ \sum_{t=0}^{T} \min \left( r_t(\theta) \hat{A}_t^{\pi_k}, \text{clip}(r_t(\theta), 1 - \epsilon, 1 + \epsilon)\hat{A}_t^{\pi_k} \right) \right] \)

Il termine di clipping evita che la nuova policy si discosti troppo da quella precedente \( \pi_k \), impedendo aggiornamenti eccessivi che potrebbero portare a una perdita di stabilità o a un peggioramento delle prestazioni.

In pratica:

Il clipping riduce l’incentivo della policy a compiere grandi variazioni nei parametri tra un aggiornamento e l’altro.
Le performance risultano comparabili, se non migliori, rispetto alla variante con penalità KL, pur mantenendo una implementazione più semplice e robusta.

Generalized Advantage Estimator (GAE)

Per introdurre quello è che l'Advantage estimator utilizzato nel PPO, è utile partire dai cosiddetti N-step advantage estimators, che rappresentano un modo per stimare il vantaggio di una determinata azione tenendo conto di un numero variabile di passi futuri.

Consideriamo inizialmente la definizione di vantaggio a un passo:

\( \hat{A}^{(1)}_t = r_t + \gamma V(s_{t+1}) - V(s_t) \)

Questa espressione misura quanto la ricompensa immediata e il valore previsto del prossimo stato superino (o meno) il valore dello stato attuale. Possiamo migliorarla includendo più passi futuri:

\( \hat{A}^{(2)}_t = r_t + \gamma r_{t+1} + \gamma^2 V(s_{t+2}) - V(s_t) \)

e, più in generale, per un orizzonte infinito:

\( \hat{A}^{(\infty)}_t = r_t + \gamma r_{t+1} + \gamma^2 r_{t+2} + \cdots - V(s_t) \)

Definiamo ora un termine più compatto per rappresentare la differenza temporale corretta dal valore, noto come errore di vantaggio a un passo:

\( \delta_t^V = r_t + \gamma V(s_{t+1}) - V(s_t) \)

Con questa notazione, possiamo riscrivere i vantaggi a più passi come somme pesate di questi termini:

\( \hat{A}^{(1)}_t = \delta_t^V \)
\( \hat{A}^{(2)}_t = \delta_t^V + \gamma \delta_{t+1}^V \)
In generale: \( \hat{A}^{(k)}_t = \sum_{l=0}^{k-1} \gamma^l \delta_{t+l}^V \)

Questa formulazione evidenzia come ciascun termine derivi da una somma telescopica, cioè una sequenza in cui molti termini intermedi si cancellano, lasciando una forma compatta e facilmente computabile. È proprio da questa struttura che il GAE deriva, introducendo un ulteriore fattore di pesatura esponenziale per controllare il compromesso tra bias e varianza nella stima del vantaggio.

Partendo dal vantaggio a \(k\) passi definito come:

\( \hat{A}^{(k)}_t = \sum_{l=0}^{k-1} \gamma^l r_{t+l} + \gamma^k V(s_{t+k}) - V(s_t) \)

il GAE viene definito come una media esponenzialmente pesata di questi stimatori a più passi:

\( \hat{A}^{\text{GAE}(\gamma, \lambda)}_t = (1 - \lambda) \left( \hat{A}^{(1)}_t + \lambda \hat{A}^{(2)}_t + \lambda^2 \hat{A}^{(3)}_t + \dots \right) \)

Sostituendo la definizione di A in termini di differenze temporali \( \delta^V_t = r_t + \gamma V(s_{t+1}) - V(s_t) \) , si ottiene una forma più compatta:

\( \hat{A}^{\text{GAE}(\gamma, \lambda)}_t = \sum_{l=0}^{\infty} (\gamma \lambda)^l \, \delta^V_{t+l} \)

Il risultato è un vantaggio che combina i termini futuri con un peso esponenzialmente decrescente, dove il parametro \( \lambda \in [0,1] \) controlla la velocità di decadimento: valori piccoli di lambda privilegiano le ricompense immediate (riducendo la varianza ma introducendo più bias), mentre valori prossimi a 1 tengono conto di orizzonti più lunghi (riducendo il bias ma aumentando la varianza).

In sostanza, il GAE realizza una somma geometrica delle differenze temporali successive, costruendo una stima del vantaggio che è più stabile e più efficiente per l’ottimizzazione della policy rispetto ai metodi tradizionali a passo singolo o multi-step.

PPO utilizza una versione troncata di GAE, \(\displaystyle \hat{A}_t=\sum_{l=0}^{T-t-1}(\gamma \lambda)^l \delta^V_{t+l}\) , che prevede quindi di eseugire la policy solo per T timestep prima di aggiornare la stima del gradiente.

Crescita Monotonica del PPO

Come abbiamo visto la differenza di performance tra due policy può essere approssimata usando la distribuzione di visita degli stati della policy corrente. In particolare, vale \( \mathcal{L}_{\pi}(\pi') \), ottenuta assumendo \( d^{\pi'} \approx d^{\pi} \). La bontà di questa approssimazione è garantita quando le due policy sono “vicine” in divergenza di Kullback–Leibler: abbiamo infatti già visto il bound di prestazione relativa

\( \big|\, J(\pi') - \big(J(\pi)+\mathcal{L}_{\pi}(\pi')\big) \,\big| \;\le\; C \sqrt{ \mathbb{E}_{s\sim d^{\pi'}}\!\left[ D_{\mathrm{KL}}\!\left(\pi'\,\|\,\pi\right)[s]\right] }\, . \)

Da questo segue un vincolo inferiore (miglioramento monotono approssimato):

\( J(\pi') - J(\pi) \;\ge\; \mathcal{L}_{\pi}(\pi') \;-\; C \sqrt{ \mathbb{E}_{s\sim d^{\pi'}}\!\left[ D_{\mathrm{KL}}\!\left(\pi'\,\|\,\pi\right)[s]\right] } \, . \)

Da ciò vediamo che se massimizziamo il lato destro rispetto a \( \pi' \), otteniamo un aggiornamento di policy che garantisce miglioramento rispetto a \( \pi \) (finché la divergenza KL resta piccola). Sia \( \mathcal{L}_{\pi}(\pi') \) sia il termine KL si possono stimare con traiettorie campionate dalla policy corrente \( \pi \).

La garanzia di miglioramento monotono si basa sul fatto che, a ogni iterazione, la nuova policy \( \pi_{k+1} \) è ottenuta massimizzando un obiettivo surrogato penalizzato:

\( \pi_{k+1} = \arg\max_{\pi'} \left[\, \mathcal{L}_{\pi_k}(\pi') - C \sqrt{ \mathbb{E}_{s \sim d^{\pi_k}} \!\left[ D_{\mathrm{KL}}(\pi' \| \pi_k)[s] \right] } \,\right]. \)

Poiché la policy corrente \( \pi_k \) è un punto ammissibile del dominio di ottimizzazione, possiamo verificare che:

La funzione surrogata ha valore nullo nel punto corrente: \( \mathcal{L}_{\pi_k}(\pi_k) \propto \mathbb{E}_{s,a \sim d^{\pi_k},\,\pi_k}[A^{\pi_k}(s,a)] = 0. \)
La penalità di divergenza è anch’essa nulla: \( D_{\mathrm{KL}}(\pi_k \| \pi_k)[s] = 0. \)

Ne consegue che il valore ottimo della funzione obiettivo (ottenuto per \( \pi_{k+1} \)) non può essere inferiore a quello calcolato in \( \pi_k \), cioè:

\( \text{valore ottimo} \ge 0 \;\;\Rightarrow\;\; J(\pi_{k+1}) - J(\pi_k) \ge 0. \)

In altre parole, a ogni passo di aggiornamento la performance della policy non peggiora. Questa dimostrazione resta valida anche se si restringe il dominio di ottimizzazione a una famiglia parametrica di policy \( \Pi_{\theta} \), purché \( \pi_k \in \Pi_{\theta} \).

L’aggiornamento della policy può essere definito come la massimizzazione dell’obiettivo surrogato penalizzato dalla divergenza di Kullback–Leibler:

\( \pi_{k+1} = \arg\max_{\pi'} \left[ \, \mathcal{L}_{\pi_k}(\pi') - C \sqrt{ \mathbb{E}_{s \sim d^{\pi_k}} \!\left[ D_{\mathrm{KL}}(\pi' \| \pi_k)[s] \right] } \, \right]. \)

Il problema in questo tipo di approccio è che Il coefficiente teorico \( C \) risulta molto elevato quando il fattore di sconto \( \gamma \) è vicino a 1, di conseguenza, i passi di aggiornamento derivanti dall’equazione risultano eccessivamente piccoli, rallentando l’apprendimento.

Le soluzioni sono regolare dinamicamente la penalità KL, approccio che porta alla formulazione già vista del del metodo PPO (Proximal Policy Optimization), o imporre un vincolo esplicito sulla divergenza KL, introducendo una trust region come in TRPO (Trust Region Policy Optimization), per controllare direttamente l’ampiezza del passo di aggiornamento.

Entrambi gli approcci mirano a mantenere un equilibrio tra stabilità e velocità di apprendimento, evitando sia aggiornamenti troppo conservativi sia cambiamenti eccessivamente drastici della policy.

Il risultato fornisce quindi una base teorica per gli algoritmi di ottimizzazione di policy (come TRPO e PPO), garantendo un miglioramento monotono — o almeno non negativo — della funzione di performance a ogni iterazione.

RL - Policy Gradient Methods

Martedì, 22 Settembre 2026 | Reinforcement Learning |

I metodi Policy Gradient prescindono da un approccio basato sulla definizione della policy a partire dal'approssimazione una funzione di stato V(s) o di stato-azione Q(s,a) anche attraverso la loro parametrizzazione, e provano a parametrizzare direttamente la policy stocastica \(\pi_\theta(s,a)=\Bbb P[a|s;\theta]\) con l'obiettivo di trovare una policy che massimizzi la funzione di valore \(V^\pi\) , apprendendo dall'esperienza in ottica model-free.

I metodi Policy Based nella quale si apprende direttamnete una policy, si contrappongono quindi ai metodi Value Based, nella quale si apprende una funzione di Valore dalla quale si ricava una policy in modo implicito (es: \(\epsilon\)-greedy). Vi sono poi metodi Actor-Critic a cavallo tra le due tipologie nelle quale si apprendono sia la Funzione di Valore che la Policy.

In un contesto Policy Based, come misurare la qualità di una policy? In un ambiente episodico potremmo utilizzare il valore della policy allo stato di partenza \(V(s_0,\theta)\) , approccio che può essere esteso al caso di un orizzonte infinito.

Il problema di massimizzare \(V(s_0,\theta)\) è di un problema di ottimizzazione complesso, perchè non conosciamo la funzione , la possiamo solo stimare attraverso i dati; non abbiamo quindi idea di come \(\theta\) si relaziona a V, relazione che è oggetto di apprendimento.

Nel reinforcement learning basato su policy il problema è di ottimizzazione, ovvero trovare i parametri \(\theta\) che massimizzano \(V(s_0,\theta)\).

Si possono usare metodi di ottimizzazione senza gradiente, ma spesso l’uso del gradiente consente maggiore efficienza. Tra i principali approcci troviamo: discesa del gradiente, gradiente coniugato e metodi quasi-Newton.

Quando il gradiente è difficile o costoso da stimare, si possono usare metodi di ottimizzazione senza gradiente, tra cui: hill climbing, simplex/Nelder–Mead, algoritmi genetici, Cross-Entropy Method (CEM) e Covariance Matrix Adaptation (CMA).

L’attenzione è rivolta in particolare alla discesa del gradiente, che può essere estesa in varie forme, e ai metodi che sfruttano la struttura sequenziale del problema.

Nel reinforcement learning basato su policy il problema si formula quindi come un’ottimizzazione: occorre trovare i parametri della policy \(\theta\) che massimizzano il valore atteso a partire dallo stato iniziale, \(V(s_0,\theta)\).

Si definisce \(V^{\pi^\theta} = V(s_0,\theta)\) per rendere esplicita la dipendenza del valore dai parametri della policy. Si assume un contesto di MDP episodici.

Gli algoritmi di policy gradient cercano un massimo locale di \(V(s_0,\theta)\) risalendo il gradiente della policy rispetto ai parametri \(\theta\):

\(\Delta \theta = \alpha \nabla_\theta V(s_0,\theta)\) , con il policy gradient \( \nabla_\theta V(s_0,\theta) = \begin{pmatrix} \frac{\partial V(s_0,\theta)}{\partial \theta_1} \\ \vdots \\ \frac{\partial V(s_0,\theta)}{\partial \theta_n} \end{pmatrix} \) e \(\alpha\) il parametro di passo (step-size).

I metodi di policy gradient presentano alcuni vantaggi: migliori proprietà di convergenza, efficacia in spazi d’azione ad alta dimensionalità o continui e la capacità di apprendere policy stocastiche.

Tra gli svantaggi vi è la tendenza a convergere a un ottimo locale piuttosto che globale, e la valutazione della policy che risulta spesso inefficiente e caratterizzata da alta varianza.

Policy differenziabile

Calcoliamo il policy gradient analiticamente, assumendo che \(\pi_\theta\) sia differenziabile quando non nulla, che possiamo calcolare il gradiente \(\nabla_\theta \pi_\theta(s,a)\) analiticamente.

In questa categoria rientrano molte classi di policy differenziabili p(a|s), quali softmax, la Gaussiana, e le reti neurali.

Assumendo quindi che la policy \(\pi_\theta\) sia differenziabile quando non è nulla e che sia noto il gradiente \(\nabla_\theta \pi_\theta(s,a)\), il valore della policy è definito come \(V(s_0,\theta) = \mathbb{E}_{\pi_\theta}\left[\sum_{t=0}^T R(s_t,a_t);\, \pi_\theta, s_0\right]\), dove l’aspettativa è calcolata sugli stati e le azioni visitati da \(\pi_\theta\).

Questa definizione può essere espressa in modi equivalenti:

\(V(s_0,\theta) = \sum_a \pi_\theta(a|s_0)\, Q(s_0,a,\theta)\)
\(V(s_0,\theta) = \sum_\tau P(\tau;\theta)\,R(\tau)\), dove \(\tau = (s_0,a_0,\ldots,s_T,a_T,r_T)\) è una traiettoria stato-azione, \(P(\tau;\theta)\) indica la probabilità della traiettoria sotto la policy \(\pi_\theta\) a partire da \(s_0\), e \(R(\tau) = \sum_{t=0}^T R(s_t,a_t)\) è la somma delle ricompense per la traiettoria \(\tau\).

Adottando questa formulazione l'obiettivo è quello di trovare i parameteri della policy \(\theta \) che soddisfano \(\displaystyle \arg \max_\theta V(\theta) = \arg \max_\theta \sum_\tau P(\tau;\theta)\,R(\tau)\)

Calcolando il gradiente di \(V(\theta)\) rispetto ai parametri \(\theta\) abbiamo:

\[ \nabla_\theta V(\theta) = \nabla_\theta \sum_\tau P(\tau;\theta) R(\tau) = \sum_\tau \nabla_\theta P(\tau;\theta) R(\tau). \]

\[ \nabla_\theta V(\theta) = \sum_\tau P(\tau;\theta) R(\tau) \frac{\nabla_\theta P(\tau;\theta)}{P(\tau;\theta)}. \] Il rapporto \(\frac{\nabla_\theta P(\tau;\theta)}{P(\tau;\theta)}\) è noto come likelihood ratio,

\[ \nabla_\theta V(\theta) = \sum_\tau P(\tau;\theta) R(\tau)\,\nabla_\theta \log P(\tau;\theta). \]

Per approssimare il gradiente della funzione valore \(V(\theta)\), si utilizza una stima empirica basata su \(m\) traiettorie campionate dalla politica \(\pi_\theta\). In questo modo:

\[ \nabla_\theta V(\theta) \approx \hat{g} = \frac{1}{m} \sum_{i=1}^m R(\tau^{(i)}) \, \nabla_\theta \log P(\tau^{(i)};\theta) \]

dove \(R(\tau^{(i)})\) rappresenta il ritorno della traiettoria \(\tau^{(i)}\). Questa formulazione consente di stimare il gradiente tramite campionamento Monte Carlo.

Per calcolare \(\nabla_\theta \log P(\tau^{(i)};\theta)\), possiamo scomporre la probabilità della traiettoria \(\tau^{(i)}\) nei suoi elementi costitutivi:

\( \nabla_\theta \log P(\tau^{(i)};\theta) = \nabla_\theta \log \Bigg[ \mu(s_0) \prod_{t=0}^{T-1} \pi_\theta(a_t|s_t) P(s_{t+1}|s_{0:t},a_{0:t}) \Bigg] \)

Espandendo il logaritmo:

\( = \nabla_\theta \left[ \log \mu(s_0) + \sum_{t=0}^{T-1} \log \pi_\theta(a_t|s_t) + \log P(s_{t+1}|s_{0:t},a_{0:t}) \right] \)

Poiché né la distribuzione iniziale \(\mu(s_0)\) né il modello dinamico \(P(s_{t+1}|s_{0:t},a_{0:t})\) dipendono dai parametri \(\theta\), i loro gradienti sono nulli. Rimane quindi:

\(\displaystyle \nabla_\theta \log P(\tau^{(i)};\theta) = \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) \)

e quindi \(\displaystyle \nabla_\theta V(\theta) = \frac{1}{m} \sum_{i=1}^m R(\tau^{(i)}) \, \sum_{t=0}^{T-1}\nabla_\theta \log \pi_\theta(a_t^{(i)}|s_t^{(i)}) \)

Il risultato mostra che non è necessario conoscere il modello dinamico dell’ambiente: il gradiente dipende unicamente dalla politica \(\pi_\theta\).

Policy Softmax

Vediamo ad esempio il calcolo della score function \(\nabla_\theta \log \pi_\theta(s,a)\) con una Softmax Policy della forma \(\displaystyle \pi_\theta (s,a)=\frac{e^{[s,a]^\top \theta}}{\sum_a e^{[s,a]^\top \theta}}\)

\(\nabla_\theta \log \frac{e^{[s,a]^\top \theta}}{\sum_a e^{[s,a]^\top \theta}} = \nabla_\theta \left[ \log {e^{[s,a]^\top \theta}} - \log {\sum_a e^{[s,a]^\top \theta}} \right]= \\ = [s,a] - \frac{{\sum_a [s,a]e^{[s,a]^\top \theta}}}{\sum_a e^{[s,a]^\top \theta}}=[s,a]-\sum_a [s,a] \pi_\theta(s,a)=[s,a]-\Bbb E_{\pi_\theta}[s,\cdot]\)

Policy Gaussiana

Negli spazi di azione continui, una policy gaussiana rappresenta una scelta naturale. In questo caso, la media è definita come combinazione lineare delle caratteristiche dello stato: \(\mu(s) = \phi(s)^\top \theta\). La varianza \(\sigma^2\) può essere fissata oppure parametrizzata. La politica assume quindi la forma gaussiana: \(a \sim \mathcal{N}(\mu(s), \sigma^2)\) , ed in forma analitica \(\displaystyle \pi_\theta(s,a)=\frac{1}{\sqrt{2\pi \sigma^2}} e^{- \frac{(a-\phi(s)^\top \theta)^2}{2 \sigma^2}}\)

La funzione punteggio (score function) associata è:

\[ \nabla_\theta \log \pi_\theta(s,a) = \frac{(a - \mu(s)) \, \phi(s)}{\sigma^2} \]

Intuizione e teorema del policy gradient

Consideriamo la forma generica \(\hat{g}_i = f(x_i)\nabla_\theta \log p(x_i|\theta)\). \(f(x)\) misura la ricompensa, ovvero quanto è buona la traiettoria campione \(x\). Muoversi nella direzione di \(\hat{g}_i\) significa aumentare la probabilità logaritmica del campione in proporzione alla sua qualità.

Questo approccio rimane valido anche se \(f(x)\) è discontinua, sconosciuta, oppure se lo spazio dei campioni che contiene \(x\) è un insieme discreto.

Il policy gradient theorem generalizza l’approccio del likelihood ratio. Per qualsiasi policy differenziabile \(\pi_\theta(s,a)\) e per qualunque funzione obiettivo della policy \(J\) (che può rappresentare la ricompensa episodica \(J_1\), la ricompensa media per passo temporale \(J_{avR}\), oppure il valore medio \(\tfrac{1}{1-\gamma} J_{avV}\)), il gradiente della policy è dato da:

\[ \nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta}\left[\nabla_\theta \log \pi_\theta(s,a) Q^{\pi_\theta}(s,a)\right] \]

Struttura Temporale della Score function e algoritmo REINFORCE

In precedenza è stato mostrato che il gradiente del valore atteso delle ricompense totali può essere scritto come:

\( \nabla_\theta \mathbb{E}_\tau[R] = \mathbb{E}_\tau \left[ \left( \sum_{t=0}^{T-1} r_t \right) \left( \sum_{t=0}^{T-1} \nabla_\theta \log \pi_\theta(a_t|s_t) \right) \right] \)

Che come abbiamo visto ha

Lo stesso argomento può essere applicato per stimare il gradiente di una singola ricompensa \(r_{t'}\):

\( \nabla_\theta \mathbb{E}[r_{t'}] = \mathbb{E}\left[ r_{t'} \sum_{t=0}^{t'} \nabla_\theta \log \pi_\theta(a_t|s_t) \right] \) , non entrando nel gradiente la score function relativa ai time step successivi.

Sommando questa formula su tutti i valori di \(t\), otteniamo:

\(\nabla_\theta \mathbb{E}[R] = \mathbb{E}\left[ \sum_{t'=0}^{T-1} r_{t'} \sum_{t=0}^{t'} \nabla_\theta \log \pi_\theta(a_t|s_t) \right] \)

e osservando quando vengono coinvolti i termini della score function otteniamo infine

\(\nabla_\theta \mathbb{E}[R] = \mathbb{E}\left[ \sum_{t=0}^{T-1}\nabla_\theta \log \pi_\theta(a_t|s_t) \sum_{t'=t}^{T-1} r_{t'} \right] \)

che evidenzia che il contributo della score function al time step t incide solo per gli step \(t'\ge t\).

Nel caso di un campionamento, ricordando che per una particolare traiettoria \(\tau^{(i)}\) il ritorno a partire da un timestep t è \(G_t^{(i)}=\sum_{t'=t}^{T-1}{r_{t'}^{(i)}} \) , abbiamo perciò

\(\displaystyle \nabla_\theta \mathbb{E}[R] \approx \frac{1}{m} \sum_{i=1}^m \sum_{t=0}^{T-1}\nabla_\theta \log \pi_\theta(a_t|s_t) G_t^{(i)}\)

relazione alla base dell'algoritmo REINFORCE, che stima il gradiente utilizzando la score function e la struttura temporale delle traiettorie.
L’aggiornamento dei parametri della policy diviene \( \Delta \theta_t = \alpha \nabla_\theta \log \pi_\theta(s_t,a_t)\, G_t \), dove \( G_t \) rappresenta il ritorno a partire dal tempo \( t \).

Algoritmo REINFORCE:

Inizializza i parametri della policy \( \theta \) in modo arbitrario.
Per ogni episodio campionato secondo la policy corrente \( \pi_\theta \) (sequenza \( \{s_1,a_1,r_2,\ldots,s_{T-1},a_{T-1},r_T\} \)):
- Per \( t=1,\ldots,T-1 \):
  - Calcola o aggiorna il ritorno \( G_t \) a partire dal tempo \( t \).
  - Aggiorna i parametri secondo la regola di ascesa del gradiente: \( \theta \leftarrow \theta + \alpha \,\nabla_\theta \log \pi_\theta(s_t,a_t)\, G_t \).
Restituisci i parametri finali \( \theta \).

Baseline

Per ridurre ulteriormente la varianza della stima del gradiente, si può introdurre una baseline \( b(s) \), dipendente solo dallo stato. L’espressione generale del gradiente diventa:

\( \nabla_\theta \mathbb{E}_\tau[R] = \mathbb{E}_\tau \left[ \sum_{t=0}^{T-1} \nabla_\theta \log \pi(a_t|s_t;\theta) \left( \sum_{t'=t}^{T-1} r_{t'} - b(s_t) \right) \right] \)

Per qualunque scelta della funzione di baseline \( b(s_t) \), lo stimatore del gradiente rimane non distorto (unbiased). Tuttavia, una scelta adeguata di \( b(s_t) \) può ridurre significativamente la varianza e migliorare la stabilità dell’apprendimento.

Una scelta quasi ottimale per la baseline è il valore atteso del ritorno a partire dallo stato \( s_t \):

\( b(s_t) \approx \mathbb{E}[r_t + r_{t+1} + \cdots + r_{T-1}] \)

L’interpretazione intuitiva è che l’algoritmo aumenta la probabilità logaritmica dell’azione \( a_t \) in proporzione a quanto il ritorno ottenuto da quel punto in poi (\( \sum_{t'=t}^{T-1} r_{t'} \)) sia superiore rispetto al valore atteso. In altre parole, le azioni che portano risultati migliori della media vengono rafforzate, mentre quelle peggiori vengono penalizzate.

La dimostrazione seguente mostra in modo dettagliato che l’aggiunta di una baseline \( b(s_t) \) non altera la correttezza dello stimatore del gradiente, poiché il suo contributo ha valore atteso nullo:

\( \mathbb{E}_\tau[\nabla_\theta \log \pi(a_t|s_t;\theta)\, b(s_t)] = 0 \)

I passaggi sono i seguenti:

\( \mathbb{E}_\tau[\nabla_\theta \log \pi(a_t|s_t;\theta)\, b(s_t)] = \mathbb{E}_{s_{0:t}, a_{0:(t-1)}} \left[ \mathbb{E}_{s_{t+1:T}, a_{t:T-1}} \left[ \nabla_\theta \log \pi(a_t|s_t;\theta)\, b(s_t) \right] \right] \) (scomposizione del valore atteso lungo la traiettoria)

\( = \mathbb{E}_{s_{0:t}, a_{0:(t-1)}} \left[ b(s_t) \, \mathbb{E}_{s_{t+1:T}, a_{t:T-1}} \left[ \nabla_\theta \log \pi(a_t|s_t;\theta) \right] \right] \) (estrazione del termine \( b(s_t) \) che non dipende da \( a_t \))

\( = \mathbb{E}_{s_{0:t}, a_{0:(t-1)}} \left[ b(s_t) \, \mathbb{E}_{a_t} [\nabla_\theta \log \pi(a_t|s_t;\theta)] \right] \) (si rimuovono le variabili irrilevanti rispetto a \( s_t, a_t \))

Ora utilizziamo la forma esplicita della likelihood ratio:

\( \mathbb{E}_{a_t} [\nabla_\theta \log \pi(a_t|s_t;\theta)] = \sum_a \pi_\theta(a|s_t) \, \nabla_\theta \log \pi_\theta(a|s_t) \)

Poiché \( \nabla_\theta \log \pi_\theta(a|s_t) = \frac{\nabla_\theta \pi_\theta(a|s_t)}{\pi_\theta(a|s_t)} \), si ha:

\( \sum_a \pi_\theta(a|s_t) \, \frac{\nabla_\theta \pi_\theta(a|s_t)}{\pi_\theta(a|s_t)} = \sum_a \nabla_\theta \pi_\theta(a|s_t) \)

Il gradiente della somma delle probabilità è nullo, poiché la loro somma è sempre 1:

\(\nabla_\theta \sum_a \pi_\theta(a|s_t) = \nabla_\theta [1] = 0 \)

Sostituendo nel calcolo originale otteniamo:

\( \mathbb{E}_\tau[\nabla_\theta \log \pi(a_t|s_t;\theta)\, b(s_t)] = \mathbb{E}_{s_{0:t}, a_{0:(t-1)}}[b(s_t) \cdot 0] = 0 \)

In conclusione, il termine della baseline non contribuisce al valore atteso del gradiente, ma solo alla sua varianza. Ciò garantisce che lo stimatore rimanga non distorto (unbiased), migliorando al contempo la stabilità numerica e l’efficienza della stima.

L'integrazione della baseline ci permette di giungere alla versione base degli attuali algoritmi di policy optimization nel reinforcement learning. Si tratta di un metodo iterativo che aggiorna i parametri della policy in direzione del gradiente stimato, utilizzando un insieme di traiettorie campionate e una baseline per ridurre la varianza.

Lo schema operativo dell’algoritmo può essere riassunto come segue:

Inizializza i parametri della policy \( \theta \) e la baseline \( b \).
Per ogni iterazione \( i = 1, 2, \ldots \):
- Raccogli un insieme di traiettorie eseguendo la policy corrente \( \pi_\theta \).
- Per ogni istante temporale \( t \) e per ogni traiettoria \( \tau^i \), calcola:
  - il ritorno cumulativo: \( G_t^i = \sum_{t'=t}^{T-1} r_{t'}^i \)
  - la stima dell’advantage: \( \hat{A}_t^i = G_t^i - b(s_t^i) \)
- Adatta la baseline minimizzando l’errore quadratico medio tra i ritorni osservati e la baseline: \( \min_b \sum_i \sum_t |b(s_t^i) - G_t^i|^2 \)
- Aggiorna la policy utilizzando una stima del gradiente medio: \( \hat{g} = \sum_t \nabla_\theta \log \pi(a_t|s_t; \theta)\, \hat{A}_t \)
- L’aggiornamento dei parametri può essere implementato con ottimizzatori come SGD o Adam.

Questo approccio è definito “vanilla” perché applica direttamente il gradiente stimato senza correzioni o adattamenti avanzati (come nel caso di algoritmi più evoluti quali TRPO o PPO). Nonostante la sua semplicità, costituisce la base concettuale per tutte le varianti moderne di policy gradient.

Per quanto riguarda la scelta della baseline , una alternativa naturale ricordando la funzione di valore stato-azione \(Q^\pi(s,a)=\Bbb E_\pi [r_0+\gamma r_1+\gamma^2 r_2 + \cdots | s_0=s, a_0=a] \) è proprio la funzione di valore di stato \(V^\pi(s)=\Bbb E_\pi [r_0+\gamma r_1+\gamma^2 r_2 + \cdots | s_0=s] =\Bbb E_{a\sim \pi}[Q^\pi(s,a)]\)

Alternative all'utilizzo dei ritorni Monte Carlo

Una strategia alternativa all'utilizzo di \(G^i_t \) , stima della funzione di valore a \(s_t\) da campionamento, unbiased ma con alta varianza, è quella di utilizzare il bootstrapping e l'approssimazione di funzione, al prezzo di reintrodurre bias.

Questo presuppone un approccio attore/critico (Actor/Critic), dove la stima di Q è fatta da un critico e quella della policy da un attore attraverso i parametri \(\theta\) .

\( \nabla_\theta \mathbb{E}_\tau[R] \approx \mathbb{E}_\tau \left[ \sum_{t=0}^{T-1} \nabla_\theta \log \pi(a_t|s_t;\theta) \left( Q(s_t,a_t;w) - b(s_t) \right) \right] \)

Nel caso in cui la baseline sia una stima di V, possiamo rappresentare il gradiente in termini della funzione di vantaggio stato-azione \(A^\pi(s,a)=Q^\pi(s,a)-V^\pi(s)\) come \( \nabla_\theta \mathbb{E}_\tau[R] \approx \mathbb{E}_\tau \left[ \sum_{t=0}^{T-1} \nabla_\theta \log \pi(a_t|s_t;\theta) \hat {A^\pi} (s_t,a_t) \right] \)

Limiti dell'approccio Policy Gradient

\( \max_\theta J(\pi_\theta) \doteq \mathbb{E}_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{\infty} \gamma^t r_t \right] \)

Per risolvere questo problema, si applica l’ascesa stocastica del gradiente rispetto ai parametri della policy, utilizzando il gradiente di policy definito come:

\( g = \nabla_\theta J(\pi_\theta) = \mathbb{E}_{\tau \sim \pi_\theta} \left[ \sum_{t=0}^{\infty} \gamma^t \nabla_\theta \log \pi_\theta(a_t|s_t) A^{\pi_\theta}(s_t, a_t) \right] \)

Limitazioni dei metodi di Policy Gradient

Evidenziamo due limitazioni principali del metodo "vanilla" di Policy Gradient_

Bassa efficienza del campionamento: per stimare accuratamente il gradiente è necessario raccogliere molte traiettorie di interazione con l’ambiente, rendendo il processo lento e costoso, con limitato riuso.
Lo spazio dei parametri non coincide con lo spazio delle policy: piccoli cambiamenti nei parametri \( \theta \) possono corrispondere a variazioni molto grandi o molto piccole nel comportamento della policy. Nel caso tabulare, lo spazio delle policy può essere descritto come l’insieme di tutte le matrici di probabilità \( \Pi = \left\{ \pi : \pi \in \mathbb{R}^{|S| \times |A|}, \ \sum_a \pi_{sa} = 1, \ \pi_{sa} \ge 0 \right\} \).
Poiché gli aggiornamenti vengono effettuati sui parametri \( \theta \) e non direttamente sulle probabilità, non è garantito che un piccolo passo in \( \theta \) corrisponda a una piccola variazione della policy. Ciò comporta che la dimensione del passo (learning rate) sia critica e difficile da regolare, poiché un valore troppo grande può far divergere la policy, mentre uno troppo piccolo rallenta drasticamente la convergenza.

Idealmente, vogliamo quindi un aggiornamento che:

utilizzi in modo efficiente i rollouts raccolti dalla policy più recente;
faccia passi di aggiornamento che rispettino la distanza nello spazio delle policy, garantendo una transizione stabile da una policy all’altra.