Hier is de geïntegreerde implementatie voor model checkpointing en early stopping in je PyTorch trainingsproces: ```python import torch import numpy as np def train(model, train_loader, val_loader, criterion, optimizer, num_epochs=100, patience=7): # Early stopping variabelen best_val_loss = float('inf') epochs_no_improve = 0 early_stop = False # Geschiedenis voor monitoring train_losses = [] val_losses = [] for epoch in range(num_epochs): # Training fase model.train() train_loss = 0.0 for data, target in train_loader: optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() train_loss += loss.item() * data.size(0) # Validatie fase model.eval() val_loss = 0.0 with torch.no_grad(): for data, target in val_loader: output = model(data) loss = criterion(output, target) val_loss += loss.item() * data.size(0) # Gemiddelde losses berekenen train_loss = train_loss / len(train_loader.dataset) val_loss = val_loss / len(val_loader.dataset) train_losses.append(train_loss) val_losses.append(val_loss) print(f'Epoch {epoch+1}/{num_epochs} - Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}') # Model checkpointing - beste model opslaan if val_loss < best_val_loss: print(f'Validatieverlies verbeterd ({best_val_loss:.4f} -> {val_loss:.4f}). Model opgeslagen.') best_val_loss = val_loss epochs_no_improve = 0 # Beste model opslaan torch.save({ 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'val_loss': val_loss, 'train_loss': train_loss, }, 'best_model.pth') else: epochs_no_improve += 1 print(f'Geen verbetering voor {epochs_no_improve} epoch(s)') # Early stopping check if epochs_no_improve >= patience: print(f'Early stopping na {epoch+1} epochs') early_stop = True break # Laad het beste model terug aan het einde van training checkpoint = torch.load('best_model.pth') model.load_state_dict(checkpoint['model_state_dict']) print(f'Training voltooid. Beste validatieverlies: {best_val_loss:.4f}') return model, train_losses, val_losses # Voorbeeld van gebruik: # model, train_losses, val_losses = train(model, train_loader, val_loader, criterion, optimizer, num_epochs=100, patience=7) ``` **Uitleg van de implementatie:** 1. **Model Checkpointing**: - Slaat het model op wanneer het validatieverlies verbetert - Bewaart niet alleen de modelgewichten maar ook de optimizer state en trainingsinfo - Het beste model wordt opgeslagen als `best_model.pth` 2. **Early Stopping**: - `patience` parameter bepaalt hoeveel epochs zonder verbetering worden toegestaan - Stopt de training wanneer validatieverlies niet meer verbetert - Voorkomt overfitting en bespaart rekentijd 3. **Monitoring**: - Houdt trainings- en validatieverlies bij - Geeft duidelijke feedback over verbetering/stagnatie **Aanbevolen parameters**: - `patience=7`: Meestal een goede balans tussen vroeg stoppen en valse stops voorkomen - Pas `num_epochs` aan op basis van je datasetgrootte en complexiteit **Extra tip**: Voor grotere modellen kun je ook periodieke checkpoints toevoegen om meerdere versies op te slaan.