Salt la conținut

Un sistem de diferențiere automată

ÎncepătorLectură: 6 min

Pe pagina despre retropropagare, gradienții unei rețele cu un singur neuron ascuns sunt calculați de mână, verigă cu verigă. Pentru o rețea cu mii de ponderi, calculul de mână nu mai este o opțiune. Librăriile precum PyTorch fac acest lucru automat: în timpul calculului, construiesc un graf computațional (computational graph), apoi îl parcurg invers și aplică regula lanțului la fiecare nod.

Pe această pagină construim un astfel de mecanism, la scară mică. Lucrăm cu numere obișnuite (scalari), nu cu matrice, ca fiecare pas să poată fi urmărit. Tot codul se află în fișierul engine.py.

La redare, playerul se încarcă de pe YouTube (detalii).

Episodul 1Retropropagarea (backpropagation) de la zero, în Pythoncapitolul „Clasa Value”

Un obiect Value învelește un număr. Pe lângă valoarea propriu-zisă, data, păstrează gradientul grad, adică derivata rezultatului final în raport cu acest număr, și ține minte din ce valori și prin ce operație a fost calculat.

engine.py
def __init__(self, data, _children=(), _op="", label=""):
self.data = float(data)
self.grad = 0.0 # derivata pierderii în raport cu această valoare, calculată de backward()
self.label = label # un nume opțional, afișat în diagrame
# Valorile din care a fost calculată aceasta și operația care le-a combinat.
self._prev = tuple(_children)
self._op = _op
# Trimite gradientul acestei valori spre valorile din care a fost calculată. Fiecare operație își scrie
# propria funcție, iar o valoare introdusă direct (o intrare sau o pondere) nu are ce trimite mai departe.
self._backward = lambda: None
def __repr__(self):
return f"Value(data={self.data:.4f}, grad={self.grad:.4f})"

Atributul _prev păstrează valorile din care a rezultat numărul, iar _op, operația. Împreună, cele două atribute formează muchiile grafului computațional. Funcția _backward este, la început, una care nu face nimic. Fiecare operație o va înlocui cu propria regulă de derivare.

Exemplul de mai jos folosește chiar fișierul engine.py al laboratorului.

from engine import Value
a = Value(2.0)
b = Value(-3.0)
c = a * b + 1
print(c)
print("operația:", c._op)
print("calculat din:", c._prev)

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

Rezultatul c știe că a fost obținut prin adunare, din produsul a * b și din constanta 1, transformată de operație tot într-un obiect Value.

Fiecare operație face două lucruri: calculează rezultatul și scrie o funcție _backward, care știe să trimită gradientul rezultatului înapoi, spre operanzi. Pentru asta, operația are nevoie doar de propria derivată locală, adică de cât de mult se schimbă rezultatul când se schimbă puțin un operand.

engine.py
def __add__(self, other):
other = other if isinstance(other, Value) else Value(other)
out = Value(self.data + other.data, (self, other), "+")
def _backward():
# La adunare, gradientul trece neschimbat spre ambii termeni.
self.grad += out.grad
other.grad += out.grad
out._backward = _backward
return out
def __mul__(self, other):
other = other if isinstance(other, Value) else Value(other)
out = Value(self.data * other.data, (self, other), "*")
def _backward():
# La înmulțire, fiecare factor primește gradientul înmulțit cu celălalt factor.
self.grad += other.data * out.grad
other.grad += self.data * out.grad
out._backward = _backward
return out

La adunare, derivata locală este 1 pentru ambii termeni, așa că gradientul trece neschimbat. La înmulțire, derivata în raport cu un factor este celălalt factor. În ambele cazuri, derivata locală este înmulțită cu out.grad, gradientul rezultatului. Aceasta este regula lanțului: gradientul unui operand este gradientul rezultatului înmulțit cu derivata locală.

Pentru curioșiRegula lanțului pentru adunare și înmulțire

Fie LL rezultatul final și out=x+yout = x + y. Derivatele locale sunt ∂out∂x=∂out∂y=1\frac{\partial out}{\partial x} = \frac{\partial out}{\partial y} = 1, deci:

∂L∂x=∂L∂out⋅1,∂L∂y=∂L∂out⋅1\frac{\partial L}{\partial x} = \frac{\partial L}{\partial out} \cdot 1, \qquad \frac{\partial L}{\partial y} = \frac{\partial L}{\partial out} \cdot 1

Pentru out=x⋅yout = x \cdot y, derivatele locale sunt ∂out∂x=y\frac{\partial out}{\partial x} = y și ∂out∂y=x\frac{\partial out}{\partial y} = x:

∂L∂x=∂L∂out⋅y,∂L∂y=∂L∂out⋅x\frac{\partial L}{\partial x} = \frac{\partial L}{\partial out} \cdot y, \qquad \frac{\partial L}{\partial y} = \frac{\partial L}{\partial out} \cdot x

În cod, ∂L∂out\frac{\partial L}{\partial out} este out.grad.

Funcțiile de activare urmează același tipar. Derivatele acestor funcții sunt cele din tabelul de pe pagina despre retropropagare.

engine.py
def tanh(self):
t = math.tanh(self.data)
out = Value(t, (self,), "tanh")
def _backward():
self.grad += (1 - t**2) * out.grad
out._backward = _backward
return out
def relu(self):
out = Value(max(0.0, self.data), (self,), "relu")
def _backward():
# Gradientul trece doar dacă neuronul a fost activ (rezultat pozitiv).
self.grad += (out.data > 0) * out.grad
out._backward = _backward
return out

Și ridicarea la putere, și funcția exponențială au câte o derivată proprie. Celelalte operații nu mai au nevoie de una: scăderea este adunarea cu un număr negativ, iar împărțirea este înmulțirea cu puterea −1.

engine.py
def __pow__(self, exponent):
assert isinstance(exponent, (int, float)), "exponentul trebuie să fie un număr obișnuit"
out = Value(self.data**exponent, (self,), f"**{exponent}")
def _backward():
self.grad += exponent * self.data ** (exponent - 1) * out.grad
out._backward = _backward
return out
def exp(self):
out = Value(math.exp(self.data), (self,), "exp")
def _backward():
# Derivata lui e^x este tot e^x, adică exact rezultatul.
self.grad += out.data * out.grad
out._backward = _backward
return out
def __neg__(self):
return self * -1
def __sub__(self, other):
return self + (-other)
def __truediv__(self, other):
return self * other**-1

Metodele __radd__, __rmul__, __rsub__ și __rtruediv__ tratează cazul în care numărul obișnuit este primul termen, de exemplu 2 * x. Python încearcă întâi int.__mul__(2, x), care nu știe ce este un Value, apoi x.__rmul__(2).

În toate funcțiile _backward, gradientul se adaugă cu +=, nu se atribuie cu =. Motivul este că o valoare poate fi folosită de mai multe ori. În y=x⋅x+xy = x \cdot x + x, valoarea xx apare de trei ori, iar fiecare apariție contribuie la gradient. Derivata corectă este 2x+12x + 1, deci 7 pentru x=3x = 3.

from engine import Value
x = Value(3.0)
y = x * x + x
y.backward()
print("dy/dx =", x.grad)
# Un al doilea backward(), fără ștergerea gradienților.
y.backward()
print("după încă un backward():", x.grad)

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

Cu =, fiecare contribuție ar suprascrie-o pe cea de dinainte, iar rezultatul ar fi greșit. Partea a doua a exemplului arată ce se întâmplă când gradienții se adună și de la un apel backward() la altul. Al doilea apel pornește de la gradienții rămași după primul, inclusiv pe valorile intermediare, așa că rezultatul, 20, nu mai este derivata lui yy. De aceea, la antrenare, gradienții sunt readuși la zero înaintea fiecărui pas, la fel ca optimizer.zero_grad() în PyTorch.

Pentru ca _backward să trimită un gradient corect mai departe, gradientul rezultatului trebuie să fie deja complet, cu toate contribuțiile adunate. Valorile trebuie deci parcurse într-o ordine în care fiecare valoare vine înaintea celor din care a fost calculată. Aceasta este inversul unei ordini topologice (topological order), în care fiecare nod al grafului apare după toate nodurile de care depinde.

engine.py
def backward(self):
# Ordinea topologică: fiecare valoare apare după toate valorile din care a fost calculată.
topo = []
visited = set()
def build(v):
if v not in visited:
visited.add(v)
for child in v._prev:
build(child)
topo.append(v)
build(self)
# Derivata unei valori în raport cu ea însăși este 1. De aici, gradientul merge înapoi, nod cu nod.
self.grad = 1.0
for v in reversed(topo):
v._backward()

Funcția build face o parcurgere în adâncime a grafului: o valoare este adăugată în listă abia după ce au fost adăugate toate valorile din care a fost calculată. Apoi, gradientul rezultatului final primește valoarea 1, pentru că derivata unei mărimi în raport cu aceeași mărime este 1, iar lista este parcursă de la coadă la cap.

Să considerăm expresia L=(a⋅b+c)⋅fL = (a \cdot b + c) \cdot f, cu a=2a = 2, b=−3b = -3, c=7c = 7 și f=−2f = -2. Codul de mai jos refolosește funcția build ca să afișeze ordinea topologică, apoi calculează gradienții.

from engine import Value
a = Value(2.0, label="a")
b = Value(-3.0, label="b")
c = Value(7.0, label="c")
f = Value(-2.0, label="f")
e = a * b
e.label = "e"
d = e + c
d.label = "d"
L = d * f
L.label = "L"
# Aceeași parcurgere ca în backward().
topo, visited = [], set()
def build(v):
if v not in visited:
visited.add(v)
for child in v._prev:
build(child)
topo.append(v)
build(L)
print("ordinea topologică:", [v.label for v in topo])
L.backward()
for v in [a, b, c, f]:
print(f"dL/d{v.label} = {v.grad}")

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

Retropropagarea începe cu LL, trece prin dd și ff, apoi prin cc și ee și se termină cu aa și bb. Același calcul, făcut de mână, dă exact aceleași numere.

Pentru curioșiGradienții expresiei, calculați de mână

Valorile intermediare sunt e=a⋅b=−6e = a \cdot b = -6 și d=e+c=1d = e + c = 1, iar L=d⋅f=−2L = d \cdot f = -2. Pornind de la ∂L∂L=1\frac{\partial L}{\partial L} = 1:

∂L∂d=f=−2,∂L∂f=d=1\frac{\partial L}{\partial d} = f = -2, \qquad \frac{\partial L}{\partial f} = d = 1∂L∂c=∂L∂e=∂L∂d⋅1=−2\frac{\partial L}{\partial c} = \frac{\partial L}{\partial e} = \frac{\partial L}{\partial d} \cdot 1 = -2∂L∂a=∂L∂e⋅b=6,∂L∂b=∂L∂e⋅a=−4\frac{\partial L}{\partial a} = \frac{\partial L}{\partial e} \cdot b = 6, \qquad \frac{\partial L}{\partial b} = \frac{\partial L}{\partial e} \cdot a = -4

Gradientul lui aa, egal cu 6, spune că dacă aa crește cu o cantitate mică, LL crește de aproximativ 6 ori mai mult. Pe pagina următoare, aceleași numere apar în diagrama grafului.

O greșeală într-o derivată locală nu produce nicio eroare la rulare, doar gradienți greșiți. Ca pe pagina despre retropropagare, putem compara rezultatul cu o aproximare prin diferențe finite: modificăm puțin o intrare în sus și în jos și vedem cât se schimbă rezultatul.

Exemplul de mai jos verifică un neuron cu două intrări și activare tanh. Pentru a încerca și operațiile derivate, a doua variantă a neuronului calculează tanh din formula cu exponențiale, cu exp, scădere și împărțire.

from engine import Value
def neuron(x1, x2, w1, w2, b, tanh_from_exp=False):
n = x1 * w1 + x2 * w2 + b
if tanh_from_exp:
e = (2 * n).exp()
return (e - 1) / (e + 1) # tanh(n), scris cu exponențiale
return n.tanh()
inputs = {"x1": 1.0, "x2": -2.0, "w1": 0.5, "w2": 0.25, "b": 0.8}
eps = 1e-6
for tanh_from_exp in [False, True]:
values = {k: Value(v) for k, v in inputs.items()}
o = neuron(**values, tanh_from_exp=tanh_from_exp)
o.backward()
print("tanh din exponențiale" if tanh_from_exp else "tanh direct", f"o = {o.data:.6f}")
for k in inputs:
up = {n: Value(v + eps * (n == k)) for n, v in inputs.items()}
down = {n: Value(v - eps * (n == k)) for n, v in inputs.items()}
numeric = (neuron(**up).data - neuron(**down).data) / (2 * eps)
print(f" do/d{k}: backward {values[k].grad:+.6f}, diferențe finite {numeric:+.6f}")

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

Cele două variante dau aceiași gradienți, deși graful celei de-a doua are mai multe noduri. Sistemul nu are nevoie să știe că expresia este tanh: îi este suficient să cunoască derivata fiecărei operații mici.

În PyTorch, același calcul se scrie aproape la fel. Tensorii cu requires_grad=True joacă rolul obiectelor Value, iar backward() face aceeași parcurgere a grafului. PyTorch nu rulează în browser, așa că rezultatele sunt trecute în comentarii.

import torch
# Aceeași expresie, L = (a * b + c) * f, cu tensori PyTorch de un singur număr
a = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(-3.0, requires_grad=True)
c = torch.tensor(7.0, requires_grad=True)
f = torch.tensor(-2.0, requires_grad=True)
L = (a * b + c) * f
L.backward()
print(L.item()) # -2.0
print(a.grad.item(), b.grad.item(), c.grad.item(), f.grad.item()) # 6.0 -4.0 -2.0 1.0

Diferența este de scară, nu de principiu. Un tensor PyTorch ține mii sau milioane de numere, iar fiecare operație are derivata scrisă pentru matrice întregi, cu cod optimizat pentru procesor și placa grafică. Pe ultima pagină a laboratorului facem același pas, de la numere la matrice, cu NumPy.