Policy gradient e PPO: imparare direttamente la politica

Politica stocastica come rete, REINFORCE e teorema del gradiente della politica, baseline e vantaggio, attore-critico, PPO con clipping scritto da zero sul pendolo inverso su un carrello, che cosa succede senza clipping, e come PPO ha rifinito i modelli linguistici.

12 minuti Matěj Žalmánek 2026-10-16

Serie Basi di IA Parte 49 di 52

Programma completo della serie 52 di 83 argomenti pubblicati

Cosa porterai a casa

Come si impara una politica direttamente dai risultati, senza una tabella di valori.
Perché aiuta sottrarre una baseline e che cos’è il vantaggio.
Perché il clipping in PPO è così importante e che legame ha con l’RLHF.

Utile sapere prima: Q-learning e DQN: imparare il valore delle azioni, dalla tabella alla rete neurale, Processi decisionali di Markov: stati, azioni, ricompense ed equazioni di Bellman

Il DQN della parte precedente impara quanto è buona ciascuna azione, e la politica ne deriva solo indirettamente: scegli l’azione con il valore più alto. La seconda grande famiglia di metodi va dritta al punto: la rete riceve lo stato e restituisce le probabilità delle azioni, e noi spostiamo queste probabilità in modo che le azioni buone diventino più frequenti. Da questa famiglia viene PPO — l’algoritmo che ha insegnato ai robot a camminare, ha battuto i professionisti a Dota 2 e c’era dietro il fine-tuning di ChatGPT. In questa parte lo scriviamo da zero e lo confrontiamo con i suoi predecessori più semplici.

Si collega alle parti Q-learning e DQN, Processi decisionali di Markov e Softmax.

1. Imparare direttamente la politica

Definizione — politica parametrizzata

Una politica stocastica π_θ(a | s) è una rete con parametri θ che, per lo stato s, restituisce una distribuzione di probabilità sulle azioni — per un numero finito di azioni il softmax delle uscite della rete, per azioni continue per esempio la media e la varianza di una distribuzione normale. L’obiettivo è massimizzare il ritorno atteso J(θ) = E_{π_θ}[G₀] con l’ascesa del gradiente θ ← θ + α ∇J(θ).

In parole semplici

Il DQN tiene una tabella «quanti punti per quale mossa» e gioca la mossa con più punti. Una politica invece dice direttamente «in questa situazione spingi a destra con il 70 %, a sinistra con il 30 %». I vantaggi: funziona anche con azioni continue (con quale forza, con quale angolo), il caso è incorporato, quindi l’agente prova da solo, e un piccolo cambiamento dei parametri significa un piccolo cambiamento del comportamento.

Esempio — il ritorno di un tentativo sul pendolo inverso su un carrello

La ricompensa è +1 per ogni passo e lo sconto γ = 0,99. Se mancano T − t passi alla fine dell’episodio, il ritorno è una serie geometrica:

G_t = 1 + γ + γ² + … + γ^T−t−1 = (1 − γ^T−t) / (1 − γ).

All’inizio di un episodio che dura tutti i 500 passi: G₀ = (1 − 0,99⁵⁰⁰) / 0,01 = 99,34. Venti passi prima della caduta: G = (1 − 0,99²⁰) / 0,01 = 18,21. Il passo subito prima della caduta: G = 1. Il ritorno è quindi sempre positivo e non supera mai 1 / (1 − γ) = 100 — ci tornerà utile nella sezione sulla baseline.

2. REINFORCE: rinforza ciò che ha funzionato

Definizione — teorema del gradiente della politica e REINFORCE

Il gradiente del ritorno atteso si può scrivere come un valore atteso, che si può stimare dagli episodi giocati:

∇J(θ) = E_{π_θ}[ ∑_t ∇ log π_θ(a_t | s_t) · G_t ].

REINFORCE (Ronald Williams, 1992) lo fa alla lettera: gioca degli episodi, per ogni passo calcola il ritorno G_t da quel passo in poi e sposta θ nella direzione ∇ log π(a_t | s_t) · G_t. Per il softmax, ∇ log π(a) rispetto alle uscite della rete è semplicemente (1_a − π).

In parole semplici

Gioca, guarda com’è andata e rendi ogni mossa che hai fatto un po’ più probabile — tanto più quanto meglio è andata dopo. Le mosse delle partite riuscite vengono rinforzate più di quelle delle partite andate male. Nessuno deve dirti quale mossa era quella giusta; basta il risultato.

∇J(θ) = E_{π_θ}[ ∑_t ∇ log π_θ(a_t | s_t) · G_t ]

∇J(θ): la direzione in cui ruotare i parametri perché il ritorno medio cresca il più in fretta possibile; non si può calcolare direttamente, perché il ritorno dipende da θ solo attraverso il gioco casuale e la fisica sconosciuta dell’ambiente
E_{π_θ}[ ∑_t … ]: la media sugli episodi giocati dalla politica attuale — per questo si può sostituire con una media sulle partite davvero giocate; e per questo i dati di un’altra politica (più vecchia, estranea) non bastano senza una correzione
∇ log π_θ(a_t | s_t): la direzione nei parametri che rende più probabile l’azione giocata; ∇ log π = ∇π / π divide per la probabilità, così un’azione frequente, che compare spesso nei dati, non riceve un rinforzo extra solo perché è frequente
G_t: il peso: quanto è andata bene dopo l’azione; solo le ricompense dal passo t in poi, perché un’azione non può influenzare ricompense già arrivate

Il gradiente è una media pesata delle direzioni «rendi più probabile questa azione», e il peso è il ritorno che l’ha seguita.

Teorema — da dove viene la formula (il trucco del logaritmo)

Un episodio τ = (s₀, a₀, s₁, a₁, …) ha, con la politica π_θ, probabilità P_θ(τ) = p(s₀) ∏_t π_θ(a_t | s_t) P(s_t+1 | s_t, a_t) e ritorno G(τ). Allora

∇J(θ) = ∇ ∑_τ P_θ(τ) G(τ) = ∑_τ P_θ(τ) · ∇ log P_θ(τ) · G(τ) = E_{τ ∼ π_θ}[ ∇ log P_θ(τ) · G(τ) ],

perché ∇P = P · ∇ log P. Dimostrazione (schizzo): il logaritmo trasforma il prodotto in una somma, log P_θ(τ) = log p(s₀) + ∑_t log π_θ(a_t | s_t) + ∑_t log P(s_t+1 | s_t, a_t). Da θ dipende solo la somma centrale, quindi non serve conoscere la fisica dell’ambiente P: ∇ log P_θ(τ) = ∑_t ∇ log π_θ(a_t | s_t). Infine, per ogni a_t scartiamo le ricompense precedenti al passo t: non dipendono da a_t, e il loro contributo ha quindi valore atteso nullo (vedi il teorema nella sezione successiva). Resta G_t. ∎ (L’enunciato esatto per il ritorno scontato è un po’ più sottile; qui semplificato.)

Esempio — un passo di REINFORCE con il softmax

Due azioni, uscite della rete z = (0; 0), quindi π = softmax(z) = (0,50; 0,50). L’agente ha giocato l’azione 1 («a destra») e il ritorno da quel passo è stato G = 10. Per il softmax ∇_z log π(a) = 1_a − π, quindi

∇_z log π(1) · G = ((0; 1) − (0,50; 0,50)) · 10 = (−5; 5).

Un passo di ascesa con α = 0,1: z ← (0; 0) + 0,1 · (−5; 5) = (−0,5; 0,5). Nuova politica π = (e^−0,5; e^0,5) / (e^−0,5 + e^0,5) = (0,269; 0,731). L’azione che ha funzionato ora è più probabile. (In una rete vera cambiano i pesi θ e il gradiente arriva a z con la retropropagazione; la direzione è la stessa.)

θ = pesi casuali della rete della politica
ripeti:
    gioca episodi completi con la politica π_θ, finché non ci sono almeno 2 000 passi
    per ogni episodio, a ritroso:            # G = 0 dopo la fine dell’episodio
        G_t = r_(t+1) + γ · G_(t+1)
    g = media su tutti i passi di  ∇ log π_θ(a_t | s_t) · G_t
    θ = θ + α · g                           # ascesa; da noi con un passo di Adam
    butta via i dati — la prossima volta vengono da un’altra politica

3. Varianza e baseline

Definizione — baseline (linea di base) e vantaggio

Da G_t si può sottrarre una qualsiasi funzione dello stato b(s_t) senza cambiare il valore atteso della stima del gradiente, perché E[∇ log π(a | s)] = 0. La varianza della stima, però, può ridursi molto. La scelta comune migliore è il valore dello stato V(s), appreso da una seconda rete; la differenza A(s, a) = Q(s, a) − V(s) si chiama vantaggio. I metodi con una politica appresa («attore») e un valore appreso («critico») si chiamano attore-critico (actor-critic).

In parole semplici

Sul pendolo inverso l’agente riceve +1 per ogni passo, quindi ogni ritorno è positivo — REINFORCE rinforza quindi ogni mossa, solo alcune di più. Il segnale «questo è andato meglio del solito» si perde nel rumore. Sottraendo il livello atteso, diventa «questa mossa ha reso 20 punti in più di quanto ci si aspettava in questa situazione» — e le mosse peggiori ricevono il segno negativo.

∇J(θ) = E[ ∑_t ∇ log π_θ(a_t | s_t) · (G_t − b(s_t)) ], A(s, a) = Q(s, a) − V(s)

∇ log π_θ(a_t | s_t): la direzione «l’azione giocata più spesso», come in REINFORCE
G_t, Q(s, a): ciò che è davvero seguito all’azione (G_t), oppure quanto rende in media dopo di essa (Q è il valore atteso di G_t); da solo quasi sempre positivo, quindi non distingue un’azione buona da una media
b(s_t), V(s): l’asticella: quanto ci si aspetta in questa situazione indipendentemente dall’azione; dopo la sottrazione, le azioni peggiori della media ricevono il segno negativo. Può dipendere solo dallo stato, non dall’azione — altrimenti il gradiente sarebbe distorto (teorema qui sotto)
A(s, a): il vantaggio: di quanto l’azione a è migliore dell’azione media della politica in s; esattamente l’informazione che vogliamo rinforzare

Sottrarre l’asticella non cambia dove punta in media il gradiente, riduce solo quanto la stima oscilla da un batch all’altro.

Teorema — la baseline non distorce il gradiente

Per ogni stato s vale E_{a ∼ π_θ}[∇ log π_θ(a | s)] = 0, e quindi E[∇ log π_θ(a | s) · b(s)] = 0 per qualsiasi funzione b che non dipende da a.

Dimostrazione: ∑_a π_θ(a | s) ∇ log π_θ(a | s) = ∑_a ∇π_θ(a | s) = ∇ ∑_a π_θ(a | s) = ∇1 = 0. Il termine b(s) è una costante per s fissato, quindi si può portare fuori dalla somma. ∎

Esempio — stessa media, varianza diversa

Uno stato, due azioni con π = (0,5; 0,5). L’azione 1 rende un ritorno di 12, l’azione 0 un ritorno di 10 — entrambi positivi come sul pendolo. La componente della stima del gradiente rispetto all’uscita z₁ è, da un solo campione, (1_a=1 − 0,5) · (G − b).

Senza baseline (b = 0): se esce l’azione 1, la stima è 0,5 · 12 = 6; se esce l’azione 0, è −0,5 · 10 = −5. Media (6 − 5) / 2 = 0,5, varianza ((6 − 0,5)² + (−5 − 0,5)²) / 2 = 30,25.

Con la baseline b = 11 (ritorno medio): 0,5 · (12 − 11) = 0,5 e −0,5 · (10 − 11) = 0,5. La media è sempre 0,5, la varianza 0.

Il gradiente vero è π₁(1 − π₁) · (12 − 10) = 0,25 · 2 = 0,5. Entrambe le stime puntano in media nel verso giusto, ma senza l’asticella un singolo campione sbaglia di ±5,5, con l’asticella per niente. In realtà la varianza non scende a zero (i ritorni sono casuali e gli stati sono molti), ma il principio è lo stesso.

L’abbiamo misurato all’inizio dell’apprendimento: 40 batch indipendenti di 1 000 passi della stessa politica casuale, e da ciascuno il gradiente di REINFORCE. Già solo sottrarre il ritorno medio (baseline costante) riduce la somma delle varianze delle componenti del gradiente da 0,177 a 0,131, cioè del 26 %. Un valore appreso V(s), che distingue le situazioni buone da quelle cattive, aiuta di più.

Definizione — somma delle varianze delle componenti del gradiente

Da K = 40 batch abbiamo le stime del gradiente ĝ⁽¹⁾, …, ĝ^(K) (vettori di tutti i pesi della rete). Per ogni componente j calcoliamo la varianza tra i batch e sommiamo:

∑_j (1/K) ∑_k (ĝ_j^(k) − ḡ_j)², ḡ_j = (1/K) ∑_k ĝ_j^(k).

È la traccia della matrice di covarianza della stima — un solo numero per quanto la stima oscilla. Calo: 1 − 0,131 / 0,177 = 0,26, cioè il 26 %.

Una V appresa serve anche a PPO, più avanti. Il vantaggio però non lo stima con la differenza G_t − V(s_t), ma con un compromesso tra questa e la stima a un passo della parte sul Q-learning:

Â_t = ∑_l≥0 (γλ)^l δ_t+l, δ_t = r_t+1 + γ V(s_t+1) − V(s_t)

Â_t: la stima del vantaggio del passo t (GAE, John Schulman e coll., 2015) — ciò per cui si moltiplica ∇ log π
δ_t: l’errore TD: di quanto un passo è andato meglio di quanto si aspettava V; una stima del vantaggio a un passo con varianza piccola, ma distorta se V sbaglia
r_t+1: la ricompensa effettivamente arrivata — l’unico pezzo di realtà in δ
V(s): l’asticella appresa; in s_t+1 sostituisce il resto del ritorno con una stima, in s_t si sottrae come baseline (dopo una caduta V(s_t+1) = 0)
(γλ)^l: quanto in fretta dimenticare i passi più lontani. λ = 0 dà solo δ_t; λ = 1 dà dopo la somma (i termini in V si elidono) esattamente G_t − V(s_t) — non distorto, ma con grande varianza. Noi usiamo λ = 0,95

Nel codice si calcola a ritroso in una riga: Â_t = δ_t + γλ Â_t+1.

4. PPO: passi piccoli e sicuri

REINFORCE ha ancora un punto debole: usa ogni esperienza giocata per un solo passo di gradiente e poi la butta via. Se sugli stessi dati facessimo più passi, la politica potrebbe allontanarsi da quella che ha raccolto i dati, e la stima del gradiente smetterebbe di valere — l’apprendimento crolla. PPO sorveglia proprio questo.

Definizione — Proximal Policy Optimization (PPO)

PPO (John Schulman e coll., OpenAI, 2017) raccoglie un batch di transizioni con la vecchia politica π_old, calcola i vantaggi Â_t e poi per diverse epoche massimizza l’obiettivo con clipping

L(θ) = E_t[ min( r_t(θ) Â_t, clip(r_t(θ), 1 − ε, 1 + ε) Â_t ) ], r_t(θ) = π_θ(a_t | s_t) / π_old(a_t | s_t),

tipicamente con ε = 0,2. Non appena la probabilità di un’azione cambia di più di ε nel verso che migliora l’obiettivo, il gradiente di quel campione sparisce. I vantaggi si stimano di solito con il metodo GAE (generalized advantage estimation), una media pesata degli errori TD con il parametro λ.

In parole semplici

Dopo la partita l’allenatore dice «fallo più spesso». Il giocatore lo ripete in allenamento — ma solo finché non lo fa un quinto più spesso di prima. Poi non impara più nulla finché non gioca la partita successiva e non scopre se funziona ancora. Passi abbastanza grandi per migliorare in fretta, abbastanza piccoli per non perdere la testa.

Obiettivo con clipping di PPO in funzione del rapporto r = π_nuova / π_vecchia (ε = 0,2; in verde la fascia 1 ± ε) vantaggio A = +1: oltre 1 + ε non aggiunge nulla vantaggio A = −1: sotto 1 − ε non aggiunge nulla

L(θ) = E_t[ min( r_t(θ) Â_t, clip(r_t(θ), 1 − ε, 1 + ε) Â_t ) ]

L(θ): l’obiettivo surrogato che si massimizza per diverse epoche sul vecchio batch; il suo gradiente in θ = θ_old è esattamente il gradiente della politica di REINFORCE con il vantaggio
r_t(θ) = π_θ / π_old: il rapporto tra la probabilità nuova e quella vecchia dell’azione giocata. I dati li ha raccolti la vecchia politica; moltiplicandoli per il rapporto si può stimare come se la caverebbe la nuova (campionamento per importanza, importance sampling). All’inizio r = 1
Â_t: il vantaggio da GAE: il segno dice se rinforzare l’azione (+) o reprimerla (−)
clip(r, 1 − ε, 1 + ε): il rapporto stretto nella fascia (in verde nella figura); fuori dalla fascia è costante, quindi non ne esce alcun gradiente — con questo campione la politica non si può più spingere oltre
min: delle due stime la peggiore (pessimistica): il clipping vale solo dove il miglioramento sembrerebbe sospettosamente buono. Se invece l’azione è peggiorata, min lascia il termine senza clipping e corregge l’errore

Rinforza le azioni vantaggiose, ma solo finché la loro probabilità non cambia più di un fattore 1 ± ε; poi il campione tace.

Esempio — tre campioni e il clipping con ε = 0,2

La vecchia politica dava all’azione giocata probabilità 0,5. Dopo alcuni passi di apprendimento è 0,65, quindi r = 0,65 / 0,5 = 1,3 e clip(1,3; 0,8; 1,2) = 1,2.

Vantaggio +2: min(1,3 · 2; 1,2 · 2) = min(2,6; 2,4) = 2,4. Vince il termine con clipping, che non dipende da θ — il gradiente di questo campione è zero. L’azione è già più frequente del 30 %, di più no.

Vantaggio −2 (stesso rapporto): min(−2,6; −2,4) = −2,6. Vince il termine senza clipping: la politica ha reso per errore più probabile un’azione cattiva, e il gradiente quindi continua a riportarla indietro.

Vantaggio +2, ma la probabilità è scesa a 0,35: r = 0,7, min(1,4; 0,8 · 2 = 1,6) = 1,4. Di nuovo il termine senza clipping — un’azione buona che la politica aveva represso ritorna. Il clipping frena solo i passi che migliorerebbero l’obiettivo «troppo».

ripeti:
    π_old = π_θ;  raccogli 2 000 passi con la politica π_old, salva π_old(a_t | s_t)
    per ogni episodio, a ritroso:                    # V(s_(t+1)) = 0 dopo una caduta
        δ_t = r_(t+1) + γ · V(s_(t+1)) − V(s_t)
        Â_t = δ_t + γλ · Â_(t+1)                      # GAE, γ = 0,99, λ = 0,95
    target_t = Â_t + V(s_t);  normalizza Â a media 0 e varianza 1
    10 volte (epoca):
        mescola i passi e dividili in mini-batch da 100
        per ogni mini-batch:
            r_t = π_θ(a_t | s_t) / π_old(a_t | s_t)
            θ: un passo in salita sulla media di min(r_t · Â_t, clip(r_t, 0,8, 1,2) · Â_t)
            V: un passo in discesa sulla media di (V(s_t) − target_t)²

5. Esperimento: il pendolo inverso su un carrello

Lo stesso pendolo inverso su un carrello del DQN, ricompensa +1 per ogni passo, l’episodio finisce con una caduta o dopo 500 passi. La politica è una rete 4 → 32 → 32 → 2 con softmax, il valore dello stato una seconda rete della stessa forma. Tutti e quattro i metodi ricevono 100 000 passi nell’ambiente, in batch da 2 000. REINFORCE fa un passo di gradiente su ogni batch, PPO dieci epoche su mini-batch da 100. La variante «senza clipping» è un PPO a cui abbiamo disattivato il clipping.

Lunghezza media degli episodi durante l’apprendimento (spessa la media di tre esecuzioni, sottili le singole esecuzioni) REINFORCEREINFORCE con baselinePPOPPO senza clipping

metodo	prima volta con media ≥ 475 (esecuzione 1 · 2 · 3)	alla fine (esecuzione 1 · 2 · 3)
REINFORCE	— · — · —	463 · 333 · 348
REINFORCE con baseline	90 000 · 80 000 · —	488 · 500 · 404
PPO	30 000 · 20 000 · 20 000	500 · 500 · 500
PPO senza clipping	100 000 · 30 000 · 50 000	494 · 44 · 500

In tutte e tre le esecuzioni PPO tiene l’asta per tutti i 500 passi già dopo 30 000, 20 000, 20 000 passi e non la molla più. REINFORCE migliora lentamente e fino alla fine non ce la fa; con la baseline è un po’ più veloce e in due esecuzioni su tre arriva all’obiettivo. Attenzione, il confronto non è del tutto equo quanto a numero di calcoli: PPO fa su ogni batch dieci volte più passi di gradiente. È però equo in ciò che nell’apprendimento per rinforzo conta di più — il numero di esperienze che l’agente deve raccogliere nel mondo.

E che cosa succede se lanciamo lo stesso apprendimento ripetuto su un batch senza clipping? Le lunghezze degli episodi saltano su e giù, l’esecuzione 2 è finita a 44 passi. Il perché lo mostra quanto la politica, in un solo aggiornamento, si allontana da quella che ha raccolto i dati:

Distanza della nuova politica dalla vecchia dopo ogni batch (stima della KL, esecuzione 1, scala logaritmica) PPO senza clipping

Con PPO la distanza media è di 0,014 nat e non supera mai 0,06. Senza clipping è in media 5,5 e a volte arriva a 25 nat — dopo un solo aggiornamento la politica fa tutt’altro rispetto a quella da cui ha imparato. I dati allora non dicono più nulla su di essa e il miglioramento diventa una lotteria. Il clipping è un piccolo ritocco nella formula, ma trasforma un algoritmo instabile in uno affidabile.

Definizione — stima della KL tra la vecchia e la nuova politica

La divergenza KL della parte sulla teoria dell’informazione, qui con il logaritmo naturale (unità nat; 1 nat = 1 / ln 2 ≈ 1,44 bit), mediata sugli stati del batch:

D_KL(π_old ‖ π_θ) = E_{s, a ∼ π_old}[ log π_old(a | s) − log π_θ(a | s) ] ≈ (1/N) ∑_i=1^N [ log π_old(a_i | s_i) − log π_θ(a_i | s_i) ].

Le azioni a_i le ha giocate la vecchia politica, quindi la media sul batch è una stima non distorta. È la media del logaritmo del rapporto, e quindi e^−D è la media geometrica del rapporto π_θ / π_old sulle azioni raccolte.

Che cosa significa in numeri: con PPO al massimo 0,06 nat, e^−0,06 = 0,94 — le azioni del vecchio batch sono di solito meno probabili di qualche punto percentuale, i dati dicono ancora qualcosa sulla nuova politica. Senza clipping fino a 24,9 nat: e^−24,9 ≈ 1,5 · 10⁻¹¹, la nuova politica non giocherebbe quasi mai le azioni da cui ha appena imparato.

6. PPO e i modelli linguistici

Nella parte sull’RLHF abbiamo detto che InstructGPT e il primo ChatGPT sono stati rifiniti con l’apprendimento per rinforzo. Era proprio PPO: la politica è il modello linguistico, lo stato è il testo finora, l’azione è il token successivo, e la ricompensa alla fine della risposta la dà un modello di ricompensa appreso dalle preferenze umane. La penalità per l’allontanamento dal modello di partenza (KL) ha lo stesso ruolo del clipping — non permette alla politica di scappare dove non ci si può fidare della ricompensa.

Definizione — la ricompensa nel fine-tuning di un modello linguistico con PPO

Per una richiesta x e una risposta y generata dal modello in addestramento π_θ, PPO riceve la ricompensa

R(x, y) = r_φ(x, y) − β · log [ π_θ(y | x) / π_ref(y | x) ],

dove r_φ è il modello di ricompensa, π_ref il modello congelato dopo il fine-tuning sugli esempi (SFT) e β la forza della penalità (così lo scrive InstructGPT, Long Ouyang e coll., 2022). Il valore atteso del secondo termine sulle risposte è esattamente β · D_KL(π_θ ‖ π_ref). Un episodio è una risposta, le azioni sono i token, la ricompensa r_φ arriva solo dopo l’ultimo token; il resto è PPO così come descritto sopra.

Con i modelli grandi, però, PPO è costoso: oltre al modello gli serve una rete di valore altrettanto grande. Per questo sono nate delle semplificazioni. Il DPO della parte sull’RLHF evita del tutto l’apprendimento per rinforzo. GRPO (DeepSeek, 2024) elimina la rete di valore e come baseline usa la ricompensa media di più risposte alla stessa domanda — proprio la baseline costante che abbiamo misurato sopra. Così si addestrano i modelli che «ragionano» su matematica e codice, dove la correttezza della risposta si può verificare.

Â_i = (r_i − media(r₁, …, r_G)) / sd(r₁, …, r_G)

Â_i: il vantaggio della i-esima risposta; lo ricevono tutti i suoi token e poi entra nell’obiettivo con clipping di PPO
r_i: la ricompensa della i-esima delle G risposte alla stessa domanda, per esempio 1 = il risultato è giusto, 0 = è sbagliato
media(…): la baseline al posto della rete di valore: quanto bene il modello risponde di solito a questa domanda — una domanda facile ha l’asticella alta, una difficile bassa
sd(…): la deviazione standard del gruppo; uniforma la scala, così le domande con varianza delle ricompense grande e piccola tirano con la stessa forza (come la normalizzazione dei vantaggi nel nostro PPO)

GRPO (Zhihong Shao e coll., DeepSeekMath, 2024): il vantaggio di una risposta = di quanto è migliore delle altre risposte alla stessa domanda.

Esempio — i vantaggi GRPO per quattro risposte

Il modello risponde quattro volte a un problema, correttamente solo la prima: ricompense (1; 0; 0; 0). Media 0,25, deviazione standard √((0,75² + 3 · 0,25²) / 4) = √0,1875 = 0,433.

Vantaggi: (1 − 0,25) / 0,433 = 1,732 per la risposta corretta e (0 − 0,25) / 0,433 = −0,577 per ciascuna delle tre sbagliate. La somma è zero: quella giusta viene rinforzata, quelle sbagliate represse. Se tutte e quattro le risposte fossero giuste (o tutte sbagliate), tutti i vantaggi sarebbero nulli e la domanda non insegnerebbe nulla — si impara solo dalle domande in cui il modello a volte ci azzecca e a volte no. (Dividiamo per G; alcune implementazioni dividono per G − 1, e allora i numeri differiscono leggermente.)

7. Riepilogo

Il policy gradient impara direttamente le probabilità delle azioni; funziona anche con azioni continue ed esplora da sé.
REINFORCE rinforza le azioni in proporzione al ritorno che le ha seguite; è semplice, ma la stima del gradiente ha una grande varianza.
Sottrarre una baseline riduce la varianza senza cambiare il valore atteso (da noi del 26 % già con una costante); con una V(s) appresa nasce l’attore-critico.
PPO usa ogni batch più volte e, con il clipping del rapporto delle probabilità, tiene la politica vicina a quella che ha raccolto i dati.
Sul pendolo inverso: PPO regge 500 passi dopo 20–30 mila passi in tutte le esecuzioni; senza clipping la politica si allontana fino a 25 nat e l’apprendimento oscilla.
PPO ha rifinito il primo ChatGPT; la sua semplificazione (GRPO) oggi addestra i modelli che «ragionano».

Vuoi metterci le mani? Chiedi a un agente IA di lanciare il PPO della libreria Stable-Baselines3 sull’ambiente LunarLander, di variare ε del clipping (0,05; 0,2; 0,5) — e di disegnare come cambiano la velocità e la stabilità dell’apprendimento.

La vedi diversamente? Scrivi a support@coden-app.com.

Policy gradient e PPO: imparare direttamente la politica

1. Imparare direttamente la politica

2. REINFORCE: rinforza ciò che ha funzionato

3. Varianza e baseline

4. PPO: passi piccoli e sicuri

5. Esperimento: il pendolo inverso su un carrello

6. PPO e i modelli linguistici

7. Riepilogo

Un Agente sul tuo computer, guidato dal telefono