Retropropagare (backpropagation)
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.
De ce avem nevoie de retropropagare
Secțiune intitulată „De ce avem nevoie de retropropagare”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.
Regula lanțului
Secțiune intitulată „Regula lanțului”Retropropagarea se bazează pe regula lanțului din calculul diferențial. Dacă o variabilă depinde de , iar depinde de , atunci derivata lui în raport cu este produsul derivatelor de pe cele două verigi ale lanțului.
Pentru curioșiFormula regulii lanțului
Î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.
Exemplu concret
Secțiune intitulată „Exemplu concret”Să considerăm o rețea simplă, cu o intrare și un strat ascuns. Fiecare neuron din stratul ascuns are o pondere , un bias și o funcție de activare .
Propagare directă (forward pass)
Secțiune intitulată „Propagare directă (forward pass)”- Pentru fiecare neuron din stratul ascuns, calculăm suma ponderată .
- Apoi aplicăm funcția de activare .
- La stratul de ieșire, calculăm predicția , unde și sunt ponderile și bias-ul stratului de ieșire.
- Eroarea este , unde este valoarea corectă. Factorul face derivata mai simplă.
Retropropagare (backward pass)
Secțiune intitulată „Retropropagare (backward pass)”Acum calculăm gradienții, pornind de la ieșire.
Gradienții stratului de ieșire
Secțiune intitulată „Gradienții stratului de 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 și ai bias-ului 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:
Pentru că , gradienții parametrilor stratului de ieșire se obțin cu un singur pas al regulii lanțului:
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:
Gradienții stratului ascuns
Secțiune intitulată „Gradienții stratului ascuns”Pentru ponderea , care leagă intrarea de neuronul , lanțul continuă cu încă două verigi: funcția de activare și suma ponderată. La fel se calculează și gradientul pentru bias-ul .
Pentru curioșiCalculul gradienților în stratul ascuns
Pentru ponderea , lanțul are încă două verigi:
unde este derivata funcției de activare, iar . Pentru bias, ultima verigă este , deci .
Observăm că gradientul în raport cu ieșirea neuronului, , se calculează o singură dată și se refolosește pentru ambii parametri ai neuronului. La scară mică, aceasta este ideea care face retropropagarea eficientă.
Derivatele funcțiilor de activare
Secțiune intitulată „Derivatele funcțiilor de activare”| Funcție | Derivată |
|---|---|
| ReLU | dacă , altfel |
| Sigmoidă | |
| Tangentă hiperbolică |
În , derivata ReLU nu există. Librăriile folosesc, prin convenție, valoarea .
Algoritmul complet
Secțiune intitulată „Algoritmul complet”Un pas de antrenare are două faze:
- Propagare directă: calculăm și memorăm valorile intermediare (, ) ale fiecărui strat, de la intrare spre ieșire.
- Retropropagare: pornim de la gradientul erorii în raport cu ieșirea () ș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 (, )
- gradientul în raport cu intrarea sa, pe care îl trimite stratului anterior
Valorile memorate la propagarea directă sunt folosite aici: are nevoie de , iar gradientul unei ponderi are nevoie de intrarea stratului. De aceea, antrenarea ocupă mai multă memorie decât simpla folosire a modelului.
Actualizarea parametrilor
Secțiune intitulată „Actualizarea parametrilor”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
unde este rata de învățare.
De ce este eficient
Secțiune intitulată „De ce este eficient”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.
Probleme practice
Secțiune intitulată „Probleme practice”Gradienți care dispar (vanishing gradients)
Secțiune intitulată „Gradienți care dispar (vanishing gradients)”Î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 , așa că, după 10 straturi, doar derivatele activărilor pot micșora gradientul de până la 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ți care explodează (exploding gradients)
Secțiune intitulată „Gradienți care explodează (exploding gradients)”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
Exemplu numeric
Secțiune intitulată „Exemplu numeric”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:
- Ponderi: ,
- Bias-uri: ,
- Valoare țintă:
Propagare directă:
Retropropagare:
- și
- (derivata ReLU este 1, pentru că )
Actualizările (cu ):
Cu noii parametri, eroarea scade de la 0,91125 la aproximativ 0,19.
Exemplu interactiv
Secțiune intitulată „Exemplu interactiv”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 numericx = 2.0w = 0.5v = 1.5b = 0.1c = 0.0y = 3.0eta = 0.1
# Propagare directăz = w * x + ba = max(0.0, z) # ReLUy_pred = v * a + closs = 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 intraredL_dy_pred = y_pred - ydL_dv = dL_dy_pred * adL_dc = dL_dy_preddL_da = dL_dy_pred * vdL_dz = dL_da * (1.0 if z > 0 else 0.0) # derivata ReLUdL_dw = dL_dz * xdL_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 gradientw -= eta * dL_dwv -= eta * dL_dvb -= eta * dL_dbc -= eta * dL_dcnew_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).
Calculul automat al gradienților
Secțiune intitulată „Calculul automat al gradienților”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.
Cum funcționează autograd
Secțiune intitulată „Cum funcționează autograd”- 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.
- Calculul erorii: eroarea devine ultimul nod al grafului.
- Retropropagarea: apelul
loss.backward()parcurge graful invers, aplică regula lanțului la fiecare nod și adaugă gradienții în atributul.gradal 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 numericx = 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 grafz = w * x + ba = torch.relu(z)y_pred = v * a + closs = 0.5 * (y_pred - y) ** 2
# Retropropagare: graful este parcurs inversloss.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()).
Ce câștigăm
Secțiune intitulată „Ce câștigăm”- 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.compilesau compilatorul XLA, pot optimiza și graful întreg înainte de execuție.
Retropropagarea în timp (BPTT)
Secțiune intitulată „Retropropagarea în timp (BPTT)”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ă.
Sfaturi practice
Secțiune intitulată „Sfaturi practice”Inițializarea ponderilor
Secțiune intitulată „Inițializarea ponderilor”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 () și de ieșiri () ale stratului:
- Inițializarea Xavier (Glorot), potrivită pentru sigmoidă și tangenta hiperbolică:
- Inițializarea He, potrivită pentru ReLU și funcțiile înrudite:
În ambele formule, al doilea parametru al distribuției normale este varianța.
Verificarea gradienților
Secțiune intitulată „Verificarea gradienților”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
unde este un număr mic, de exemplu .
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.0w, v, b, c = 0.5, 1.5, 0.1, 0.0eps = 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 numericanalytic = {"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.
Bibliografie
Secțiune intitulată „Bibliografie”- Ba, J. L., Kiros, J. R. și Hinton, G. E. (2016). Layer Normalization. Preprint arXiv:1607.06450.
- Baydin, A. G. et al. (2018). Automatic differentiation in machine learning: a survey. Journal of Machine Learning Research, 18(153), 1–43.
- Bengio, Y., Simard, P. și Frasconi, P. (1994). Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2), 157–166.
- Glorot, X. și Bengio, Y. (2010). Understanding the difficulty of training deep feedforward neural networks. AISTATS 2010.
- Goodfellow, I., Bengio, Y. și Courville, A. (2016). Deep Learning. MIT Press.
- He, K. et al. (2015). Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification. ICCV 2015.
- He, K. et al. (2016). Deep Residual Learning for Image Recognition. CVPR 2016.
- Ioffe, S. și Szegedy, C. (2015). Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. ICML 2015.
- Linnainmaa, S. (1976). Taylor expansion of the accumulated rounding error. BIT, 16(2), 146–160.
- Pascanu, R., Mikolov, T. și Bengio, Y. (2013). On the difficulty of training Recurrent Neural Networks. ICML 2013.
- Paszke, A. et al. (2019). PyTorch: An Imperative Style, High-Performance Deep Learning Library. NeurIPS 2019.
- Rumelhart, D. E., Hinton, G. E. și Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533–536.
- Werbos, P. J. (1990). Backpropagation through time: what it does and how to do it. Proceedings of the IEEE, 78(10), 1550–1560.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.