Salt la conținut

Retropropagare (backpropagation)

IntermediarLectură: 9 min

Pentru a antrena o rețea neuronală, trebuie să știm cu cât să ajustăm fiecare pondere pentru ca eroarea să scadă. Acest calcul se face cu algoritmul de retropropagare (backpropagation), care aplică eficient regula lanțului (chain rule) pentru a obține gradienții tuturor parametrilor.

Propagarea directă și retropropagareaPatru casete legate de la stânga la dreapta: intrarea x, neuronul ascuns care calculează a = f(wx + b), ieșirea ŷ = va + c și eroarea L. Săgețile pline, spre dreapta, duc valorile x, a și ŷ. Săgețile punctate, spre stânga, întorc gradienții ∂L/∂ŷ și ∂L/∂a. Sub neuronul ascuns apar gradienții ∂L/∂w și ∂L/∂b, iar sub ieșire ∂L/∂v și ∂L/∂c.IntrarexNeuron ascunsa = f(wx + b)Ieșireŷ = va + cEroareL = ½(ŷ − y)²xaŷ∂L/∂ŷ∂L/∂a∂L/∂w, ∂L/∂b∂L/∂v, ∂L/∂cpropagare directă: valoriretropropagare: gradienți
Propagarea directă calculează valorile de la stânga la dreapta, până la eroare. Retropropagarea pornește de la eroare și trimite gradienții înapoi, iar pe drum obține gradienții tuturor parametrilor.

O rețea neuronală este o compoziție de funcții. Fiecare strat transformă intrarea și trece rezultatul mai departe. Pentru a ști cum să ajustăm o pondere din stratul 1, trebuie să înțelegem cum afectează ponderea ieșirea finală și, prin urmare, eroarea.

Fără un calcul eficient, am trebui să modificăm fiecare pondere pe rând, să măsurăm eroarea și să repetăm. Ar fi extrem de lent. Retropropagarea rezolvă această problemă calculând toți gradienții o singură dată, într-un singur pas înapoi prin rețea.

Retropropagarea se bazează pe regula lanțului din calculul diferențial. Dacă o variabilă yy depinde de uu, iar uu depinde de xx, atunci derivata lui yy în raport cu xx este produsul derivatelor de pe cele două verigi ale lanțului.

Pentru curioșiFormula regulii lanțului
dydx=dydu⋅dudx\frac{dy}{dx} = \frac{dy}{du} \cdot \frac{du}{dx}

Într-o rețea neuronală, eroarea este capătul unui lanț de funcții: intrarea trece prin straturi și funcții de activare, iar ieșirea ultimului strat este comparată cu valoarea corectă. Regula lanțului ne permite să parcurgem acest lanț invers, câte o verigă pe rând.

Să considerăm o rețea simplă, cu o intrare xx și un strat ascuns. Fiecare neuron jj din stratul ascuns are o pondere wjw_j, un bias bjb_j și o funcție de activare ff.

  1. Pentru fiecare neuron jj din stratul ascuns, calculăm suma ponderată zj=wjx+bjz_j = w_j x + b_j.
  2. Apoi aplicăm funcția de activare aj=f(zj)a_j = f(z_j).
  3. La stratul de ieșire, calculăm predicția y^=∑jvjaj+c\hat{y} = \sum_j v_j a_j + c, unde vjv_j și cc sunt ponderile și bias-ul stratului de ieșire.
  4. Eroarea este L=12(y^−y)2L = \frac{1}{2}(\hat{y} - y)^2, unde yy este valoarea corectă. Factorul 12\frac{1}{2} face derivata mai simplă.

Acum calculăm gradienții, pornind de la ieșire.

Pornim de la eroare, care depinde direct de predicție. Un singur pas al regulii lanțului ne dă apoi gradienții ponderilor vjv_j și ai bias-ului cc din stratul de ieșire, dar și gradientul în raport cu ieșirea fiecărui neuron ascuns, de la care continuăm spre stratul ascuns.

Pentru curioșiCalculul gradienților la ieșire

Eroarea depinde direct de predicție:

∂L∂y^=y^−y\frac{\partial L}{\partial \hat{y}} = \hat{y} - y

Pentru că y^=∑jvjaj+c\hat{y} = \sum_j v_j a_j + c, gradienții parametrilor stratului de ieșire se obțin cu un singur pas al regulii lanțului:

∂L∂vj=∂L∂y^⋅aj,∂L∂c=∂L∂y^\frac{\partial L}{\partial v_j} = \frac{\partial L}{\partial \hat{y}} \cdot a_j, \qquad \frac{\partial L}{\partial c} = \frac{\partial L}{\partial \hat{y}}

Același pas ne dă și gradientul în raport cu ieșirea fiecărui neuron ascuns, de care avem nevoie ca să mergem mai departe, înapoi:

∂L∂aj=∂L∂y^⋅∂y^∂aj=(y^−y)⋅vj\frac{\partial L}{\partial a_j} = \frac{\partial L}{\partial \hat{y}} \cdot \frac{\partial \hat{y}}{\partial a_j} = (\hat{y} - y) \cdot v_j

Pentru ponderea wjw_j, care leagă intrarea de neuronul jj, lanțul continuă cu încă două verigi: funcția de activare și suma ponderată. La fel se calculează și gradientul pentru bias-ul bjb_j.

Pentru curioșiCalculul gradienților în stratul ascuns

Pentru ponderea wjw_j, lanțul are încă două verigi:

∂L∂wj=∂L∂aj⋅∂aj∂zj⋅∂zj∂wj\frac{\partial L}{\partial w_j} = \frac{\partial L}{\partial a_j} \cdot \frac{\partial a_j}{\partial z_j} \cdot \frac{\partial z_j}{\partial w_j}

unde ∂aj∂zj=f′(zj)\frac{\partial a_j}{\partial z_j} = f'(z_j) este derivata funcției de activare, iar ∂zj∂wj=x\frac{\partial z_j}{\partial w_j} = x. Pentru bias, ultima verigă este ∂zj∂bj=1\frac{\partial z_j}{\partial b_j} = 1, deci ∂L∂bj=∂L∂aj⋅f′(zj)\frac{\partial L}{\partial b_j} = \frac{\partial L}{\partial a_j} \cdot f'(z_j).

Observăm că gradientul în raport cu ieșirea neuronului, ∂L∂aj\frac{\partial L}{\partial a_j}, se calculează o singură dată și se refolosește pentru ambii parametri ai neuronului. La scară mică, aceasta este ideea care face retropropagarea eficientă.

FuncțieDerivată
ReLU f(z)=max⁡(0,z)f(z) = \max(0, z)f′(z)=1f'(z) = 1 dacă z>0z > 0, altfel 00
Sigmoidă f(z)=11+e−zf(z) = \frac{1}{1 + e^{-z}}f′(z)=f(z)(1−f(z))f'(z) = f(z)(1 - f(z))
Tangentă hiperbolică f(z)=tanh⁡(z)f(z) = \tanh(z)f′(z)=1−tanh⁡2(z)f'(z) = 1 - \tanh^2(z)

În z=0z = 0, derivata ReLU nu există. Librăriile folosesc, prin convenție, valoarea 00.

Un pas de antrenare are două faze:

  1. Propagare directă: calculăm și memorăm valorile intermediare (zz, aa) ale fiecărui strat, de la intrare spre ieșire.
  2. Retropropagare: pornim de la gradientul erorii în raport cu ieșirea (∂L∂y^\frac{\partial L}{\partial \hat{y}}) și trimitem gradienții înapoi prin rețea, strat cu strat.

Fiecare strat primește de la stratul următor gradientul în raport cu ieșirea sa și calculează din acest gradient:

  • gradienții parametrilor proprii (∂L∂w\frac{\partial L}{\partial w}, ∂L∂b\frac{\partial L}{\partial b})
  • gradientul în raport cu intrarea sa, pe care îl trimite stratului anterior

Valorile memorate la propagarea directă sunt folosite aici: f′(z)f'(z) are nevoie de zz, iar gradientul unei ponderi are nevoie de intrarea stratului. De aceea, antrenarea ocupă mai multă memorie decât simpla folosire a modelului.

După ce au fost calculați toți gradienții, actualizăm parametrii cu coborârea pe gradient. Fiecare parametru se mută puțin în sensul opus gradientului său, adică în sensul în care eroarea scade, iar mărimea pasului depinde de rata de învățare.

Pentru curioșiRegula de actualizare a parametrilor
w←w−η∂L∂ww \leftarrow w - \eta \frac{\partial L}{\partial w}b←b−η∂L∂bb \leftarrow b - \eta \frac{\partial L}{\partial b}

unde η\eta este rata de învățare.

Retropropagarea este eficientă deoarece:

  • Partajează calculul: fiecare gradient intermediar este calculat o singură dată și refolosit pentru mai mulți parametri.
  • Se poate paraleliza: gradienții parametrilor din același strat se calculează în paralel, ca înmulțiri de matrice.
  • Costul este de același ordin cu al propagării directe: în practică, de aproximativ două ori mai mare. Metoda naivă de mai sus ar avea nevoie de câte o propagare directă pentru fiecare parametru.

În rețelele adânci, gradienții pot deveni foarte mici pe măsură ce sunt propagați înapoi. Cauza este produsul derivatelor de la fiecare strat: dacă aceste derivate sunt mai mici decât 1, gradientul scade exponențial cu numărul de straturi traversate. De exemplu, derivata sigmoidei este cel mult 0.250.25, așa că, după 10 straturi, doar derivatele activărilor pot micșora gradientul de până la 0.2510≈10−60.25^{10} \approx 10^{-6} ori.

Soluții:

  • Funcții de activare de tip ReLU, a căror derivată este 1 pentru valorile pozitive
  • Inițializarea potrivită a ponderilor (de exemplu, inițializarea Xavier sau He, descrise mai jos)
  • Rețele reziduale (residual networks), cu conexiuni directe între straturi, pe care gradientul trece fără să fie atenuat

Gradienții pot deveni și foarte mari, mai ales în rețelele recurente sau foarte adânci, când derivatele din produs sunt mai mari decât 1.

Soluții:

  • Limitarea gradientului (gradient clipping): norma gradientului este limitată la o valoare maximă
  • Normalizarea activărilor, pe lot (batch normalization) sau pe strat (layer normalization)
  • Rate de învățare mai mici

Să considerăm un exemplu simplu: o rețea cu o singură intrare, un neuron ascuns cu activare ReLU și o ieșire liniară.

  • Intrare: x=2x = 2
  • Ponderi: w=0.5w = 0.5, v=1.5v = 1.5
  • Bias-uri: b=0.1b = 0.1, c=0c = 0
  • Valoare țintă: y=3y = 3

Propagare directă:

  • z=0.5⋅2+0.1=1.1z = 0.5 \cdot 2 + 0.1 = 1.1
  • a=ReLU⁡(1.1)=1.1a = \operatorname{ReLU}(1.1) = 1.1
  • y^=1.5⋅1.1+0=1.65\hat{y} = 1.5 \cdot 1.1 + 0 = 1.65
  • L=12(1.65−3)2=0.91125L = \frac{1}{2}(1.65 - 3)^2 = 0.91125

Retropropagare:

  • ∂L∂y^=1.65−3=−1.35\frac{\partial L}{\partial \hat{y}} = 1.65 - 3 = -1.35
  • ∂L∂v=−1.35⋅1.1=−1.485\frac{\partial L}{\partial v} = -1.35 \cdot 1.1 = -1.485 și ∂L∂c=−1.35\frac{\partial L}{\partial c} = -1.35
  • ∂L∂a=−1.35⋅1.5=−2.025\frac{\partial L}{\partial a} = -1.35 \cdot 1.5 = -2.025
  • ∂L∂w=−2.025⋅1⋅2=−4.05\frac{\partial L}{\partial w} = -2.025 \cdot 1 \cdot 2 = -4.05 (derivata ReLU este 1, pentru că z>0z > 0)
  • ∂L∂b=−2.025⋅1=−2.025\frac{\partial L}{\partial b} = -2.025 \cdot 1 = -2.025

Actualizările (cu η=0.1\eta = 0.1):

  • w←0.5−0.1⋅(−4.05)=0.905w \leftarrow 0.5 - 0.1 \cdot (-4.05) = 0.905
  • v←1.5−0.1⋅(−1.485)=1.6485v \leftarrow 1.5 - 0.1 \cdot (-1.485) = 1.6485
  • b←0.1−0.1⋅(−2.025)=0.3025b \leftarrow 0.1 - 0.1 \cdot (-2.025) = 0.3025
  • c←0−0.1⋅(−1.35)=0.135c \leftarrow 0 - 0.1 \cdot (-1.35) = 0.135

Cu noii parametri, eroarea scade de la 0,91125 la aproximativ 0,19.

Calculul de mai sus poate fi verificat direct în browser. Putem modifica valorile, apoi apăsăm „Rulare” pentru a vedea cum se schimbă gradienții.

# Valorile din exemplul numeric
x = 2.0
w = 0.5
v = 1.5
b = 0.1
c = 0.0
y = 3.0
eta = 0.1
# Propagare directă
z = w * x + b
a = max(0.0, z) # ReLU
y_pred = v * a + c
loss = 0.5 * (y_pred - y) ** 2
print("Propagare directă:")
print(f" z = {z:.6g}, a = {a:.6g}, y_pred = {y_pred:.6g}")
print(f" loss = {loss:.6g}")
# Retropropagare, de la eroare spre intrare
dL_dy_pred = y_pred - y
dL_dv = dL_dy_pred * a
dL_dc = dL_dy_pred
dL_da = dL_dy_pred * v
dL_dz = dL_da * (1.0 if z > 0 else 0.0) # derivata ReLU
dL_dw = dL_dz * x
dL_db = dL_dz
print("\nRetropropagare:")
print(f" dL/dy_pred = {dL_dy_pred:.6g}")
print(f" dL/dv = {dL_dv:.6g}, dL/dc = {dL_dc:.6g}")
print(f" dL/da = {dL_da:.6g}")
print(f" dL/dw = {dL_dw:.6g}, dL/db = {dL_db:.6g}")
# Un pas de coborâre pe gradient
w -= eta * dL_dw
v -= eta * dL_dv
b -= eta * dL_db
c -= eta * dL_dc
new_loss = 0.5 * (v * max(0.0, w * x + b) + c - y) ** 2
print("\nDupă actualizare:")
print(f" w = {w:.6g}, v = {v:.6g}, b = {b:.6g}, c = {c:.6g}")
print(f" loss = {new_loss:.6g}")

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

Librăriile moderne precum PyTorch și TensorFlow construiesc automat un graf computațional (computational graph) în timpul propagării directe. Fiecare operație (înmulțire, adunare, funcție de activare) devine un nod în graf, iar valorile intermediare circulă pe muchiile dintre noduri. Librăria știe derivata fiecărui tip de operație, așa că poate aplica regula lanțului pe tot graful, fără ca noi să scriem vreo derivată. Mecanismul se numește diferențiere automată (automatic differentiation), iar în PyTorch îl implementează modulul autograd.

  1. Propagarea directă: pe măsură ce se calculează ieșirea, fiecare operație este înregistrată în graf, împreună cu valorile de care va avea nevoie derivata operației.
  2. Calculul erorii: eroarea devine ultimul nod al grafului.
  3. Retropropagarea: apelul loss.backward() parcurge graful invers, aplică regula lanțului la fiecare nod și adaugă gradienții în atributul .grad al fiecărui parametru.

Codul de mai jos refolosește valorile din exemplul numeric. PyTorch nu rulează în browser, așa că rezultatele sunt trecute în comentarii.

import torch
# Aceleași valori ca în exemplul numeric
x = torch.tensor(2.0)
y = torch.tensor(3.0)
w = torch.tensor(0.5, requires_grad=True)
v = torch.tensor(1.5, requires_grad=True)
b = torch.tensor(0.1, requires_grad=True)
c = torch.tensor(0.0, requires_grad=True)
# Propagare directă: fiecare operație este înregistrată în graf
z = w * x + b
a = torch.relu(z)
y_pred = v * a + c
loss = 0.5 * (y_pred - y) ** 2
# Retropropagare: graful este parcurs invers
loss.backward()
print(w.grad) # tensor(-4.0500)
print(v.grad) # tensor(-1.4850)
print(b.grad) # tensor(-2.0250)
print(c.grad) # tensor(-1.3500)

Gradienții se adună de la un apel backward() la altul. De aceea, la antrenare îi resetăm la zero înainte de fiecare pas (optimizer.zero_grad()).

  • Automat: nu mai scriem derivatele de mână.
  • Flexibil: putem schimba arhitectura oricând. PyTorch construiește graful din nou la fiecare propagare directă, deci nu avem derivate de recalculat.
  • Eficient: derivata fiecărei operații este implementată o singură dată, cu cod optimizat pentru plăci grafice. Unele instrumente, precum torch.compile sau compilatorul XLA, pot optimiza și graful întreg înainte de execuție.

Același mecanism funcționează și pentru rețelele neuronale recurente (recurrent neural networks, RNN), care aplică aceleași ponderi la fiecare pas al unei secvențe. Graful computațional se „desfășoară” în timp, cu câte o copie a rețelei pentru fiecare pas, iar gradienții se propagă înapoi prin toți pașii secvenței. Metoda se numește retropropagare în timp (backpropagation through time, BPTT). Gradienții ponderilor se adună de-a lungul secvenței, iar produsele lungi de derivate fac aceste rețele deosebit de sensibile la gradienții care dispar sau explodează.

Valorile inițiale ale ponderilor influențează direct mărimea gradienților care se propagă înapoi. Două scheme des folosite aleg varianța ponderilor după numărul de intrări (ninn_{\text{in}}) și de ieșiri (noutn_{\text{out}}) ale stratului:

  • Inițializarea Xavier (Glorot), potrivită pentru sigmoidă și tangenta hiperbolică: w∼N(0,2nin+nout)w \sim \mathcal{N}\left(0, \frac{2}{n_{\text{in}} + n_{\text{out}}}\right)
  • Inițializarea He, potrivită pentru ReLU și funcțiile înrudite: w∼N(0,2nin)w \sim \mathcal{N}\left(0, \frac{2}{n_{\text{in}}}\right)

În ambele formule, al doilea parametru al distribuției normale N\mathcal{N} este varianța.

Când scriem retropropagarea de mână, o greșeală într-o derivată nu produce nicio eroare la rulare: rețeaua doar învață prost. De aceea, gradienții calculați se compară cu o aproximare numerică, obținută prin diferențe finite (finite differences). Ponderea este mărită și apoi micșorată cu o cantitate foarte mică, iar din cât se schimbă eroarea între cele două variante se obține o estimare a derivatei.

Pentru curioșiFormula diferențelor finite
∂L∂w≈L(w+ε)−L(w−ε)2ε\frac{\partial L}{\partial w} \approx \frac{L(w + \varepsilon) - L(w - \varepsilon)}{2\varepsilon}

unde ε\varepsilon este un număr mic, de exemplu 10−510^{-5}.

Metoda se numește verificarea gradienților (gradient checking). Este lentă, pentru că are nevoie de două propagări directe pentru fiecare parametru, așa că o folosim doar ca test, pe rețele mici.

x, y = 2.0, 3.0
w, v, b, c = 0.5, 1.5, 0.1, 0.0
eps = 1e-5
def loss(w, v):
a = max(0.0, w * x + b)
return 0.5 * (v * a + c - y) ** 2
# Gradienții calculați de mână în exemplul numeric
analytic = {"w": -4.05, "v": -1.485}
numeric = {
"w": (loss(w + eps, v) - loss(w - eps, v)) / (2 * eps),
"v": (loss(w, v + eps) - loss(w, v - eps)) / (2 * eps),
}
for name in analytic:
print(f"dL/d{name}: analitic {analytic[name]:.6g}, numeric {numeric[name]:.6g}")

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

În timpul antrenării merită urmărită și norma gradienților: valori foarte apropiate de zero sau foarte mari semnalează una dintre problemele de mai sus.