El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Validació i Prova

Següent ►
►

En aquest tema, aprendrem com validar i provar els nostres models de xarxes neuronals per assegurar-nos que generalitzen bé a dades no vistes. La validació i la prova són passos crucials en el procés d'entrenament de models, ja que ens ajuden a avaluar el rendiment del model i a detectar problemes com el sobreajustament (overfitting).

Objectius

  • Entendre la diferència entre validació i prova.
  • Aprendre a dividir les dades en conjunts d'entrenament, validació i prova.
  • Implementar un bucle de validació.
  • Avaluar el rendiment del model utilitzant mètriques adequades.

Diferència entre Validació i Prova

Validació

  • Propòsit: Ajustar els hiperparàmetres del model i prevenir el sobreajustament.
  • Dades: Un subconjunt de les dades d'entrenament que no es fa servir per entrenar el model.
  • Freqüència: Durant l'entrenament, després de cada època o cada cert nombre de passos.

Prova

  • Propòsit: Avaluar el rendiment final del model en dades no vistes.
  • Dades: Un conjunt separat de dades que no s'ha utilitzat ni per entrenar ni per validar el model.
  • Freqüència: Un cop finalitzat l'entrenament.

Divisió de les Dades

Abans de començar l'entrenament, hem de dividir les dades en tres conjunts: entrenament, validació i prova. Una divisió típica podria ser:

  • Entrenament: 70%
  • Validació: 15%
  • Prova: 15%
from sklearn.model_selection import train_test_split

# Suposem que tenim les dades en les variables X i y
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.3, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

Implementació del Bucle de Validació

Durant l'entrenament, després de cada època, avaluarem el model en el conjunt de validació per monitoritzar el seu rendiment.

import torch
import torch.nn as nn
import torch.optim as optim

# Suposem que tenim un model definit com `model`
# i un DataLoader per a les dades de validació `val_loader`

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    
    # Validació
    model.eval()
    val_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            val_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    val_loss /= len(val_loader)
    val_accuracy = 100 * correct / total
    print(f'Epoch {epoch+1}, Val Loss: {val_loss:.4f}, Val Accuracy: {val_accuracy:.2f}%')

Avaluació del Model en el Conjunt de Prova

Un cop finalitzat l'entrenament, avaluarem el model en el conjunt de prova per obtenir una mesura del seu rendiment en dades no vistes.

model.eval()
test_loss = 0.0
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        test_loss += loss.item()
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

test_loss /= len(test_loader)
test_accuracy = 100 * correct / total
print(f'Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.2f}%')

Mètriques d'Avaluació

Les mètriques d'avaluació més comunes per a classificació inclouen:

  • Precisió (Accuracy): Proporció de prediccions correctes.
  • Precisió (Precision): Proporció de prediccions positives correctes.
  • Record (Recall): Proporció de casos positius correctament identificats.
  • F1-Score: Mitjana harmònica de precisió i record.
from sklearn.metrics import classification_report

# Suposem que tenim les prediccions i les etiquetes reals
print(classification_report(y_test, y_pred))

Resum

En aquesta secció, hem après la importància de la validació i la prova en el procés d'entrenament de models de xarxes neuronals. Hem vist com dividir les dades en conjunts d'entrenament, validació i prova, i com implementar bucles de validació i prova per avaluar el rendiment del model. També hem explorat les mètriques d'avaluació més comunes per a models de classificació. Amb aquests coneixements, estem preparats per assegurar-nos que els nostres models generalitzen bé a dades no vistes i per detectar i corregir problemes de sobreajustament.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats