Guia d’aplicació i diagnòstic

Què podem fer
Avaluació d’un model
Selecció de model
- K-Fold Cross-Validation
Biaix i variància
Regularització
- Regularització en xarxes neuronals
Rendiment de referència
Curves d’aprenentatge
Què podem fer (revisat)
Biaix i variància en xarxes neuronals
Altres tècniques

Aquest document se centra en tècniques de diagnòstic i anàlisi matemàtica per entendre i millorar models de Machine Learning. Proporciona:

Formules matemàtiques per calcular errors i mètriques
Visualitzacions interactives per comprendre conceptes clau
Procediments detallats amb exemples de codi
Eines de diagnòstic basades en anàlisi quantitativa

Complement: Per una guia pràctica sobre quin algoritme triar i com estructurar projectes de ML, consulta la Metodologia Pràctica.

Aquest document presenta un marc sistemàtic de diagnòstic amb bases matemàtiques per identificar i resoldre problemes en models de Machine Learning.

Què podem fer

Què fer si d’una regressió lineal regularitzada dona errors massa grans en les prediccions?

Si el cost o error de la funció de pèrdua és massa alt, pots provar les següents opcions:

Obtenir més exemples d’entrenament.
Reduir el conjunt de característiques (features).
Afegir noves característiques.
Afegir característiques polinòmiques (per exemple, ).
Disminuir el paràmetre de regularització .
Incrementar el paràmetre de regularització .

La necessitat de diagnòstics: cal fer proves i anàlisis que ens ajudin a entendre què està funcionant i què no en un algorisme d’aprenentatge, per així guiar les millores en el seu rendiment.

Avaluació d’un model

Suposem que tenim un model amb quatre característiques i polinòmiques, i que la seva corba d’ajust és molt irregular (“wiggly”). Probablement és un mal model que no predirà bé.

Preguntes:

Com podem visualitzar un model amb quatre dimensions? És difícil de representar.

Una pràctica habitual és dividir el conjunt de dades en:

Conjunt d’entrenament (train): 70% de les dades.
Conjunt de prova (test): 30% de les dades.

Primer entrenem el model amb el conjunt d’entrenament, i després avaluem el seu rendiment al conjunt de prova.

: nombre d’exemples d’entrenament
: nombre d’exemples de prova

A continuació es mostra el procediment d’entrenament i test per a una regressió lineal amb funció de cost de mínims quadrats.

Ajustament dels paràmetres (inclou regularització):
Càlcul de l’error al conjunt de prova:
Càlcul de l’error al conjunt d’entrenament:

Què veurem a les funcions de cost si tenim overfitting (sobreajustament)?

és baix (el model s’ajusta molt bé a l’entrenament).
és alt (el model no generalitza bé a noves dades).

En problemes de classificació, els valors i es refereixen a la fracció d’exemples mal classificats al conjunt d’entrenament i al conjunt de prova, respectivament.

Selecció de model

Podem ajustar models amb funcions de diferents graus ( ), per exemple polinomis:

Una manera intuïtiva és provar quin grau ens dóna el valor més baix de la funció de pèrdua sobre el conjunt de test, . Per exemple, podríem trobar que sembla el millor.

Problema d’usar el conjunt de test per a seleccionar el model: el valor pot ser una estimació massa optimista de l’error real de generalització. Això passa perquè estem triant el grau del polinomi basant-nos en el mateix conjunt de test. En altres paraules:

Els paràmetres estan ajustats al conjunt d’entrenament.
El grau es tria mirant el conjunt de test.

Aquesta pràctica no és correcta, perquè estem utilitzant informació del test per prendre decisions de model, el que fa que la estimació final del error sigui massa optimista i poc fiable.

Solució: dividir les dades en tres conjunts

La manera correcta és dividir les dades en tres parts:

Conjunt d’entrenament (train): 60% de les dades.
Conjunt de validació (cross-validation):: 20% de les dades.
Conjunt de prova (test): 20% de les dades.

El conjunt de validació (també anomenat validation set o dev set) s’utilitza per seleccionar l’hiperparàmetre, en aquest cas, el grau del polinomi .

Procediment amb els tres conjunts:

Per cada grau , entrenem el model amb el conjunt d’entrenament.
Calculem l’error de validació en el conjunt de validació.
Triem el grau que dóna el menor error . Per exemple, .
Finalment, utilitzem el conjunt de test per estimar de manera justa l’error de generalització del model final (amb ).

Aquest procediment no només s’aplica a la selecció del grau del polinomi, sinó també a qualsevol decisió sobre l’arquitectura o paràmetres d’un model, com per exemple el nombre de capes o neurones d’una xarxa neuronal.

Regla d’or: No utilitzar mai el conjunt de test per prendre decisions sobre el model. Només quan ja es tingui el model final, es pot avaluar amb el test per obtenir una estimació realista de la seva qualitat.

K-Fold Cross-Validation

El mètode descrit anteriorment utilitza una única divisió de les dades en train/validació/test. Però, què passa si la divisió és poc afortunada? Per exemple, si per casualitat el conjunt de validació conté exemples més fàcils o més difícils que la mitjana, l’estimació de ( J_{\text{cv}} ) pot ser enganyosa.

La validació creuada de K folds (K-Fold Cross-Validation) és una tècnica més robusta que soluciona aquest problema fent múltiples divisions i calculant la mitjana dels resultats.

Com funciona K-Fold Cross-Validation:

Dividim les dades en K parts iguals (folds). Per exemple, si ( K = 5 ), dividim les dades en 5 grups.
Entrenem K vegades, cada vegada utilitzant un fold diferent com a validació i els altres ( K-1 ) folds com a entrenament.
Calculem la mitjana de l’error de validació obtingut en cada iteració.

Exemple pràctic amb K=5:

Fold 1: Entrenem amb folds 2-3-4-5, validem amb fold 1 →
Fold 2: Entrenem amb folds 1-3-4-5, validem amb fold 2 →
Fold 3: Entrenem amb folds 1-2-4-5, validem amb fold 3 →
Fold 4: Entrenem amb folds 1-2-3-5, validem amb fold 4 →
Fold 5: Entrenem amb folds 1-2-3-4, validem amb fold 5 →

Error final de validació:

Avantatges de K-Fold Cross-Validation:

Més robust: Redueix la variància de l’estimació de l’error perquè no depèn d’una sola divisió.
Millor aprofitament de les dades: Cada exemple s’utilitza tant per entrenar com per validar.
Estimació més fiable: Especialment important amb datasets petits.

Inconvenients:

Cost computacional: Cal entrenar el model K vegades (en lloc d’una sola vegada).
Més lent: Pot ser prohibitiu amb models grans o datasets enormes.

Quan usar K-Fold Cross-Validation:

Datasets petits o mitjans (menys de 100k exemples aproximadament).
Quan vols una estimació fiable de l’error de generalització.
Per ajustar hiperparàmetres (per exemple, triar ( \lambda ), el grau del polinomi, etc.).
Quan el temps d’entrenament no és un problema crític.

Quan NO usar-lo:

Datasets molt grans (milions d’exemples): massa costós computacionalment.
Models molt lents d’entrenar (xarxes neuronals profundes): millor usar una única divisió train/val/test.

Variants comunes:

K=5 o K=10: Valors típics que equilibren cost computacional i robustesa.
Leave-One-Out (LOO): Cas extrem on ( K = m ) (nombre total de mostres). Cada exemple és un fold. Molt costós però màxima robustesa.
Stratified K-Fold: En problemes de classificació amb classes desbalancejades, garanteix que cada fold mantingui la mateixa proporció de classes que el dataset original.

Exemple amb Linear Regression:


import numpy as np
from sklearn.model_selection import cross_val_score, KFold
from sklearn.linear_model import LinearRegression

# Generar dades sintètiques per a regressió
rng = np.random.RandomState(42)
X_train = rng.randn(100, 5)
y_train = rng.randn(100)

# Crear el model
model = LinearRegression()

# Configurar K-Fold amb K=5
cv = KFold(n_splits=5, shuffle=True, random_state=42)

# Avaluar el model amb cross-validation
cv_scores = cross_val_score(
    estimator=model,
    X=X_train,
    y=y_train,
    cv=cv,
    scoring='neg_mean_squared_error',
    n_jobs=-1  # Usar tots els cores disponibles
)

# Convertir a MSE positiu
mse_scores = -cv_scores

print(f"MSE per cada fold: {mse_scores}")
print(f"MSE mitjà: {mse_scores.mean():.4f} ± {mse_scores.std():.4f}")

Alternativament, pots utilitzar Stratified K-Fold per a classificació:


cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

Exemple amb xarxes neuronals:


import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Subset
from sklearn.model_selection import KFold
import numpy as np

# Configuració
k = 5  # Nombre de folds
seed = 42

kf = KFold(n_splits=k, shuffle=True, random_state=seed)
fold_accs = []

for fold, (train_idx, val_idx) in enumerate(kf.split(X), 1):
    # Seed diferent per cada fold per evitar inicialitzacions idèntiques
    torch.manual_seed(seed + fold)

    # DataLoaders: batch més gran per validació (no cal backprop)
    train_loader = DataLoader(Subset(dataset, train_idx), batch_size=batch_size, shuffle=True)
    val_loader   = DataLoader(Subset(dataset, val_idx),   batch_size=batch_size*2, shuffle=False)

    # Model, optimitzador i loss
    model = MLP(in_features, num_classes=num_classes)
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    criterion = nn.CrossEntropyLoss()

    # Entrenament
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_loader:
            optimizer.zero_grad()
            loss = criterion(model(xb), yb)
            loss.backward()
            optimizer.step()

    # Avaluació
    model.eval()
    correct = total = 0
    with torch.no_grad():
        for xb, yb in val_loader:
            preds = model(xb).argmax(dim=1)
            correct += (preds == yb).sum().item()
            total += yb.size(0)

    acc = correct / total
    fold_accs.append(acc)
    print(f"Fold {fold}/{k}: val_acc={acc:.4f}")

print(f"\nMean acc: {np.mean(fold_accs):.4f} ± {np.std(fold_accs):.4f}")

Resum del workflow recomanat:

Dividir les dades inicialment en train+val (80%) i test (20%).
Aplicar K-Fold Cross-Validation sobre train+val per:
- Seleccionar hiperparàmetres
- Comparar models
- Obtenir una estimació robusta de l’error
Entrenar el model final amb tot el conjunt train+val utilitzant els millors hiperparàmetres trobats.
Avaluar només una vegada sobre el test set per obtenir l’estimació final i honesta de l’error de generalització.

Aquest enfocament combina el millor dels dos mons: la robustesa de K-Fold per a la selecció de model, i la regla d’or de mantenir el test set intacte fins al final.

Biaix i variància

Analitzar el biaix i la variància d’un model ens dóna una bona idea de què provar quan el model no funciona bé.

Per exemple, considerem un model polinòmic per ajustar un conjunt de dades:

Alt biaix: el model no s’ajusta bé al conjunt de dades (underfitting).
Alta variància: el model s’ajusta massa al conjunt de dades i no generalitza bé (overfitting).
Model correcte: trobem un punt intermedi amb biaix i variància equilibrats.

Si només tenim una característica (feature), es pot visualitzar directament com el model s’ajusta al conjunt de dades.
Amb més característiques, hem d’analitzar el rendiment del model sobre:

Training set ()

Cross-validation set ()

Comportament segons l’ajustament del model:

Tipus de model
Subajustament (alt biaix)	Alt	Alt
Sobreajustament (alta variància)	Baix	Alt
Correcte	Baix	Baix

Imaginem que tenim un dataset que modelem com un polinomi, i volem representar gràficament l’error d’entrenament i verificació en funció de :

Observacions:

sempre disminueix quan augmenta .
té forma aproximadament quadràtica, amb un mínim en el model “correcte” ().

És un cas menys freqüent, però per a models molt complexos (per exemple, xarxes neuronals), és possible trobar simultàniament Alt biaix i alta variància. Això passa perquè el model s’ajusta massa per a algunes regions de les dades (overfitting) i massa poc per a altres (underfitting).

Resumint, l’objectiu és trobar un equilibri que minimitzi ambdós errors.

Regularització

Partim d’un model de regressió polinòmica:

Amb la funció de cost:

Si fem que sigui molt gran, l’entrenament farà que els pesos siguin propers a zero, i per tant: , que és un model amb alt biaix (subajustament) on és gran.
Si fem que sigui molt petit llavors no hi ha regularització i el model té alta variància (sobreajustament) on és petit i és gran.
L’objectiu és tenir un valor intermedi de que faci i petits.

El procediment per calcular el millor valor de serà trobar l’error de validació més petit per a . En el nostre cas, farem .

Observacions:

sempre augmenta quan augmenta .
té forma aproximadament quadràtica, amb un mínim en el model “correcte” ().

Regularització en xarxes neuronals

En xarxes neuronals, la regularització L2 s’implementa mitjançant el paràmetre weight_decay de l’optimitzador. Aquest paràmetre és equivalent al paràmetre de regularització que hem vist abans.

En PyTorch, aquest terme es gestiona automàticament amb weight_decay:


import torch.optim as optim

# weight_decay és equivalent a λ
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01)

Valors típics de weight_decay:

weight_decay=0: Sense regularització (pot causar overfitting)
weight_decay=0.01: Regularització moderada (valor comú)
weight_decay=0.1: Regularització forta (per models molt complexos)

Notes:

Usa Adam per a la majoria de casos
AdamW és una variant que implementa weight decay de forma més correcta (recomanat quan uses regularització L2)
weight_decay aplica la penalització a tots els paràmetres del model
Com amb , cal ajustar weight_decay amb validació creuada

Rendiment de referència

Quan dissenyem un model, és important preguntar-nos: quin nivell d’error podem esperar assolir raonablement? Per establir una baseline (referència inicial) es poden tenir en compte diversos factors:

Rendiment humà: especialment en dades no estructurades (per exemple, imatges o veu).
Rendiment d’algoritmes competidors: comparar amb models existents similars.
Estimació basada en experiència: quan no hi ha comparatives directes, utilitzar coneixement previ.

Nota: la baseline podria ser 0% d’error, però en aplicacions sorolloses com el reconeixement de veu, el valor de referència pot ser més alt.

Què cal comprovar? Abans de fer ajustos complexos, hem de mesurar:

Baseline performance: el punt de referència inicial.
Training error: l’error sobre les dades d’entrenament.
Cross-validation error: l’error sobre dades de validació (dades no vistes durant l’entrenament).

Un cop mesurades aquestes mètriques, podem analitzar possibles problemes:

Alt biaix:
- Diferència gran entre baseline i training error → el model no aprèn bé ni sobre l’entrenament.
Alta variància:
- Diferència gran entre training error i cross-validation error → el model s’ajusta massa al conjunt d’entrenament i no generalitza bé.

Aquest enfocament ajuda a identificar on cal actuar per millorar el model: si reduir la complexitat, afegir més dades, o regularitzar.

Curves d’aprenentatge

Considerem un model de regressió polinòmic de segon grau:

Si representem la mida del conjunt d’entrenament a l’eix horitzontal i l’error a l’eix vertical, obtenim les següents corbes:

comença baixa i augmenta a mesura que incrementem la mida del conjunt, ja que els polinomis poden ajustar-se bé amb pocs exemples.
comença alta i disminueix a mesura que el model generalitza millor amb més dades d’entrenament.

Aquestes corbes mostren la intuïció clàssica de les curves d’aprenentatge, on el model tendeix a sobreajustar amb poques dades i millora la seva capacitat de generalització a mesura que la mida del conjunt creix.

Què passa en situacions d’alt biaix i alta variància?

Alt biaix:
- El model és massa simple per capturar la complexitat de les dades.
- serà alt i també serà alt, amb poc espai entre elles i per sobre del rendiment de referència.
- Les corbes no baixen gaire amb més dades, fins i tot queden planes. Cal considerar canviar altres coses.
Alta variància:
- El model és molt complex respecte a la quantitat de dades.
- serà molt baix, mentre que serà molt més alt, creant una gran separació entre les corbes. El rendiment de referència pot quedar al mig.
- A mesura que afegim més dades d’entrenament, disminuirà gradualment, i per tant és una forma de resoldre aquest problema.

Què podem fer (revisat)

Revisem els sis remeis que vam veure, i indicarem quin problema adrecen:

Obtenir més exemples d’entrenament: alta variància.
Reduir el conjunt de característiques (features): alta variància.
Afegir noves característiques: alt biaix.
Afegir característiques polinòmiques (per exemple, ): alt biaix.
Disminuir el paràmetre de regularització : alt biaix.
Incrementar el paràmetre de regularització : alta variància.

Com es pot veure, reduir els exemples d’entrenament no s’inclou a la llista de remeis. No resol cap dels dos problemes.

Biaix i variància en xarxes neuronals

El tradeoff de biaix i variància és el concepte que, triant adequadament l’ordre del polinomi o el millor paràmetre de regularització, podem aconseguir que el model sigui tan precís com sigui possible sense sobreajustar-se.

En el cas de les xarxes neuronals, aquest tradeoff funciona de manera diferent. Les xarxes grans entrenades amb datasets relativament petits solen ser màquines de baix biaix. Això dóna lloc a una recepta pràctica que, tot i no funcionar sempre, pot ajudar a trobar un model precís:

Entrena l’algorisme amb el teu conjunt d’entrenament.
Mesura i comprova si és alt respecte al nivell de referència (indicant alt biaix).
Si hi ha alt biaix, utilitza una xarxa neuronal més gran (més capes ocultes o més unitats per capa) i torna al pas 1.
Si no, mesura i comprova si és alt (indicant alta variància).
Si hi ha alta variància, obté més dades i torna al pas 1.
Si no, el model és satisfactori i has acabat.

Limitacions d’aquesta recepta:

Augmentar la mida de la xarxa neuronal: Tot i l’existència de GPUs, arriba un punt en què ja no és possible engrandir la xarxa. Tot i que això podria incrementar la variància, amb una bona regularització una xarxa més gran serà almenys tan bona com una més petita.
Obtenir més dades: No sempre és possible aconseguir-les.

Altres tècniques

A més de la regularització L2 (paràmetre ) que hem vist anteriorment, existeixen altres tècniques efectives per combatre l’alta variància (overfitting):

Dropout

Dropout és una tècnica de regularització específica per a xarxes neuronals que ajuda a prevenir el sobreajustament.

Com funciona:

Durant l’entrenament, dropout “apaga” aleatòriament un percentatge de neurones a cada iteració. Per exemple, amb un dropout rate de 0.5, cada neurona té un 50% de probabilitat de ser temporalment desactivada.

Durant l’entrenament: A cada forward pass, es desactiven aleatòriament neurones segons el dropout rate.
Durant la inferència: Totes les neurones estan actives, però els seus pesos s’escalen pel dropout rate per compensar.

Per què funciona:

Evita que les neurones es “co-adaptin” massa (és a dir, que depenguin massa les unes de les altres).
Força la xarxa a aprendre representacions més robustes i redundants.
Equivalent a entrenar un ensemble de moltes xarxes diferents i fer-ne la mitjana.

Quan usar-lo:

Quan tens alta variància: baix però alt.
En xarxes neuronals grans amb molts paràmetres.
Especialment efectiu en capes totalment connectades (fully connected).

Valors típics:

Dropout rate de 0.2-0.5 per a capes ocultes.
Dropout rate de 0.5 és un valor estàndard i comú.
Per a capes convolucionals, valors més baixos (0.1-0.3) solen funcionar millor.

Exemple amb PyTorch:


import torch
import torch.nn as nn
import torch.nn.functional as F

class MyNetwork(nn.Module):
    def __init__(self, input_size=784, hidden1=128, hidden2=64, num_classes=10, dropout_rate=0.5):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden1)
        self.dropout1 = nn.Dropout(p=dropout_rate)
        self.fc2 = nn.Linear(hidden1, hidden2)
        self.dropout2 = nn.Dropout(p=0.3)
        self.fc3 = nn.Linear(hidden2, num_classes)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.dropout1(x)
        x = F.relu(self.fc2(x))
        x = self.dropout2(x)
        x = self.fc3(x)
        return x

# Ús del model
model = MyNetwork(dropout_rate=0.5)
model.train()  # Activa dropout durant entrenament
# ... entrenament ...
model.eval()   # Desactiva dropout durant inferència

Early Stopping

Early stopping és una tècnica simple però efectiva per prevenir el sobreajustament que funciona amb qualsevol tipus de model entrenat de forma iterativa (xarxes neuronals, gradient boosting, etc.).

Com funciona:

Durant l’entrenament, monitoritzes l’error de validació . Quan aquest error deixa d’millorar (o comença a augmentar), atures l’entrenament i recuperes els pesos del model que tenien el millor rendiment de validació.

Procediment:

Divideix les dades en train, validation i test.
Entrena el model i, després de cada època, calcula .
Guarda els pesos del model quan és el més baix.
Si no millora durant N èpoques consecutives (patience), atura l’entrenament.
Restaura els pesos guardats del millor model.

Per què funciona:

Evita que el model continuï entrenant fins al punt de memoritzar les dades d’entrenament.
Troba automàticament el punt òptim entre underfitting i overfitting.
És una forma de regularització “gratuïta” que no afegeix hiperparàmetres complexos.

Quan usar-lo:

Quan tens alta variància: disminueix però comença a augmentar.
Com a complement o alternativa a altres tècniques de regularització.
Quan vols estalviar temps de computació (atura abans que l’entrenament complet).

Paràmetre clau:

Patience: Nombre d’èpoques a esperar sense millora abans d’aturar. Valors típics: 5-20 èpoques.

Exemple amb PyTorch:


import torch
import copy

def train_with_early_stopping(model, train_loader, val_loader,
                              optimizer, criterion, patience=10, max_epochs=100):
    best_val_loss = float('inf')
    patience_counter = 0

    for epoch in range(max_epochs):
        # Entrenament
        model.train()
        for X_batch, y_batch in train_loader:
            optimizer.zero_grad()
            loss = criterion(model(X_batch), y_batch)
            loss.backward()
            optimizer.step()

        # Validació
        model.eval()
        val_loss = 0.0
        with torch.no_grad():
            for X_val, y_val in val_loader:
                val_loss += criterion(model(X_val), y_val).item()
        val_loss /= len(val_loader)

        # Early stopping
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            best_model_state = copy.deepcopy(model.state_dict())
            patience_counter = 0
        else:
            patience_counter += 1

        if patience_counter >= patience:
            print(f'Early stopping a època {epoch+1}')
            model.load_state_dict(best_model_state)
            break

    return model

Comparació amb regularització L2:

Early stopping: Controla quan aturar l’entrenament.
Regularització L2 (): Controla la magnitud dels pesos durant tot l’entrenament.
Es poden combinar ambdues tècniques per millors resultats.

Avantatges d’early stopping:

No requereix ajustar hiperparàmetres complexos (només patience).
Estalvia temps de computació.
Funciona amb qualsevol algoritme iteratiu.

Inconvenients:

Requereix un conjunt de validació separat.
Pot aturar massa aviat si el patience és massa baix.

Resum

Ambdues tècniques adrecen el problema d’alta variància:

Tècnica	Aplicable a	Paràmetre clau	Quan usar-la
Dropout	Només xarxes neuronals	Dropout rate (0.2-0.5)	baix, alt
Early stopping	Qualsevol model iteratiu	Patience (5-20 èpoques)	disminueix, augmenta

Aquestes tècniques es poden combinar amb regularització L2 i altres mètodes per obtenir models més robustos i amb millor capacitat de generalització.

Keyboard shortcuts

apunts.jg5.dev