Hier is een implementatie met aangepaste callbacks voor early stopping in PyTorch: ```python import torch import numpy as np class EarlyStopping: def __init__(self, patience=3, 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 class TrainingCallbackHandler: def __init__(self): self.callbacks = [] def add_callback(self, callback): self.callbacks.append(callback) def on_epoch_end(self, val_loss): for callback in self.callbacks: callback(val_loss) def should_stop(self): return any(callback.early_stop for callback in self.callbacks if hasattr(callback, 'early_stop')) # Je aangepaste trainingsloop met callbacks def train_with_callbacks(model, optimizer, train_loader, val_loader, num_epochs=5): # Initialiseer callbacks callback_handler = TrainingCallbackHandler() early_stopping = EarlyStopping(patience=3) callback_handler.add_callback(early_stopping) for epoch in range(num_epochs): # Train fase train_loss = train_one_epoch(model, optimizer, train_loader) # Validatie fase val_loss = validate(model, val_loader) print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}') # Roep callbacks aan callback_handler.on_epoch_end(val_loss) # Controleer of training moet stoppen if callback_handler.should_stop(): print(f"Early stopping triggered after {epoch+1} epochs") break return model # Voorbeeld van je bestaande functies (moet je zelf implementeren) def train_one_epoch(model, optimizer, train_loader): model.train() total_loss = 0 for batch_idx, (data, target) in enumerate(train_loader): optimizer.zero_grad() output = model(data) loss = torch.nn.functional.cross_entropy(output, target) loss.backward() optimizer.step() total_loss += loss.item() return total_loss / len(train_loader) def validate(model, val_loader): model.eval() total_loss = 0 with torch.no_grad(): for data, target in val_loader: output = model(data) loss = torch.nn.functional.cross_entropy(output, target) total_loss += loss.item() return total_loss / len(val_loader) # Gebruik # model = YourModel() # optimizer = torch.optim.Adam(model.parameters()) # trained_model = train_with_callbacks(model, optimizer, train_loader, val_loader, num_epochs=100) ``` **Uitleg van de integratie:** 1. **EarlyStopping class**: Houdt bij of het validatieverlies 3 epochs niet verbetert 2. **CallbackHandler**: Beheert meerdere callbacks en hun executie 3. **train_with_callbacks**: Je hoofd trainingsfunctie die de callbacks integreert **Hoe het werkt:** - Na elke epoch wordt `on_epoch_end()` aangeroepen met het validatieverlies - De early stopping callback controleert of het verlies verbetert - Bij 3 opeenvolgende epochs zonder verbetering wordt `early_stop = True` - De training stopt automatisch via `should_stop()` check **Extra mogelijkheden:** Je kunt eenvoudig meer callbacks toevoegen: ```python class ModelCheckpoint: def __init__(self, filepath): self.filepath = filepath self.best_loss = float('inf') def __call__(self, val_loss): if val_loss < self.best_loss: self.best_loss = val_loss torch.save(model.state_dict(), self.filepath) print(f"Model opgeslagen met verlies: {val_loss:.4f}") # Toevoegen aan handler callback_handler.add_callback(ModelCheckpoint('best_model.pth')) ``` Deze architectuur maakt je code modulair en uitbreidbaar voor toekomstige requirements.