Calcul diferențial și integral pentru învățarea automată

Derivatele vă arată în ce direcție trebuie să coborâți. O rețea neuronală nu are nevoie de mai mult pentru a învăța.

Tip: Învățare Limbaj: Python Cerințe preliminare: Faza 1, lecțiile 01–03 Durată: ~60 de minute

Obiective de învățare

• Calcularea derivatelor numerice și analitice pentru funcții uzuale din învățarea automată (machine learning, ML): x^2, sigmoidă și entropie încrucișată
• Implementarea de la zero a coborârii pe gradient (gradient descent) pentru minimizarea unei funcții de pierdere în 1D și 2D
• Deducerea gradientului unui model de regresie liniară și antrenarea acestuia prin actualizarea manuală a ponderilor
• Explicarea matricei hessiene, a aproximărilor prin serii Taylor și a legăturii lor cu metodele de optimizare

Problema

Aveți o rețea neuronală cu milioane de ponderi. Fiecare pondere este ca un buton de reglaj. Trebuie să aflați în ce direcție să rotiți fiecare buton pentru ca modelul să greșească puțin mai puțin. Calculul diferențial vă oferă această direcție.

Fără calcul diferențial, antrenarea unei rețele neuronale ar însemna să încercați modificări aleatorii și să sperați la cel mai bun rezultat. Cu ajutorul derivatelor, știți exact cum influențează fiecare pondere eroarea. De fiecare dată, rotiți toate butoanele în direcția corectă.

Conceptul

Ce este o derivată?

O derivată măsoară rata de variație. Pentru o funcție y = f(x), derivata f’(x) vă spune cu cât se modifică y atunci când modificați foarte puțin valoarea lui x.

Geometric, derivata reprezintă panta dreptei tangente într-un punct.

f(x) = x^2:

x	f(x)	f’(x) (pantă)
0	0	0 (orizontală, în punctul de minim)
1	1	2
2	4	4 (panta tangentei în acest punct)
3	9	6

La x=2, panta este 4. Dacă deplasați foarte puțin x spre dreapta, y crește cu aproximativ de patru ori acea deplasare. La x=0, panta este 0. Vă aflați în partea de jos a curbei în formă de bol.

Definiția formală:

f'(x) = lim   f(x + h) - f(x)
        h->0  -----------------
                     h

În cod, omiteți limita și utilizați pur și simplu o valoare h foarte mică. Astfel obțineți derivata numerică.

Derivate parțiale: câte o variabilă pe rând

Funcțiile întâlnite în practică au numeroase intrări. Pierderea unei rețele neuronale depinde de mii de ponderi. Pentru o derivată parțială, toate variabilele sunt menținute constante, cu excepția uneia, iar derivarea se face în raport cu acea variabilă.

f(x, y) = x^2 + 3xy + y^2

df/dx = 2x + 3y     (considerați y constantă)
df/dy = 3x + 2y     (considerați x constantă)

Fiecare derivată parțială răspunde la întrebarea: dacă modificați puțin numai această pondere, cum se schimbă pierderea?

Gradientul: vectorul tuturor derivatelor parțiale

Gradientul reunește toate derivatele parțiale într-un singur vector. Pentru o funcție f(x, y, z), gradientul este:

grad f = [ df/dx, df/dy, df/dz ]

Gradientul este orientat în direcția celei mai rapide creșteri. Pentru a minimiza o funcție, deplasați-vă în direcția opusă.

Diagramă cu curbe de nivel pentru f(x,y) = x^2 + y^2:

Funcția are forma unui bol, iar curbele sale de nivel sunt cercuri concentrice. Minimul se află în (0, 0).

Punct	grad f	-grad f (direcția coborârii)
(1, 1)	[2, 2] (orientat în sus, departe de minim)	[-2, -2] (orientat în jos, către minim)
(0, 0)	[0, 0] (orizontal, în punctul de minim)	[0, 0]

Aceasta este reprezentarea vizuală a coborârii pe gradient. Calculați gradientul, schimbați-i semnul și efectuați un pas.

Legătura cu optimizarea

Antrenarea unei rețele neuronale este o problemă de optimizare. Aveți o funcție de pierdere L(w1, w2, …, wn), care măsoară cât de mult greșește modelul. Doriți să o minimizați.

Regula de actualizare pentru coborârea pe gradient:

  w_new = w_old - learning_rate * dL/dw

Pentru fiecare pondere:
  1. Calculați derivata parțială a pierderii în raport cu ponderea respectivă
  2. Scădeți din pondere un multiplu mic al derivatei
  3. Repetați

Rata de învățare controlează dimensiunea pasului. Dacă este prea mare, depășiți minimul. Dacă este prea mică, avansați foarte lent.

Peisajul funcției de pierdere (secțiune 1D):

Funcția de pierdere L(w) formează o curbă cu vârfuri și văi pe măsură ce ponderea w variază.

Caracteristică	Descriere
Minim global	Cel mai jos punct al întregii curbe: cea mai bună soluție
Minim local	O vale mai joasă decât valorile din vecinătatea sa, dar nu cea mai joasă din întreaga curbă
Pantă	Coborârea pe gradient urmează panta descendentă din orice punct de pornire

Coborârea pe gradient urmează panta descendentă. Poate rămâne blocată în minime locale, dar în spații cu multe dimensiuni, adică milioane de ponderi, aceasta este rareori o problemă practică.

Derivate numerice și analitice

Există două moduri de a calcula o derivată.

Metoda analitică: aplicați manual regulile calculului diferențial. Pentru f(x) = x^2, derivata este f’(x) = 2x. Rezultatul este exact și se calculează rapid.

Metoda numerică: aproximați folosind definiția. Calculați f(x+h) și f(x-h) pentru o valoare h foarte mică, apoi utilizați diferența.

Metoda numerică (diferență centrată):

f'(x) ~= f(x + h) - f(x - h)
          -----------------------
                  2h

h = 0.0001 funcționează bine în practică

Derivatele numerice se calculează mai lent, dar funcționează pentru orice funcție. Derivatele analitice se calculează rapid, dar necesită deducerea formulei. Frameworkurile pentru rețele neuronale folosesc o a treia abordare: diferențierea automată, care calculează mecanic derivate exacte. O veți întâlni în faza 3.

Derivarea manuală a funcțiilor simple

Acestea sunt derivatele pe care le veți întâlni în mod repetat în ML.

Funcție         Derivată         Utilizare
--------        ----------       -------
f(x) = x^2     f'(x) = 2x      Funcții de pierdere (MSE)
f(x) = wx + b  f'(w) = x        Strat liniar (gradient în raport cu ponderea)
                f'(b) = 1        Strat liniar (gradient în raport cu biasul)
                f'(x) = w        Strat liniar (gradient în raport cu intrarea)
f(x) = e^x     f'(x) = e^x     Softmax, atenție
f(x) = ln(x)   f'(x) = 1/x     Pierdere prin entropie încrucișată
f(x) = 1/(1+e^-x)  f'(x) = f(x)(1-f(x))   Activare sigmoidă

Pentru f(x) = x^2:

f(x) = x^2    f'(x) = 2x

  x    f(x)   f'(x)   semnificație
  -2    4      -4      panta este înclinată spre stânga (descreștere)
  -1    1      -2      panta este înclinată spre stânga (descreștere)
   0    0       0      orizontală (minim!)
   1    1       2      panta este înclinată spre dreapta (creștere)
   2    4       4      panta este înclinată spre dreapta (creștere)

Pentru f(w) = wx + b, cu x=3, b=1:

f(w) = 3w + 1    f'(w) = 3

Derivata în raport cu w este chiar x.
Dacă x este mare, o mică variație a lui w produce o variație mare a ieșirii.

Regula lanțului

Când funcțiile sunt compuse, regula lanțului vă arată cum să le derivați.

Dacă y = f(g(x)), atunci dy/dx = f'(g(x)) * g'(x)

Exemplu: y = (3x + 1)^2
  exterior: f(u) = u^2       f'(u) = 2u
  interior: g(x) = 3x + 1    g'(x) = 3
  dy/dx = 2(3x + 1) * 3 = 6(3x + 1)

Rețelele neuronale sunt lanțuri de funcții: intrare -> liniar -> activare -> liniar -> activare -> pierdere. Retropropagarea (backpropagation) este regula lanțului aplicată în mod repetat, de la ieșire către intrare. Acesta este întregul algoritm.

Matricea hessiană

Gradientul vă indică panta. Matricea hessiană vă indică curbura.

Hessiana este matricea derivatelor parțiale de ordinul al doilea. Pentru o funcție f(x1, x2, …, xn), elementul (i, j) al Hessienei este:

H[i][j] = d^2f / (dx_i * dx_j)

Pentru o funcție cu două variabile f(x, y):

H = | d^2f/dx^2    d^2f/dxdy |
    | d^2f/dydx    d^2f/dy^2 |

Ce vă indică Hessiana într-un punct critic, unde gradient = 0:

Proprietatea Hessienei	Semnificație	Exemplu de suprafață
Pozitiv definită (toate valorile proprii > 0)	Minim local	Bol orientat în sus
Negativ definită (toate valorile proprii < 0)	Maxim local	Bol orientat în jos
Indefinită (valori proprii cu semne diferite)	Punct de șa	Suprafață în formă de șa

Exemplu: f(x, y) = x^2 - y^2 (o funcție în formă de șa)

df/dx = 2x       df/dy = -2y
d^2f/dx^2 = 2    d^2f/dy^2 = -2    d^2f/dxdy = 0

H = | 2   0 |
    | 0  -2 |

Valori proprii: 2 și -2 (una pozitivă, una negativă)
--> Punct de șa în (0, 0)

Comparați cu f(x, y) = x^2 + y^2 (un bol):

H = | 2  0 |
    | 0  2 |

Valori proprii: 2 și 2 (ambele pozitive)
--> Minim local în (0, 0)

De ce este importantă Hessiana în ML:

Metoda lui Newton utilizează Hessiana pentru a efectua pași de optimizare mai buni decât coborârea pe gradient. În loc să urmeze doar panta, aceasta ia în calcul curbura:

Actualizarea Newton:       w_new = w_old - H^(-1) * gradient
Coborârea pe gradient:     w_new = w_old - lr * gradient

Metoda lui Newton converge mai repede deoarece Hessiana „rescalează” gradientul: direcțiile abrupte primesc pași mai mici, iar direcțiile plate primesc pași mai mari.

Dezavantajul: pentru o rețea neuronală cu N parametri, Hessiana are dimensiunea N x N. Un model cu un milion de parametri ar necesita o matrice cu un trilion de elemente. Din acest motiv folosim aproximări.

Metodă	Ce utilizează	Cost	Convergență
Coborârea pe gradient	Numai derivate de ordinul întâi	O(N) per pas	Lentă (liniară)
Metoda lui Newton	Hessiana completă	O(N^3) per pas	Rapidă (pătratică)
L-BFGS	Aproximarea Hessienei pe baza istoricului gradienților	O(N) per pas	Medie (superliniară)
Adam	Estimări mobile ale primului și celui de-al doilea moment necentrat al gradientului	O(N) per pas	Medie
Gradient natural	Matricea informației Fisher (Hessiană statistică)	O(N^2) per pas	Rapidă

În practică, Adam este un optimizator implicit frecvent pentru învățarea profundă. El adaptează actualizarea fiecărui parametru folosind estimări mobile ale mediei gradientului și ale pătratului gradientului. Adam nu este, în general, o aproximare a Hessienei și nici o metodă de ordinul al doilea.

Notă tehnică a traducerii: Originalul descrie Adam drept o aproximare diagonală a Hessienei și o aproximare a informației de ordinul al doilea. Formularea a fost corectată conform algoritmului Adam.

Aproximarea prin seria Taylor

Orice funcție netedă poate fi aproximată local printr-un polinom:

f(x + h) = f(x) + f'(x)*h + (1/2)*f''(x)*h^2 + (1/6)*f'''(x)*h^3 + ...

Cu cât includeți mai mulți termeni, cu atât aproximarea este mai bună, dar numai în apropierea punctului x.

De ce sunt importante seriile Taylor pentru ML:

• Taylor de ordinul întâi și coborârea pe gradient. Când utilizați f(x + h) ~ f(x) + f’(x)*h, realizați o aproximare liniară. Acest model nu are un minim finit dacă pasul h nu este restricționat. Coborârea pe gradient alege în schimb un pas limitat în direcția gradientului negativ, h = -lr * f’(x).

Notă tehnică a traducerii: Originalul afirmă că pasul de coborâre pe gradient minimizează necondiționat modelul Taylor liniar. Aici este precizată necesitatea restricționării pasului.

• Taylor de ordinul al doilea = metoda lui Newton. Utilizând f(x + h) ~ f(x) + f’(x)*h + (1/2)*f’‘(x)*h^2, obțineți un model pătratic. Minimizarea sa produce h = -f’(x)/f’’(x), adică pasul Newton.

• Proiectarea funcției de pierdere. MSE și entropia încrucișată sunt funcții netede, ceea ce înseamnă că dezvoltările lor Taylor se comportă bine. Acest lucru nu este întâmplător. Funcțiile de pierdere netede fac optimizarea previzibilă.

Ordinul aproximării     Ce surprinde         Metoda de optimizare
-------------------     -----------------    -------------------
Ordinul 0 (constantă)   Numai valoarea       Căutare aleatorie
Ordinul 1 (liniară)     Panta                Coborâre pe gradient
Ordinul 2 (pătratică)   Curbura              Metoda lui Newton
Ordine superioare       Structură mai fină   Rareori utilizate în ML

Ideea esențială: orice optimizare bazată pe gradient constă, de fapt, în aproximarea locală a funcției de pierdere și efectuarea unui pas către minimul aproximării respective.

Integralele în ML

Derivatele vă indică ratele de variație. Integralele calculează acumulări, adică aria de sub o curbă.

În ML, rareori calculați integrale manual, dar conceptul apare pretutindeni:

Probabilitate. Pentru o variabilă aleatoare continuă cu densitatea p(x):

P(a < X < b) = integrala de la a la b din p(x) dx

Aria de sub curba densității de probabilitate între a și b reprezintă probabilitatea ca valoarea să se afle în acel interval.

Speranță matematică. Rezultatul mediu ponderat cu probabilitatea:

E[f(X)] = integrala din f(x) * p(x) dx

Pierderea așteptată pe o distribuție de date este o integrală. Antrenarea minimizează o aproximare empirică a acesteia.

Divergența KL. Măsoară diferența dintre două distribuții:

KL(p || q) = integrala din p(x) * log(p(x) / q(x)) dx

Este utilizată în VAE-uri, distilarea cunoștințelor și inferența bayesiană.

Constante de normalizare. În inferența bayesiană:

p(w | data) = p(data | w) * p(w) / integrala din p(data | w) * p(w) dw

Numitorul este o integrală peste toate valorile posibile ale parametrilor. Adesea, aceasta nu poate fi calculată analitic, motiv pentru care folosim aproximări precum MCMC și inferența variațională.

Concept integral	Unde apare în ML
Aria de sub curbă	Probabilitate obținută din funcții de densitate
Speranță matematică	Funcții de pierdere, minimizarea riscului
Divergență KL	VAE-uri, optimizarea politicilor, distilare
Normalizare	Densități de probabilitate continue, distribuții posterioare bayesiene
Verosimilitate marginală	Compararea modelelor, limita inferioară a evidenței (evidence lower bound, ELBO)

Notă tehnică a traducerii: Originalul oferă numitorul softmax drept exemplu de integrală. Acesta este o sumă finită; tabelul folosește acum exemple care necesită într-adevăr integrare.

Regula lanțului pentru mai multe variabile într-un graf de calcul

Regula lanțului nu se aplică doar funcțiilor scalare dispuse în linie. Într-o rețea neuronală, variabilele se ramifică și se reunesc. Iată cum circulă derivatele printr-o propagare înainte simplă:

Propagarea înapoi calculează gradienții de la dreapta la stânga:

Pe fiecare săgeată se înmulțește cu derivata locală. Gradientul oricărui parametru este produsul tuturor derivatelor locale de-a lungul traseului de la pierdere până la parametrul respectiv. Când traseele se ramifică și se reunesc, însumați contribuțiile, conform regulii lanțului pentru mai multe variabile.

Aceasta este întreaga retropropagare: regula lanțului aplicată sistematic într-un graf de calcul, de la ieșire către intrări.

Matricea jacobiană

Când o funcție transformă un vector într-un alt vector, așa cum se întâmplă într-un strat al unei rețele neuronale, derivata sa este o matrice. Jacobiana conține fiecare derivată parțială a fiecărei ieșiri în raport cu fiecare intrare.

Pentru f: R^n -> R^m, Jacobiana J este o matrice m x n:

	x1	x2	…	xn
f1	df1/dx1	df1/dx2	…	df1/dxn
f2	df2/dx1	df2/dx2	…	df2/dxn
…	…	…	…	…
fm	dfm/dx1	dfm/dx2	…	dfm/dxn

Nu veți calcula manual Jacobiene pentru rețele neuronale. PyTorch se ocupă de acest lucru. Totuși, faptul că știți că există vă ajută să înțelegeți dimensiunile din retropropagare: dacă un strat transformă R^n în R^m, Jacobiana sa are dimensiunea m x n. Gradientul se propagă înapoi prin transpusa acestei matrice.

De ce este important pentru rețelele neuronale

Fiecare pondere dintr-o rețea neuronală primește un gradient. Acesta vă arată cum să ajustați ponderea pentru a reduce pierderea.

Actualizarea fiecărei ponderi:

• W1 = W1 - lr * dL/dW1
• W2 = W2 - lr * dL/dW2

Propagarea înainte calculează predicția și pierderea. Propagarea înapoi calculează gradientul pierderii în raport cu fiecare pondere. Apoi fiecare pondere face un pas mic în direcția descendentă. Repetați timp de milioane de pași. Aceasta este învățarea profundă.

derivative-tangent

Construirea soluției

Pasul 1: Derivata numerică de la zero

def numerical_derivative(f, x, h=1e-7):
    return (f(x + h) - f(x - h)) / (2 * h)

def f(x):
    return x ** 2

for x in [-2, -1, 0, 1, 2]:
    numerical = numerical_derivative(f, x)
    analytical = 2 * x
    print(f"x={x:2d}  f'(x) numerical={numerical:.6f}  analytical={analytical:.1f}")

Derivata numerică coincide cu cea analitică la o precizie de numeroase zecimale.

Pasul 2: Derivate parțiale și gradienți

def numerical_gradient(f, point, h=1e-7):
    gradient = []
    for i in range(len(point)):
        point_plus = list(point)
        point_minus = list(point)
        point_plus[i] += h
        point_minus[i] -= h
        partial = (f(point_plus) - f(point_minus)) / (2 * h)
        gradient.append(partial)
    return gradient

def f_multi(point):
    x, y = point
    return x**2 + 3*x*y + y**2

grad = numerical_gradient(f_multi, [1.0, 2.0])
print(f"Numerical gradient at (1,2): {[f'{g:.4f}' for g in grad]}")
print(f"Analytical gradient at (1,2): [2*1+3*2, 3*1+2*2] = [{2*1+3*2}, {3*1+2*2}]")

Pasul 3: Coborârea pe gradient pentru găsirea minimului funcției f(x) = x^2

x = 5.0
lr = 0.1
for step in range(20):
    grad = 2 * x
    x = x - lr * grad
    print(f"step {step:2d}  x={x:8.4f}  f(x)={x**2:10.6f}")

Pornind de la x=5, fiecare pas se apropie de x=0, punctul de minim.

Pasul 4: Coborârea pe gradient pentru o funcție 2D

def f_2d(point):
    x, y = point
    return x**2 + y**2

point = [4.0, 3.0]
lr = 0.1
for step in range(30):
    grad = numerical_gradient(f_2d, point)
    point = [p - lr * g for p, g in zip(point, grad)]
    loss = f_2d(point)
    if step % 5 == 0 or step == 29:
        print(f"step {step:2d}  point=({point[0]:7.4f}, {point[1]:7.4f})  f={loss:.6f}")

Pasul 5: Compararea derivatelor numerice și analitice

import math

test_functions = [
    ("x^2",      lambda x: x**2,          lambda x: 2*x),
    ("x^3",      lambda x: x**3,          lambda x: 3*x**2),
    ("sin(x)",   lambda x: math.sin(x),   lambda x: math.cos(x)),
    ("e^x",      lambda x: math.exp(x),   lambda x: math.exp(x)),
    ("1/x",      lambda x: 1/x,           lambda x: -1/x**2),
]

x = 2.0
print(f"{'Function':<12} {'Numerical':>12} {'Analytical':>12} {'Error':>12}")
print("-" * 50)
for name, f, df in test_functions:
    num = numerical_derivative(f, x)
    ana = df(x)
    err = abs(num - ana)
    print(f"{name:<12} {num:12.6f} {ana:12.6f} {err:12.2e}")

Pasul 6: Calcularea numerică a Hessienei

def hessian_2d(f, x, y, h=1e-5):
    fxx = (f(x + h, y) - 2 * f(x, y) + f(x - h, y)) / (h ** 2)
    fyy = (f(x, y + h) - 2 * f(x, y) + f(x, y - h)) / (h ** 2)
    fxy = (f(x + h, y + h) - f(x + h, y - h) - f(x - h, y + h) + f(x - h, y - h)) / (4 * h ** 2)
    return [[fxx, fxy], [fxy, fyy]]

def saddle(x, y):
    return x ** 2 - y ** 2

def bowl(x, y):
    return x ** 2 + y ** 2

H_saddle = hessian_2d(saddle, 0.0, 0.0)
H_bowl = hessian_2d(bowl, 0.0, 0.0)
print(f"Saddle Hessian: {H_saddle}")  # [[2, 0], [0, -2]] -- mixed signs
print(f"Bowl Hessian:   {H_bowl}")    # [[2, 0], [0, 2]]  -- both positive

Hessiana funcției în formă de șa are valorile proprii 2 și -2, cu semne diferite, ceea ce confirmă existența unui punct de șa. Funcția în formă de bol are valorile proprii 2 și 2, ambele pozitive, ceea ce confirmă existența unui minim.

Pasul 7: Aproximarea Taylor în practică

import math

def taylor_approx(f, f_prime, f_double_prime, x0, h, order=2):
    result = f(x0)
    if order >= 1:
        result += f_prime(x0) * h
    if order >= 2:
        result += 0.5 * f_double_prime(x0) * h ** 2
    return result

x0 = 0.0
for h in [0.1, 0.5, 1.0, 2.0]:
    true_val = math.sin(h)
    t1 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=1)
    t2 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=2)
    print(f"h={h:.1f}  sin(h)={true_val:.4f}  order1={t1:.4f}  order2={t2:.4f}")

În apropierea lui x0=0, sin(x) ~ x, conform aproximării Taylor de ordinul întâi. Aproximarea este excelentă pentru valori h mici, dar devine inexactă pentru valori h mari. Din acest motiv, coborârea pe gradient funcționează cel mai bine cu rate de învățare mici: fiecare pas presupune că aproximarea liniară este precisă.

Pasul 8: De ce este important pentru o rețea neuronală

import random

random.seed(42)

w = random.gauss(0, 1)
b = random.gauss(0, 1)
lr = 0.01

xs = [1.0, 2.0, 3.0, 4.0, 5.0]
ys = [3.0, 5.0, 7.0, 9.0, 11.0]

for epoch in range(200):
    total_loss = 0
    dw = 0
    db = 0
    for x, y in zip(xs, ys):
        pred = w * x + b
        error = pred - y
        total_loss += error ** 2
        dw += 2 * error * x
        db += 2 * error
    dw /= len(xs)
    db /= len(xs)
    total_loss /= len(xs)
    w -= lr * dw
    b -= lr * db
    if epoch % 40 == 0 or epoch == 199:
        print(f"epoch {epoch:3d}  w={w:.4f}  b={b:.4f}  loss={total_loss:.6f}")

print(f"\nLearned: y = {w:.2f}x + {b:.2f}")
print(f"Actual:  y = 2x + 1")

Fiecare buclă de antrenare bazată pe gradient urmează acest tipar: efectuați predicția, calculați pierderea, calculați gradienții și actualizați ponderile.

Utilizarea soluției

Cu NumPy, aceleași operații sunt mai rapide și mai concise:

import numpy as np

x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([3, 5, 7, 9, 11], dtype=float)

w, b = np.random.randn(), np.random.randn()
lr = 0.01

for epoch in range(200):
    pred = w * x + b
    error = pred - y
    loss = np.mean(error ** 2)
    dw = np.mean(2 * error * x)
    db = np.mean(2 * error)
    w -= lr * dw
    b -= lr * db

print(f"Learned: y = {w:.2f}x + {b:.2f}")

Tocmai ați construit coborârea pe gradient de la zero. PyTorch automatizează calcularea gradientului, dar bucla de actualizare este identică.

Exerciții

1. Implementați numerical_second_derivative(f, x) apelând de două ori numerical_derivative. Verificați dacă derivata a doua a funcției x^3 în x=2 este 12.
2. Utilizați coborârea pe gradient pentru a găsi minimul funcției f(x, y) = (x - 3)^2 + (y + 1)^2. Porniți din (0, 0). Rezultatul ar trebui să conveargă către (3, -1).
3. Adăugați moment (momentum) în bucla de coborâre pe gradient: mențineți un vector de viteză care acumulează gradienții anteriori. Comparați viteza de convergență cu și fără moment pentru f(x) = x^4 - 3x^2.

Termeni-cheie

Termen	Formulare uzuală	Ce înseamnă de fapt
Derivată	„Panta”	Rata de variație a unei funcții într-un punct. Arată cât se modifică ieșirea la o variație unitară a intrării.
Derivată parțială	„Derivata unei variabile”	Derivata în raport cu o variabilă, în timp ce toate celelalte sunt menținute constante.
Gradient	„Direcția celei mai rapide creșteri”	Un vector al tuturor derivatelor parțiale. Este orientat în direcția în care funcția crește cel mai repede.
Coborâre pe gradient	„Deplasare în jos”	Scăderea gradientului, înmulțit cu rata de învățare, din parametri pentru a reduce pierderea. Este mecanismul central al antrenării rețelelor neuronale.
Rată de învățare	„Dimensiunea pasului”	Un scalar care controlează dimensiunea fiecărui pas al coborârii pe gradient. Prea mare: divergență. Prea mică: convergență lentă.
Regula lanțului	„Înmulțirea derivatelor”	Regula derivării funcțiilor compuse: df/dx = df/dg * dg/dx. Reprezintă baza matematică a retropropagării.
Jacobiană	„Matricea derivatelor”	Când o funcție transformă vectori în vectori, Jacobiana este matricea tuturor derivatelor parțiale ale ieșirilor în raport cu intrările.
Derivată numerică	„Diferențe finite”	Aproximarea unei derivate prin evaluarea funcției în două puncte apropiate și calcularea pantei dintre ele.
Retropropagare	„Diferențiere automată în mod invers (reverse-mode autodiff)”	Calcularea gradienților strat cu strat, de la ieșire către intrare, folosind regula lanțului. Astfel învață rețelele neuronale.
Hessiană	„Matricea derivatelor de ordinul al doilea”	Matricea tuturor derivatelor parțiale de ordinul al doilea. Descrie curbura unei funcții. O Hessiană pozitiv definită într-un punct critic indică un minim local.
Serie Taylor	„Aproximare polinomială”	Aproximarea unei funcții în vecinătatea unui punct folosind derivatele sale: f(x+h) ~ f(x) + f’(x)h + (1/2)f’’(x)h^2 + … Aceasta explică de ce funcționează coborârea pe gradient și metoda lui Newton.
Integrală	„Aria de sub curbă”	Acumularea unei mărimi pe un interval. În ML, integralele definesc probabilități, speranțe matematice și divergența KL.

Lecturi suplimentare

• 3Blue1Brown: Essence of Calculus — explicații vizuale intuitive pentru derivate, integrale și regula lanțului
• Stanford CS231n: Backpropagation — modul în care gradienții se propagă prin straturile rețelelor neuronale

---

Sursă: Calculus for Machine Learning — originalul Navigare: înapoi: 01.03 — Transformări matriciale · Faza 1 — Fundamente matematice · Catalog complet · în continuare: 01.05 — Regula lanțului și diferențierea automată.