Salt la conținut

Grafuri computaționale cu Graphviz

ÎncepătorLectură: 5 min

Pe pagina anterioară, fiecare obiect Value a ținut minte din ce valori a fost calculat. Aceste legături formează un graf, iar metoda backward() îl parcurge de la rezultat spre intrări. Pe această pagină îl desenăm, ca să vedem exact ce parcurge retropropagarea și cum apar gradienții pe nodurile grafului.

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

Episodul 1Retropropagarea (backpropagation) de la zero, în Pythoncapitolul „Grafuri computaționale cu Graphviz”

Graphviz este un set de programe pentru desenarea grafurilor, dezvoltat inițial la AT&T Bell Labs. Graful se descrie ca text, în limbajul DOT: o listă de noduri, fiecare cu propriile atribute, și o listă de muchii, scrise cu săgeți. Programul dot așază singur nodurile, pe niveluri, și desenează muchiile.

digraph {
rankdir=LR;
a [shape=record, label="{ a | { data 2.0000 | grad 0.0000 } }"];
b [shape=record, label="{ b | { data -3.0000 | grad 0.0000 } }"];
mul [label="*"];
a -> mul;
b -> mul;
}

digraph înseamnă graf orientat, cu săgeți. rankdir=LR așază graful de la stânga la dreapta. Forma record împarte un dreptunghi în câmpuri, cu bara verticală | între câmpuri, iar acoladele schimbă direcția în care sunt așezate câmpurile: numele valorii stă în stânga, iar valoarea și gradientul, unul sub altul, în dreapta.

Fișierul graph.py are trei funcții. Prima, trace, adună toate valorile și legăturile dintre valori, pornind de la rezultat, la fel ca funcția build din backward().

graph.py
def trace(root):
# Toate valorile din care a fost calculată rădăcina și legăturile dintre ele, pornind de la rădăcină.
nodes, edges = [], []
seen = set()
def build(v):
if v in seen:
return
seen.add(v)
nodes.append(v)
for child in v._prev:
edges.append((child, v))
build(child)
build(root)
return nodes, edges
def to_dot(root, rankdir="LR"):
nodes, edges = trace(root)
ids = {v: f"v{i}" for i, v in enumerate(nodes)}
lines = [
"digraph {",
f" rankdir={rankdir}; nodesep=0.15; ranksep=0.3;", # LR: de la stânga la dreapta, în ordinea calculului
' node [fontname="Helvetica", fontsize=11];',
]
for v in nodes:
# O valoare este un dreptunghi cu numele ei (dacă are unul) și, unul sub altul, valoarea și gradientul.
name = f"{v.label} | " if v.label else ""
fields = f"{{ data {v.data:.4f} | grad {v.grad:.4f} }}"
lines.append(f' {ids[v]} [shape=record, label="{{ {name}{fields} }}"];')
if v._op:
# Operația care a produs valoarea este un nod separat, de formă ovală, legat de rezultat.
lines.append(f' {ids[v]}_op [label="{v._op}", width=0.4, height=0.3];')
lines.append(f" {ids[v]}_op -> {ids[v]};")
for child, parent in edges:
lines.append(f" {ids[child]} -> {ids[parent]}_op;")
lines.append("}")
return "\n".join(lines)

Funcția to_dot scrie apoi graful în limbajul DOT. Fiecare valoare devine un dreptunghi, iar fiecare valoare care a rezultat dintr-o operație primește în plus un nod oval pentru operație. Muchiile merg de la operanzi spre operație și de la operație spre rezultat. Nodurile primesc nume scurte, v0, v1 și așa mai departe, în ordinea în care le-a găsit trace.

Funcția to_dot folosește doar Python, deci rulează și în browser. Exemplul de mai jos scrie textul DOT al expresiei L=(a⋅b+c)⋅fL = (a \cdot b + c) \cdot f de pe pagina anterioară, după retropropagare.

from engine import Value
from graph import to_dot
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"
L.backward()
print(to_dot(L))

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

A treia funcție, draw_graph, dă textul DOT pachetului Python graphviz, care apelează programul dot și primește înapoi imaginea. Cu un nume de fișier, imaginea este și salvată, în formatul dat de extensie (.svg, .png sau .pdf).

graph.py
def draw_graph(root, path=None, rankdir="LR"):
import graphviz
graph = graphviz.Source(to_dot(root, rankdir))
if path:
# Formatul imaginii (svg, png, pdf) vine din extensia fișierului.
graph.render(outfile=path, cleanup=True)
return graph

În Jupyter și în Google Colab, obiectul întors de draw_graph se afișează singur, ca imagine, dacă este ultimul rând al unei celule. Graphviz nu rulează în browser, așa că diagramele de mai jos au fost desenate local, de scriptul diagrams.py. Pentru expresie, scriptul desenează graful de două ori, înainte și după backward().

diagrams.py
def draw_before_and_after():
# Același graf, desenat de două ori: imediat după calcul și după retropropagare.
L = expression()
draw_graph(L, f"{OUT}/expresie-inainte.svg")
L.backward()
draw_graph(L, f"{OUT}/expresie-dupa.svg")
return L

Imediat după calculul expresiei, fiecare nod are valoarea calculată, dar toți gradienții sunt zero. Propagarea directă a calculat doar valorile.

Graful expresiei L = (a * b + c) * f înainte de retropropagare. Valorile a = 2, b = -3, c = 7 și f = -2 duc, prin operațiile înmulțire, adunare și înmulțire, la e = -6, d = 1 și L = -2. Toți gradienții sunt 0. L data -2.0000 grad 0.0000 * d data 1.0000 grad 0.0000 + e data -6.0000 grad 0.0000 * a data 2.0000 grad 0.0000 b data -3.0000 grad 0.0000 c data 7.0000 grad 0.0000 f data -2.0000 grad 0.0000
Graful expresiei L = (a · b + c) · f, înainte de retropropagare: toți gradienții sunt 0.

După L.backward(), gradienții au fost completați de la dreapta la stânga. LL are gradientul 1, iar fiecare operație a trimis gradientul spre operanzi, după propria regulă.

Același graf după retropropagare. Gradienții sunt: L 1, d -2, f 1, e -2, c -2, a 6 și b -4. L data -2.0000 grad 1.0000 * d data 1.0000 grad -2.0000 + e data -6.0000 grad -2.0000 * a data 2.0000 grad 6.0000 b data -3.0000 grad -4.0000 c data 7.0000 grad -2.0000 f data -2.0000 grad 1.0000
Același graf după L.backward(): gradienții au fost trimiși de la L spre intrări.

Diagrama se citește de la dreapta la stânga. Înmulțirea finală, L=d⋅fL = d \cdot f, dă fiecărui factor gradientul lui LL înmulțit cu celălalt factor: dd primește f=−2f = -2, iar ff primește d=1d = 1. Adunarea d=e+cd = e + c trimite același −2-2 ambilor termeni. În sfârșit, înmulțirea e=a⋅be = a \cdot b dă lui aa valoarea −2⋅b=6-2 \cdot b = 6 și lui bb valoarea −2⋅a=−4-2 \cdot a = -4.

Același mecanism funcționează pentru un neuron cu două intrări și activare tanh, cu intrările x1=1x_1 = 1 și x2=−2x_2 = -2, ponderile w1=0,5w_1 = 0{,}5 și w2=0,25w_2 = 0{,}25 și bias-ul b=0,8b = 0{,}8.

Graful unui neuron: x1 * w1 și x2 * w2 sunt adunate în s = 0, apoi n = s + b = 0,8 și o = tanh(n) = 0,664. După retropropagare, n, s, b și cele două produse au gradientul 0,5591, w1 are 0,5591, w2 are -1,1181, x1 are 0,2795 și x2 are 0,1398. o data 0.6640 grad 1.0000 tanh n data 0.8000 grad 0.5591 + s data 0.0000 grad 0.5591 + x1*w1 data 0.5000 grad 0.5591 * x1 data 1.0000 grad 0.2795 w1 data 0.5000 grad 0.5591 x2*w2 data -0.5000 grad 0.5591 * x2 data -2.0000 grad 0.1398 w2 data 0.2500 grad -1.1181 b data 0.8000 grad 0.5591
Un neuron, o = tanh(x1 · w1 + x2 · w2 + b), după retropropagare.

Suma ponderată este n=0,8n = 0{,}8, iar ieșirea este o=tanh⁡(0,8)≈0,664o = \tanh(0{,}8) \approx 0{,}664. Prin tanh, gradientul se înmulțește cu derivata lui tanh, 1−o2≈0,55911 - o^2 \approx 0{,}5591. De aici, adunările îl trimit neschimbat spre bias și spre cele două produse, iar înmulțirile îl înmulțesc cu celălalt factor. Gradientul ponderii w2w_2, de exemplu, este 0,5591⋅x2≈−1,1180{,}5591 \cdot x_2 \approx -1{,}118: dacă w2w_2 ar crește puțin, ieșirea ar scădea.

Pentru antrenare contează doar gradienții ponderilor și ai bias-ului, pentru că doar ponderile și bias-ul pot fi modificate. Gradienții intrărilor x1x_1 și x2x_2 sunt calculați la fel, dar nu sunt folosiți.

Graful crește repede. Rețeaua de mai jos are 2 intrări, un strat ascuns cu 2 neuroni cu activare ReLU și un neuron de ieșire, fără activare. Ponderile au fost alese de mână și au nume: wjiw_{ji} leagă intrarea ii de neuronul ascuns jj, iar vjv_j leagă neuronul ascuns jj de ieșire. Ultimele noduri calculează pierderea pentru un singur exemplu, (y−1)2(y - 1)^2, adică eroarea pătratică față de ținta 1. Pe ecranele înguste, diagrama se derulează orizontal.

Graful unei rețele cu intrările x1 = 1 și x2 = -1, doi neuroni ascunși cu ReLU și o ieșire y = 1,32, urmată de pierderea (y - 1)^2 = 0,1024. Primul neuron ascuns are suma 0,85, este activ și are ponderi cu gradienți nenuli (w11 0,768, w12 -0,768, b1 0,768). Al doilea are suma -0,5, iese 0 prin ReLU și are ponderi cu gradientul 0. pierdere data 0.1024 grad 1.0000 **2 data 0.3200 grad 0.6400 + y data 1.3200 grad 0.6400 + data 1.3200 grad 0.6400 + c data 0.3000 grad 0.6400 data 1.0200 grad 0.6400 * v1 data 1.2000 grad 0.5440 data 0.8500 grad 0.7680 relu data 0.8500 grad 0.7680 + data 0.6000 grad 0.7680 + b1 data 0.1000 grad 0.7680 data 0.5000 grad 0.7680 * w11 data 0.5000 grad 0.7680 x1 data 1.0000 grad 0.3840 * data 0.2500 grad 0.7680 * w12 data -0.2500 grad -0.7680 x2 data -1.0000 grad -0.1920 * data 0.0000 grad 0.6400 * v2 data 0.6000 grad 0.0000 data 0.0000 grad 0.3840 relu data -0.5000 grad 0.0000 + data -0.2000 grad 0.0000 + b2 data 0.2000 grad 0.0000 data -0.4000 grad 0.0000 w21 data -0.4000 grad 0.0000 data -0.3000 grad 0.0000 w22 data 0.3000 grad 0.0000 data -1.0000 grad 0.6400
O rețea cu 2 intrări, 2 neuroni ascunși cu ReLU și o ieșire, plus pierderea pe un exemplu, după retropropagare.

Câteva lucruri se văd direct pe diagramă:

  • Pierderea este (1,32−1)2=0,1024(1{,}32 - 1)^2 = 0{,}1024, iar gradientul pierderii în raport cu yy este 2⋅(1,32−1)=0,642 \cdot (1{,}32 - 1) = 0{,}64.
  • Scăderea y−1y - 1 apare ca o adunare cu −1-1, pentru că așa este scrisă în engine.py. La fel, constanta −1-1 apare ca un nod separat, cu propriul gradient, pe care nu îl folosește nimeni.
  • Primul neuron ascuns are suma ponderată 0,85, deci ReLU îl lasă să treacă, iar ponderile neuronului primesc gradienți. Al doilea are suma −0,5-0{,}5, ReLU îl transformă în 0, iar gradientul se oprește aici: w21w_{21}, w22w_{22} și b2b_2 au gradientul 0 și nu se vor schimba la acest pas.
  • Și ponderea v2v_2 are gradientul 0, pentru că înmulțește ieșirea 0 a neuronului inactiv.

Rețeaua are doar 9 parametri, iar graful are deja câteva zeci de noduri. O rețea pentru recunoașterea cifrelor, cu peste 100.000 de parametri, ar avea sute de mii de noduri pentru o singură imagine. Diagramele sunt utile pentru înțelegere, dar următoarele pagini lucrează doar cu numere.

Pe calculatorul local, după pregătirea mediului, diagramele de pe această pagină se obțin cu o singură comandă.

Terminal window
python diagrams.py

Scriptul afișează câteva valori și salvează cele patru imagini în directorul imagini/.

Expresia L = (a * b + c) * f
L = -2.0
Neuronul: o = 0.6640
Rețeaua mică: pierderea = 0.1024
Diagramele au fost salvate în imagini