Metodi policy gradient: REINFORCE
Teorema del policy gradient, algoritmo REINFORCE, sottrazione della baseline, riduzione della varianza
Metodi policy gradient: REINFORCE è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
RL basato sui valori vs RL basato sulle policy
Alcuni metodi di RL apprendono il valore delle azioni e poi agiscono in modo greedy. I metodi basati sul policy gradient apprendono invece la policy direttamente: una funzione che restituisce le probabilità delle azioni. Questo gestisce naturalmente le azioni continue e le policy stocastiche.
La policy pi(a|s)
Una policy parametrizzata pi(a|s, theta) mappa uno stato in una distribuzione di probabilità sulle azioni, con parametri theta (una rete neurale). L'addestramento modifica theta per favorire le azioni che ottengono ricompense maggiori.
class Policy(nn.Module):
def __init__(self, obs_dim, n_actions):
super().__init__()
self.net = nn.Sequential(
nn.Linear(obs_dim, 128), nn.ReLU(),
nn.Linear(128, n_actions)
)
def forward(self, s):
return torch.softmax(self.net(s), dim=-1)Campionamento delle azioni
Poiché la policy è una distribuzione, si campiona un'azione invece di scegliere quella con valore massimo. Il campionamento favorisce l'esplorazione e rende la policy stocastica.
probs = policy(state)
dist = torch.distributions.Categorical(probs)
action = dist.sample()
log_prob = dist.log_prob(action)Esecuzione di una traiettoria
Un episodio (o traiettoria) è la sequenza di stati, azioni e ricompense dall'inizio alla fine. Si raccoglie una traiettoria completa agendo nell'ambiente finché non termina.
states, actions, rewards, log_probs = [], [], [], []
state, _ = env.reset()
done = False
while not done:
probs = policy(torch.tensor(state).float())
dist = torch.distributions.Categorical(probs)
a = dist.sample()
state, r, term, trunc, _ = env.step(a.item())
rewards.append(r); log_probs.append(dist.log_prob(a))
done = term or truncRitorno scontato G_t
Il ritorno G_t è la ricompensa futura totale a partire dal tempo t, scontata tramite gamma in modo che le ricompense più vicine contino di più. Indica quanto si sono rivelate efficaci le azioni eseguite dal passo t in poi.
def returns(rewards, gamma=0.99):
G, out = 0, []
for r in reversed(rewards):
G = r + gamma * G
out.insert(0, G)
return torch.tensor(out)L'obiettivo di REINFORCE
REINFORCE esegue l'ascesa del gradiente sul ritorno atteso. In termini intuitivi: aumenta la probabilità delle azioni che hanno portato a un ritorno elevato e diminuisce quella delle azioni che hanno portato a un ritorno basso. Ogni azione è ponderata in base a G_t.
Il gradiente della policy
La funzione di perdita è -sum(log_prob * G_t). Il segno negativo trasforma l'ascesa del gradiente in una discesa, così l'ottimizzatore massimizza il ritorno. Per le azioni con un ritorno elevato, la log-probabilità viene aumentata.
G = returns(rewards)
loss = -torch.sum(torch.stack(log_probs) * G)Aggiornamento della policy
Eseguite il backpropagation e l'aggiornamento come di consueto. Un aggiornamento utilizza un'intera traiettoria, che poi viene scartata (REINFORCE è on-policy: usa solo dati della policy corrente).
optimizer.zero_grad()
loss.backward()
optimizer.step()Il problema dell'elevata varianza
REINFORCE nella sua forma base è notoriamente instabile e caratterizzato da un'elevata varianza: i ritorni cambiano molto da un episodio all'altro, quindi le stime del gradiente sono rumorose e l'apprendimento è lento e irregolare.
Baseline per la riduzione della varianza
Sottrarre una baseline (come il ritorno medio) da G_t riduce la varianza senza introdurre bias nel gradiente. Le azioni vengono premiate perché sono migliori del previsto, non semplicemente perché hanno prodotto un ritorno positivo.
baseline = G.mean()
advantage = G - baseline
loss = -torch.sum(torch.stack(log_probs) * advantage)Perché REINFORCE è importante
REINFORCE è alla base di tutti i metodi di gradiente della policy. I suoi punti deboli, ovvero l'elevata varianza e l'inefficienza nell'uso dei campioni, hanno portato allo sviluppo dei metodi actor-critic e PPO che vedrà tra poco.
Verifica rapida
Verificate la vostra comprensione del gradiente della policy.
Riepilogo: REINFORCE
Avete imparato a parametrizzare una policy pi(a|s,theta), eseguire il rollout delle traiettorie, calcolare il ritorno scontato G_t ed eseguire l'ascesa del gradiente con la funzione di perdita -sum(log_prob * G_t). Avete osservato l'elevata varianza di REINFORCE e come una baseline possa ridurla.
Domande Frequenti
La lezione «Metodi policy gradient: REINFORCE» è gratuita?
Sì — il testo completo di «Metodi policy gradient: REINFORCE» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «Metodi policy gradient: REINFORCE»?
Teorema del policy gradient, algoritmo REINFORCE, sottrazione della baseline, riduzione della varianza Eserciti Learn AI with Python con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Metodi policy gradient: REINFORCE»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn AI with Python?
Sì. Ogni lezione Learn AI with Python include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Metodi policy gradient: REINFORCE
- Metodi actor-critic (A2C)
- Proximal Policy Optimization (PPO)
- Ambienti Gymnasium personalizzati