Zeker, hier is een complete handleiding voor het opzetten van geautomatiseerde validatie voor je PyTorch CNN-model: ## Validatieloop Implementatie ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision import datasets, transforms from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, confusion_matrix import numpy as np import matplotlib.pyplot as plt import seaborn as sns # Modelarchitectuur class CNNModel(nn.Module): def __init__(self, dropout_rate=0.5): super(CNNModel, self).__init__() self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1) self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1) self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1) self.dropout = nn.Dropout2d(dropout_rate) self.fc = nn.Linear(128 * 3 * 3, 10) # Aangepast voor MNIST self.pool = nn.MaxPool2d(2) def forward(self, x): x = self.pool(torch.relu(self.conv1(x))) x = self.dropout(x) x = self.pool(torch.relu(self.conv2(x))) x = self.dropout(x) x = self.pool(torch.relu(self.conv3(x))) x = x.view(-1, 128 * 3 * 3) x = self.fc(x) return x # Validatiefunctie met uitgebreide metrics def validate_model(model, val_loader, criterion, device): model.eval() val_loss = 0.0 all_preds = [] all_labels = [] with torch.no_grad(): for data, target in val_loader: data, target = data.to(device), target.to(device) output = model(data) loss = criterion(output, target) val_loss += loss.item() pred = output.argmax(dim=1, keepdim=True) all_preds.extend(pred.cpu().numpy()) all_labels.extend(target.cpu().numpy()) val_loss /= len(val_loader) # Bereken verschillende metrics all_preds = np.array(all_preds).flatten() all_labels = np.array(all_labels) accuracy = accuracy_score(all_labels, all_preds) f1 = f1_score(all_labels, all_preds, average='weighted') precision = precision_score(all_labels, all_preds, average='weighted') recall = recall_score(all_labels, all_preds, average='weighted') return { 'loss': val_loss, 'accuracy': accuracy, 'f1_score': f1, 'precision': precision, 'recall': recall, 'predictions': all_preds, 'labels': all_labels } # Training loop met validatie def train_with_validation(model, train_loader, val_loader, criterion, optimizer, epochs, device): train_losses = [] val_metrics = [] for epoch in range(epochs): # Training fase model.train() train_loss = 0.0 for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() train_loss += loss.item() if batch_idx % 100 == 0: print(f'Epoch: {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)}]') train_loss /= len(train_loader) train_losses.append(train_loss) # Validatie fase val_results = validate_model(model, val_loader, criterion, device) val_metrics.append(val_results) # Log metrics print(f'\nEpoch {epoch+1}/{epochs}:') print(f'Train Loss: {train_loss:.4f}') print(f'Val Loss: {val_results["loss"]:.4f}') print(f'Val Accuracy: {val_results["accuracy"]:.4f}') print(f'Val F1-Score: {val_results["f1_score"]:.4f}') print(f'Val Precision: {val_results["precision"]:.4f}') print(f'Val Recall: {val_results["recall"]:.4f}') print('-' * 50) return train_losses, val_metrics # Foutanalyse functie def analyze_errors(predictions, labels, class_names): cm = confusion_matrix(labels, predictions) plt.figure(figsize=(10, 8)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=class_names, yticklabels=class_names) plt.title('Confusion Matrix') plt.ylabel('True Label') plt.xlabel('Predicted Label') plt.show() # Bereken class-specifieke metrics class_accuracy = cm.diagonal() / cm.sum(axis=1) for i, acc in enumerate(class_accuracy): print(f'Class {i} Accuracy: {acc:.4f}') return cm ``` ## Data Preparation en Training Setup ```python # Data transformaties transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) # Laad MNIST dataset train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST('./data', train=False, transform=transform) # Split training data voor validatie train_size = int(0.8 * len(train_dataset)) val_size = len(train_dataset) - train_size train_subset, val_subset = torch.utils.data.random_split(train_dataset, [train_size, val_size]) train_loader = DataLoader(train_subset, batch_size=64, shuffle=True) val_loader = DataLoader(val_subset, batch_size=64, shuffle=False) test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) # Initialiseer model en training device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = CNNModel().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # Start training met validatie train_losses, val_metrics = train_with_validation( model, train_loader, val_loader, criterion, optimizer, epochs=10, device=device ) ``` ## Geavanceerde Validatie en Monitoring ```python # Early stopping implementatie class EarlyStopping: def __init__(self, patience=5, min_delta=0): self.patience = patience self.min_delta = min_delta self.counter = 0 self.best_loss = None self.early_stop = False def __call__(self, val_loss): if self.best_loss is None: self.best_loss = val_loss elif val_loss > self.best_loss - self.min_delta: self.counter += 1 if self.counter >= self.patience: self.early_stop = True else: self.best_loss = val_loss self.counter = 0 # Learning rate scheduler scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2) # Gebruik in training loop: early_stopping = EarlyStopping(patience=3) for epoch in range(epochs): # ... training code ... val_results = validate_model(model, val_loader, criterion, device) # Update learning rate gebaseerd op validation loss scheduler.step(val_results['loss']) # Check early stopping early_stopping(val_results['loss']) if early_stopping.early_stop: print("Early stopping triggered!") break ``` ## Praktische Tips voor Validatie-analyse: 1. **Monitor overfitting**: Vergelijk training en validation loss 2. **Class-specifieke analyse**: Identificeer welke classes problematisch zijn 3. **Hyperparameter tuning**: Gebruik validation metrics om learning rate, dropout etc. af te stemmen 4. **Visualiseer resultaten**: Plot learning curves en confusion matrices 5. **Regelmatige checkpoints**: Sla het beste model op gebaseerd op validation performance ```python # Voorbeeld: Model checkpointing best_val_acc = 0.0 def save_checkpoint(model, optimizer, epoch, val_acc, filename): torch.save({ 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'val_accuracy': val_acc }, filename) # In training loop: if val_results['accuracy'] > best_val_acc: best_val_acc = val_results['accuracy'] save_checkpoint(model, optimizer, epoch, best_val_acc, 'best_model.pth') ``` Deze implementatie geeft je een robuust validatieproces met gedetailleerde metrics en analyse tools voor effectieve modelafstemming.