Salt la conținut

Gradientul strategiei și REINFORCE

AvansatLectură: 5 min

REINFORCE este punctul de plecare al metodelor bazate pe gradientul strategiei (policy gradient). Ronald Williams l-a publicat în 1992, în articolul „Simple statistical gradient-following algorithms for connectionist reinforcement learning”. Aceeași idee stă la baza metodelor de azi, inclusiv PPO și GRPO, folosite la alinierea modelelor de limbaj mari.

Pagina folosește noțiunile introduse în Învățare prin consolidare: stare, acțiune, recompensă, strategie și recompensă cumulată.

O strategie πθ\pi_\theta este o funcție cu parametrii θ\theta, de exemplu o rețea neuronală care primește starea curentă și dă probabilitățile acțiunilor posibile. Vrem să maximizăm valoarea așteptată a recompensei cumulate.

Pentru curioșiFuncția obiectiv
J(θ)=Eτ∼πθ[R(τ)]J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}\left[ R(\tau) \right]

unde τ=(s0,a0,r1,s1,a1,…)\tau = (s_0, a_0, r_1, s_1, a_1, \ldots) este o traiectorie (trajectory), adică un episod complet generat urmând strategia, iar R(τ)R(\tau) este recompensa totală a episodului.

Aici nu putem aplica direct coborârea pe gradient. Recompensa vine de la un mediu pe care de obicei nu îl putem deriva și pentru care nu avem o formulă, iar acțiunile sunt eșantionate aleatoriu. Gradientul strategiei ocolește ambele obstacole.

Gradientul recompensei așteptate se poate scrie tot ca o medie, pe care o estimăm din episoadele generate cu strategia, fără să derivăm mediul sau recompensa. În această medie, fiecare acțiune contribuie cu direcția în care trebuie mutați parametrii ca acțiunea să devină mai probabilă, înmulțită cu recompensa cumulată obținută din acel moment.

Pentru curioșiDerivarea gradientului strategiei

Pentru orice distribuție de probabilitate pθ(x)p_\theta(x) și orice funcție scalară f(x)f(x) este adevărată următoarea identitate.

∇θ Ex∼pθ[f(x)]=Ex∼pθ[f(x) ∇θlog⁡pθ(x)]\nabla_\theta\, \mathbb{E}_{x \sim p_\theta}\left[ f(x) \right] = \mathbb{E}_{x \sim p_\theta}\left[ f(x)\, \nabla_\theta \log p_\theta(x) \right]

Identitatea vine din proprietatea ∇p=p ∇log⁡p\nabla p = p\, \nabla \log p. Gradientul unei medii devine astfel tot o medie, pe care o putem estima din eșantioane, prin metoda Monte Carlo. Funcția ff nu trebuie să fie derivabilă, așa că recompensa poate veni din orice sursă externă.

Probabilitatea unei traiectorii este produsul dintre probabilitățile acțiunilor (date de strategia πθ\pi_\theta) și probabilitățile de tranziție ale mediului. Termenii care țin de mediu nu depind de θ\theta, așa că dispar la derivare. Rămâne următoarea expresie.

∇θJ(θ)=Eτ∼πθ[∑t∇θlog⁡πθ(at∣st) Gt]\nabla_\theta J(\theta) = \mathbb{E}_{\tau \sim \pi_\theta}\left[ \sum_{t} \nabla_\theta \log \pi_\theta(a_t \mid s_t)\, G_t \right]

unde GtG_t este recompensa cumulată de la pasul tt până la sfârșitul episodului. O acțiune poate influența doar ce urmează, de aceea o ponderăm cu GtG_t, nu cu recompensa totală a episodului.

Rezultatul se numește teorema gradientului strategiei (policy gradient theorem). Richard Sutton și colaboratorii lui l-au demonstrat în 2000.

REINFORCE estimează gradientul din episoade complete.

  1. Generăm un episod cu strategia curentă πθ\pi_\theta și reținem stările, acțiunile și recompensele care apar pe parcurs.

  2. Pentru fiecare pas tt calculăm recompensa cumulată GtG_t, de la acel pas până la final.

  3. Actualizăm parametrii cu rata de învățare α\alpha.

    Pentru curioșiRegula de actualizare
    θ←θ+α∑tGt ∇θlog⁡πθ(at∣st)\theta \leftarrow \theta + \alpha \sum_{t} G_t\, \nabla_\theta \log \pi_\theta(a_t \mid s_t)

    Termenul ∇θlog⁡πθ(at∣st)\nabla_\theta \log \pi_\theta(a_t \mid s_t) arată în ce direcție trebuie mutați parametrii ca acțiunea aleasă să devină mai probabilă, iar numărul GtG_t stabilește cât de mare este pasul.

Intuitiv, acțiunile urmate de recompense mari devin mai probabile în episoadele următoare, iar cele care aduc puțin sunt descurajate.

Estimarea gradientului are o varianță (variance) mare. Două episoade generate cu aceeași strategie pot avea recompense foarte diferite, așa că actualizările oscilează. Dacă toate recompensele sunt pozitive, orice acțiune aleasă devine mai probabilă, chiar și una slabă, doar că mai puțin decât una foarte bună.

Soluția este să scădem din recompensa cumulată GtG_t o linie de bază (baseline) b(st)b(s_t), care nu depinde de acțiune.

Pentru curioșiGradientul cu linie de bază
∇θJ(θ)=E[∑t∇θlog⁡πθ(at∣st) (Gt−b(st))]\nabla_\theta J(\theta) = \mathbb{E}\left[ \sum_{t} \nabla_\theta \log \pi_\theta(a_t \mid s_t)\, \big( G_t - b(s_t) \big) \right]

Termenul scăzut are media zero, deci estimarea gradientului rămâne nedeplasată (unbiased), dar varianța scade mult.

Acum devin mai probabile doar acțiunile mai bune decât linia de bază. O alegere firească pentru b(st)b(s_t) este funcția de valoare V(st)V(s_t), iar diferența Gt−V(st)G_t - V(s_t) este o estimare a avantajului. Când VV este aproximată de o a doua rețea, metoda devine actor-critic.

Cea mai simplă problemă de acest fel este un automat cu mai multe manete (multi-armed bandit). Are o singură stare și trei acțiuni. Prima aduce recompensa 1 cu probabilitatea 0,2, a doua cu 0,5, iar a treia cu 0,8. Altfel, recompensa este 0. Agentul nu cunoaște aceste probabilități. Strategia este un softmax peste trei parametri. Pentru softmax, gradientul lui log⁡π(a)\log \pi(a) este vectorul care are 1 pe poziția acțiunii alese, din care scădem vectorul probabilităților. Linia de bază este media mobilă a recompenselor.

import numpy as np
rng = np.random.default_rng(seed=0)
reward_probs = np.array([0.2, 0.5, 0.8]) # probabilitatea de câștig a fiecărei acțiuni
theta = np.zeros(3) # parametrii strategiei: câte un scor pentru fiecare acțiune
alpha = 0.1 # rata de învățare
baseline = 0.0 # media mobilă a recompenselor
def policy(theta):
e = np.exp(theta - theta.max())
return e / e.sum()
for step in range(1, 2001):
pi = policy(theta)
a = rng.choice(3, p=pi)
r = float(rng.random() < reward_probs[a]) # recompensa: 1 sau 0
# Pentru softmax, gradientul lui log π(a) este one_hot(a) - π.
grad_log_pi = -pi
grad_log_pi[a] += 1
theta += alpha * (r - baseline) * grad_log_pi
baseline += 0.01 * (r - baseline)
if step in (1, 100, 500, 2000):
print(f"Pasul {step:>4}: probabilitățile acțiunilor {np.round(policy(theta), 2)}")

Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).

Strategia pornește uniformă și ajunge să aleagă aproape mereu a treia acțiune, cea mai profitabilă, deși agentul nu cunoaște probabilitățile de câștig. Merită să încercăm alte valori pentru rata de învățare sau pentru probabilitățile din reward_probs, ori să eliminăm linia de bază (baseline = 0 la fiecare pas).

Metodele apărute ulterior rezolvă aceste probleme. Metodele actor-critic învață o funcție de valoare, ca să estimeze mai precis avantajele. PPO (proximal policy optimization) limitează cât se poate schimba strategia la o actualizare și refolosește fiecare lot de episoade de mai multe ori. GRPO calculează avantajele comparând mai multe încercări pentru aceeași problemă. Ultimele două sunt descrise pe pagina Învățare prin consolidare pentru LLM-uri.