Teoria informației

Teoria informației măsoară surpriza. Funcțiile de pierdere se bazează pe ea.

Tip: Învățare Limbaj: Python Cerințe preliminare: Faza 1, lecția 06 (Probabilitate) Durată: ~60 de minute

Obiective de învățare

• Calcularea de la zero a entropiei, a entropiei încrucișate și a divergenței KL și explicarea relației dintre ele
• Deducerea motivului pentru care minimizarea pierderii prin entropie încrucișată echivalează cu maximizarea log-verosimilității
• Calcularea informației mutuale dintre caracteristici și o variabilă țintă pentru ierarhizarea importanței caracteristicilor
• Explicarea perplexității ca dimensiune efectivă a vocabularului din care alege un model lingvistic

Problema

Apelați CrossEntropyLoss() în fiecare model de clasificare pe care îl antrenați. Întâlniți „perplexitate” în orice lucrare despre modele lingvistice. Citiți despre divergența KL în VAE-uri, distilare și RLHF. Aceste concepte nu sunt disparate, ci reprezintă aceeași idee sub forme diferite.

Teoria informației vă oferă limbajul necesar pentru a raționa despre incertitudine, compresie și predicție. Claude Shannon a creat-o în 1948 pentru a rezolva probleme de comunicații. Se pare că antrenarea unei rețele neuronale este tot o problemă de comunicații: modelul încearcă să transmită eticheta corectă printr-un canal cu zgomot format din ponderile învățate.

Această lecție construiește fiecare formulă de la zero, astfel încât să înțelegeți originea și funcționarea lor.

Conceptul

Conținutul informațional (surpriza)

Când se produce un eveniment improbabil, acesta transmite mai multă informație. O monedă cade cu fața „cap”? Nu este surprinzător. Câștigați la loterie? Este foarte surprinzător.

Conținutul informațional al unui eveniment cu probabilitatea p este:

I(x) = -log(p(x))

Logaritmul în baza 2 produce biți. Logaritmul natural produce nați. Ideea este aceeași, dar unitățile diferă.

Eveniment                  Probabilitate    Surpriză (biți)
„Cap” la o monedă corectă  0.5              1.0
Obținerea unui 6           0.167            2.58
Eveniment cu șansa 1/1000  0.001            9.97
Eveniment sigur            1.0              0.0

Evenimentele sigure transmit zero informație. Știați deja că se vor produce.

Entropia (surpriza medie)

Entropia este surpriza așteptată pentru toate rezultatele posibile ale unei distribuții.

H(P) = -sum( p(x) * log(p(x)) )  pentru toate valorile x

O monedă corectă are entropia maximă pentru o variabilă binară: 1 bit. O monedă dezechilibrată, care cade în 99% dintre cazuri cu fața „cap”, are o entropie scăzută: 0,08 biți. Știți deja ce se va întâmpla, așadar fiecare aruncare vă spune foarte puțin.

Monedă corectă:       H = -(0.5 * log2(0.5) + 0.5 * log2(0.5)) = 1.0 bit
Monedă dezechilibrată: H = -(0.99 * log2(0.99) + 0.01 * log2(0.01)) = 0.08 biți

Entropia măsoară incertitudinea ireductibilă a unei distribuții. Nu puteți comprima informația sub această limită.

Entropia încrucișată (funcția de pierdere folosită zilnic)

Entropia încrucișată măsoară surpriza medie atunci când folosiți distribuția Q pentru a codifica evenimente care provin în realitate din distribuția P.

H(P, Q) = -sum( p(x) * log(q(x)) )  pentru toate valorile x

P este distribuția-țintă, reprezentată de etichete. Q este distribuția predicțiilor modelului. Dacă Q coincide perfect cu P, entropia încrucișată este egală cu entropia. Orice nepotrivire îi mărește valoarea.

În clasificare, P este un vector one-hot: clasa corectă are probabilitatea 1, iar toate celelalte au probabilitatea 0. Astfel, entropia încrucișată se simplifică la:

H(P, Q) = -log(q(clasa_corectă))

Aceasta este formula completă a pierderii prin entropie încrucișată pentru clasificare. Maximizați probabilitatea prezisă pentru clasa corectă.

Divergența KL (diferența dintre distribuții)

Divergența KL măsoară surpriza suplimentară produsă de folosirea distribuției Q în locul distribuției P.

D_KL(P || Q) = sum( p(x) * log(p(x) / q(x)) )  pentru toate valorile x
             = H(P, Q) - H(P)

Entropia încrucișată este suma dintre entropie și divergența KL. Deoarece entropia distribuției-țintă rămâne constantă în timpul antrenării, minimizarea entropiei încrucișate echivalează cu minimizarea divergenței KL. Împingeți distribuția modelului spre distribuția-țintă.

Divergența KL nu este simetrică: D_KL(P || Q) != D_KL(Q || P). Prin urmare, nu este o metrică de distanță propriu-zisă.

Informația mutuală

Informația mutuală măsoară cât de mult aflați despre o variabilă atunci când o cunoașteți pe cealaltă.

I(X; Y) = H(X) - H(X|Y)
        = H(X) + H(Y) - H(X, Y)

Dacă X și Y sunt independente, informația mutuală este zero. Cunoașterea uneia nu vă spune nimic despre cealaltă. Dacă Y este o funcție deterministă a lui X, informația mutuală este H(Y); ea este egală cu entropia ambelor variabile numai când relația este bijectivă.

În selectarea caracteristicilor, o informație mutuală ridicată între o caracteristică și variabila țintă indică utilitatea individuală a caracteristicii. O valoare univariată scăzută nu dovedește că aceasta este zgomot: caracteristica poate deveni utilă numai prin interacțiune cu altele, ca în problema XOR, iar o estimare pe un eșantion finit poate omite dependențe reale.

Notă tehnică a traducerii: Originalul echivalează orice relație deterministă cu entropia ambelor variabile și interpretează informația mutuală univariată scăzută drept zgomot. Formularea a fost corectată pentru relații nebijective, interacțiuni între caracteristici și eroarea de estimare.

Entropia condiționată

H(Y|X) măsoară câtă incertitudine despre Y rămâne după observarea lui X.

H(Y|X) = H(X,Y) - H(X)

Două cazuri extreme:

• Dacă X determină complet Y, atunci H(Y|X) = 0. Cunoașterea lui X elimină toată incertitudinea despre Y. Exemplu: X = temperatura în grade Celsius, Y = temperatura în grade Fahrenheit.
• Dacă X nu vă spune nimic despre Y, atunci H(Y|X) = H(Y). Cunoașterea lui X nu reduce deloc incertitudinea. Exemplu: X = rezultatul aruncării unei monede, Y = vremea de mâine.

Entropia condiționată este întotdeauna nenegativă și nu depășește niciodată H(Y):

0 <= H(Y|X) <= H(Y)

În învățarea automată, entropia condiționată apare în arborii de decizie. La fiecare divizare, algoritmul alege caracteristica X care minimizează H(Y|X), adică acea caracteristică ce elimină cea mai mare parte a incertitudinii despre eticheta Y.

Entropia comună

H(X,Y) este entropia distribuției comune a variabilelor X și Y.

H(X,Y) = -sum sum p(x,y) * log(p(x,y))   pentru toate valorile x, y

Proprietate esențială:

H(X,Y) <= H(X) + H(Y)

Egalitatea se verifică atunci când X și Y sunt independente. Dacă variabilele au informație comună, entropia comună este mai mică decât suma entropiilor individuale. Entropia care „lipsește” este exact informația mutuală.

Relațiile sunt:

• H(X,Y) = H(X) + H(Y|X) = H(Y) + H(X|Y)
• I(X;Y) = H(X) - H(X|Y) = H(Y) - H(Y|X)
• H(X,Y) = H(X) + H(Y) - I(X;Y)

Informația mutuală în detaliu

Informația mutuală I(X;Y) cuantifică reducerea incertitudinii despre una dintre variabile atunci când o cunoașteți pe cealaltă.

I(X;Y) = H(X) - H(X|Y)
       = H(Y) - H(Y|X)
       = H(X) + H(Y) - H(X,Y)
       = sum sum p(x,y) * log(p(x,y) / (p(x) * p(y)))

Proprietăți:

• I(X;Y) >= 0 întotdeauna. Nu pierdeți niciodată informație atunci când observați ceva.
• I(X;Y) = 0 dacă și numai dacă X și Y sunt independente.
• I(X;Y) = I(Y;X). Informația mutuală este simetrică, spre deosebire de divergența KL.
• I(X;X) = H(X). O variabilă conține întreaga informație despre sine.

Informația mutuală pentru selectarea caracteristicilor. În învățarea automată aveți nevoie de caracteristici informative pentru variabila țintă. Informația mutuală vă oferă o metodă fundamentată de ierarhizare a caracteristicilor:

1. Pentru fiecare caracteristică X_i, calculați I(X_i; Y), unde Y este variabila țintă.
2. Ierarhizați caracteristicile după scorul MI.
3. Păstrați primele k caracteristici.

Metoda funcționează pentru orice relație dintre caracteristică și variabila țintă: liniară, neliniară, monotonă sau nemonotonă. Corelația detectează doar relațiile liniare. Informația mutuală le detectează pe toate.

Metodă	Detectează	Cost de calcul	Acceptă date categoriale?
Corelația Pearson	Relații liniare	O(n)	Nu
Corelația Spearman	Relații monotone	O(n log n)	Nu
Informația mutuală	Orice dependență statistică	Depinde de estimator și de discretizare	Da

Netezirea etichetelor și entropia încrucișată

Clasificarea standard folosește ținte ferme (hard targets): [0, 0, 1, 0]. Clasa corectă primește probabilitatea 1, iar toate celelalte primesc 0. Netezirea etichetelor le înlocuiește cu ținte netezite (soft targets):

țintă_netezită = (1 - epsilon) * țintă_fermă + epsilon / număr_clase

Pentru epsilon = 0.1 și 4 clase:

• Țintă fermă: [0, 0, 1, 0]
• Țintă netezită: [0.025, 0.025, 0.925, 0.025]

Din perspectiva teoriei informației, netezirea etichetelor crește entropia distribuției țintă. Țintele one-hot ferme au entropia 0, deoarece nu există incertitudine. Țintele netezite au entropie pozitivă.

De ce ajută acest lucru:

• Împiedică modelul să deplaseze logiturile spre valori extreme; potrivirea perfectă a unei ținte one-hot prin entropie încrucișată ar necesita logituri infinite
• Are rol de regularizare: modelul nu poate avea un grad de încredere de 100%
• Îmbunătățește calibrarea: probabilitățile prezise reflectă mai bine incertitudinea reală
• Reduce diferența dintre comportamentul din timpul antrenării și cel din timpul inferenței

Pierderea prin entropie încrucișată cu netezirea etichetelor devine:

L = (1 - epsilon) * CE(țintă_fermă, predicție) + epsilon * CE(U, predicție), unde U este distribuția-țintă uniformă

Al doilea termen penalizează predicțiile îndepărtate de distribuția uniformă, reprezentând o regularizare directă a gradului de încredere.

De ce entropia încrucișată este funcția de pierdere pentru clasificare

Trei perspective conduc la aceeași concluzie.

Perspectiva teoriei informației. Entropia încrucișată H(P, Q) măsoară lungimea medie totală a codificării evenimentelor din distribuția-țintă P folosind distribuția modelului Q. Numărul mediu de biți suplimentari față de codificarea optimă este divergența KL: H(P, Q) - H(P).

Perspectiva verosimilității maxime. Pentru N exemple de antrenare cu clasele corecte y_i:

Verosimilitate              = product( q(y_i) )
Log-verosimilitate          = sum( log(q(y_i)) )
Log-verosimilitate negativă = -sum( log(q(y_i)) )

Ultima linie reprezintă pierderea prin entropie încrucișată. Minimizarea entropiei încrucișate echivalează cu maximizarea verosimilității datelor de antrenare în raport cu modelul.

Perspectiva gradientului. Gradientul entropiei încrucișate în raport cu logiturile este pur și simplu (predicție - țintă). Este simplu, stabil și rapid de calculat. Din acest motiv, entropia încrucișată se combină perfect cu softmax.

Biți și nați

Singura diferență este baza logaritmului.

logaritm în baza 2  -> biți     (tradiția teoriei informației)
logaritm în baza e  -> nați     (convenția din învățarea automată)
logaritm în baza 10 -> hartley  (folosit rar)

1 nat = 1/ln(2) biți = 1,4427 biți. PyTorch și TensorFlow folosesc implicit logaritmul natural, deci nați.

Perplexitatea

Perplexitatea este exponențiala entropiei încrucișate. Ea indică numărul efectiv de opțiuni echiprobabile între care modelul este nesigur.

Perplexitate = 2^H(P,Q)   (dacă folosiți biți)
Perplexitate = e^H(P,Q)   (dacă folosiți nați)

Un model lingvistic cu perplexitatea 50 este, în medie, la fel de nesigur ca și cum ar trebui să aleagă uniform dintre 50 de tokeni următori posibili. O valoare mai mică este mai bună.

Perplexitatea poate fi comparată direct numai când modelele folosesc aceeași tokenizare, același vocabular și același set de evaluare. O valoare raportată fără aceste condiții nu permite o comparație informativă între modele.

Notă tehnică a traducerii: Originalul compară valori de perplexitate fără să fixeze tokenizatorul, vocabularul și setul de date. Acești factori schimbă unitatea efectivă de predicție și fac valorile incompatibile.

entropy-kl

Construirea implementării

Pasul 1: conținutul informațional și entropia

import math

def information_content(p, base=2):
    if p <= 0 or p > 1:
        return float('inf') if p <= 0 else 0.0
    return -math.log(p) / math.log(base)

def entropy(probs, base=2):
    return sum(
        p * information_content(p, base)
        for p in probs if p > 0
    )

fair_coin = [0.5, 0.5]
biased_coin = [0.99, 0.01]
fair_die = [1/6] * 6

print(f"Fair coin entropy:   {entropy(fair_coin):.4f} bits")
print(f"Biased coin entropy: {entropy(biased_coin):.4f} bits")
print(f"Fair die entropy:    {entropy(fair_die):.4f} bits")

Notă tehnică a traducerii: information_content din original întoarce 0.0 pentru p > 1, deși aceasta este o probabilitate invalidă, și nu validează baza logaritmului. O implementare robustă trebuie să impună 0 < p <= 1, base > 0 și base != 1, semnalând o eroare pentru intrări invalide.

Pasul 2: entropia încrucișată și divergența KL

def cross_entropy(p, q, base=2):
    total = 0.0
    for pi, qi in zip(p, q):
        if pi > 0:
            if qi <= 0:
                return float('inf')
            total += pi * (-math.log(qi) / math.log(base))
    return total

def kl_divergence(p, q, base=2):
    return cross_entropy(p, q, base) - entropy(p, base)

true_dist = [0.7, 0.2, 0.1]
good_model = [0.6, 0.25, 0.15]
bad_model = [0.1, 0.1, 0.8]

print(f"Entropy of true dist:     {entropy(true_dist):.4f} bits")
print(f"CE (good model):          {cross_entropy(true_dist, good_model):.4f} bits")
print(f"CE (bad model):           {cross_entropy(true_dist, bad_model):.4f} bits")
print(f"KL divergence (good):     {kl_divergence(true_dist, good_model):.4f} bits")
print(f"KL divergence (bad):      {kl_divergence(true_dist, bad_model):.4f} bits")

Pasul 3: entropia încrucișată ca pierdere pentru clasificare

def softmax(logits):
    max_logit = max(logits)
    exps = [math.exp(z - max_logit) for z in logits]
    total = sum(exps)
    return [e / total for e in exps]

def cross_entropy_loss(true_class, logits):
    probs = softmax(logits)
    return -math.log(probs[true_class])

logits = [2.0, 1.0, 0.1]
true_class = 0

probs = softmax(logits)
loss = cross_entropy_loss(true_class, logits)

print(f"Logits:      {logits}")
print(f"Softmax:     {[f'{p:.4f}' for p in probs]}")
print(f"True class:  {true_class}")
print(f"Loss:        {loss:.4f} nats")
print(f"Perplexity:  {math.exp(loss):.2f}")

Notă tehnică a traducerii: Calcularea mai întâi a softmax și apoi a log(probabilitate) nu este la fel de stabilă ca implementarea PyTorch. Pentru un logit adevărat foarte negativ, probabilitatea se poate rotunji la zero; forma robustă folosește direct log_softmax sau logsumexp.

Pasul 4: entropia încrucișată este egală cu log-verosimilitatea negativă

import random

random.seed(42)

n_samples = 1000
n_classes = 3
true_labels = [random.randint(0, n_classes - 1) for _ in range(n_samples)]
model_logits = [[random.gauss(0, 1) for _ in range(n_classes)] for _ in range(n_samples)]

ce_loss = sum(
    cross_entropy_loss(label, logits)
    for label, logits in zip(true_labels, model_logits)
) / n_samples

nll = -sum(
    math.log(softmax(logits)[label])
    for label, logits in zip(true_labels, model_logits)
) / n_samples

print(f"Cross-entropy loss:      {ce_loss:.6f}")
print(f"Negative log-likelihood: {nll:.6f}")
print(f"Difference:              {abs(ce_loss - nll):.2e}")

Pasul 5: informația mutuală

def mutual_information(joint_probs, base=2):
    rows = len(joint_probs)
    cols = len(joint_probs[0])

    margin_x = [sum(joint_probs[i][j] for j in range(cols)) for i in range(rows)]
    margin_y = [sum(joint_probs[i][j] for i in range(rows)) for j in range(cols)]

    mi = 0.0
    for i in range(rows):
        for j in range(cols):
            pxy = joint_probs[i][j]
            if pxy > 0:
                mi += pxy * math.log(pxy / (margin_x[i] * margin_y[j])) / math.log(base)
    return mi

independent = [[0.25, 0.25], [0.25, 0.25]]
dependent = [[0.45, 0.05], [0.05, 0.45]]

print(f"MI (independent): {mutual_information(independent):.4f} bits")
print(f"MI (dependent):   {mutual_information(dependent):.4f} bits")

Utilizarea implementării

Aceleași concepte implementate cu NumPy, așa cum le veți folosi în practică:

import numpy as np

def np_entropy(p):
    p = np.asarray(p, dtype=float)
    mask = p > 0
    result = np.zeros_like(p)
    result[mask] = p[mask] * np.log(p[mask])
    return -result.sum()

def np_cross_entropy(p, q):
    p, q = np.asarray(p, dtype=float), np.asarray(q, dtype=float)
    mask = p > 0
    return -(p[mask] * np.log(q[mask])).sum()

def np_kl_divergence(p, q):
    return np_cross_entropy(p, q) - np_entropy(p)

true = np.array([0.7, 0.2, 0.1])
pred = np.array([0.6, 0.25, 0.15])
print(f"Entropy:    {np_entropy(true):.4f} nats")
print(f"Cross-ent:  {np_cross_entropy(true, pred):.4f} nats")
print(f"KL div:     {np_kl_divergence(true, pred):.4f} nats")

Ați construit de la zero forma matematică a pierderii executate de torch.nn.CrossEntropyLoss(), cu precizarea de stabilitate numerică de mai sus. Pe măsură ce distribuția prezisă se apropie de distribuția-țintă, entropia încrucișată scade; excesul față de entropia ireductibilă H(P) este divergența KL, măsurată în nați.

Exerciții

1. Calculați entropia alfabetului englez presupunând o distribuție uniformă a celor 26 de litere. Apoi estimați-o folosind frecvențele reale ale literelor. Care valoare este mai mare și de ce?

2. Un model produce logiturile [5.0, 2.0, 0.5] pentru un exemplu a cărui clasă corectă este 1. Calculați manual pierderea prin entropie încrucișată, apoi verificați-o cu funcția cross_entropy_loss. Ce logituri ar produce pierderea zero?

3. Demonstrați că divergența KL nu este simetrică. Alegeți două distribuții P și Q, apoi calculați D_KL(P || Q) și D_KL(Q || P). Explicați de ce diferă.

4. Construiți o funcție care calculează perplexitatea pentru o secvență de predicții de tokeni. Pentru o listă de perechi (true_token_index, predicted_logits), returnați perplexitatea secvenței.

Termeni-cheie

Termen	Cum îi spune lumea	Ce înseamnă de fapt
Conținut informațional	„Surpriză”	Numărul de biți sau nați necesari pentru codificarea unui eveniment: -log(p).
Entropie	„Aleatorietate”	Surpriza medie pentru toate rezultatele unei distribuții. Măsoară incertitudinea ireductibilă.
Entropie încrucișată	„Funcția de pierdere”	Surpriza medie atunci când distribuția Q a modelului este folosită pentru a codifica evenimente din distribuția-țintă P.
Divergență KL	„Distanța dintre distribuții”	Biții suplimentari irosiți prin folosirea distribuției Q în locul distribuției P. Este egală cu entropia încrucișată minus entropia și nu este simetrică.
Informație mutuală	„Cât de legate sunt X și Y”	Reducerea incertitudinii despre X prin cunoașterea lui Y. Valoarea zero indică independența.
Softmax	„Transformă logiturile în probabilități”	Exponențiază și normalizează. Transformă orice vector de valori reale într-o distribuție de probabilitate validă.
Perplexitate	„Cât de nesigur este modelul”	Exponențiala entropiei încrucișate. Dimensiunea efectivă a vocabularului din care alege modelul la fiecare pas.
Biți	„Unitatea lui Shannon”	Informație măsurată cu logaritmul în baza 2. Un bit elimină incertitudinea asociată unei aruncări de monedă corectă.
Nați	„Unitatea din învățarea automată”	Informație măsurată cu logaritmul natural. Este folosită implicit de PyTorch și TensorFlow.
Log-verosimilitate negativă	„Pierderea NLL”	Este identică cu pierderea prin entropie încrucișată pentru etichetele one-hot. Minimizarea ei maximizează probabilitatea predicțiilor corecte.

Lecturi suplimentare

• Shannon 1948: A Mathematical Theory of Communication - lucrarea originală, încă accesibilă
• Visual Information Theory (Chris Olah) - cea mai bună explicație vizuală a entropiei și divergenței KL
• Documentația PyTorch pentru CrossEntropyLoss - modul în care cadrul software implementează mecanismul construit în această lecție

---

Sursă: Information Theory — original

Navigare: înapoi: 01.08 — Optimizare · Faza 1 — Fundamente matematice · Catalog complet · în continuare: 01.10 — Reducerea dimensionalității.