Natuurlijk! Hier is een voorbeeld van aangepaste TensorFlow callbacks die je modeltraining kunnen verbeteren door overfitting te voorkomen en de generalisatie te bevorderen. Deze callbacks combineren EarlyStopping met LearningRateScheduler en ModelCheckpoint. Daarnaast kun je ook een custom callback toevoegen voor meer controle. ```python import tensorflow as tf # Callback voor het aanpassen van de learning rate tijdens training def scheduler(epoch, lr): if epoch < 10: return lr else: return lr * tf.math.exp(-0.1) # Aangepaste callback voor extra logging of acties class CustomCallback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): # Log bijvoorbeeld validatieverlies en nauwkeurigheid print(f"Epoch {epoch+1}: val_loss={logs['val_loss']:.4f}, val_accuracy={logs['val_accuracy']:.4f}") # Instantiateer de callbacks early_stopping = tf.keras.callbacks.EarlyStopping( monitor='val_loss', patience=10, restore_best_weights=True ) learning_rate_scheduler = tf.keras.callbacks.LearningRateScheduler(scheduler) model_checkpoint = tf.keras.callbacks.ModelCheckpoint( 'best_model.h5', monitor='val_loss', save_best_only=True ) custom_callback = CustomCallback() # Voeg de callbacks toe aan je model.fit() call model.fit( train_data, validation_data=validation_data, epochs=100, callbacks=[early_stopping, learning_rate_scheduler, model_checkpoint, custom_callback] ) ``` **Toelichting:** - **EarlyStopping:** voorkomt overfitting door te stoppen als het validatieverlies niet verbetert. - **LearningRateScheduler:** verlaagt de leersnelheid na een aantal epochs om fine-tuning te ondersteunen. - **ModelCheckpoint:** bewaart het beste model op basis van validatieverlies. - **CustomCallback:** biedt de mogelijkheid voor extra maatwerk, zoals logging of andere acties na elke epoch. Wil je nog meer maatwerk of specifieke functionaliteiten?

Zeker, ik help je graag met het maken van aangepaste TensorFlow callbacks voor je CNN. Hier zijn enkele krachtige callbacks die overfitting tegengaan en de generalisatie verbeteren: ## 1. Learning Rate Scheduler ```python class AdaptiveLRScheduler(tf.keras.callbacks.Callback): def __init__(self, factor=0.5, patience=3, min_lr=1e-6): super().__init__() self.factor = factor self.patience = patience self.min_lr = min_lr self.wait = 0 self.best_val_loss = float('inf') def on_epoch_end(self, epoch, logs=None): current_val_loss = logs.get('val_loss') if current_val_loss < self.best_val_loss: self.best_val_loss = current_val_loss self.wait = 0 else: self.wait += 1 if self.wait >= self.patience: old_lr = float(tf.keras.backend.get_value(self.model.optimizer.lr)) new_lr = max(old_lr * self.factor, self.min_lr) tf.keras.backend.set_value(self.model.optimizer.lr, new_lr) print(f'\nLearning rate verlaagd naar: {new_lr:.2e}') self.wait = 0 ``` ## 2. Gradient Norm Monitoring ```python class GradientMonitor(tf.keras.callbacks.Callback): def on_train_batch_end(self, batch, logs=None): with tf.GradientTape() as tape: # Bereken gradients pass # Monitor gradient norms om exploding/vanishing gradients te detecteren gradients = [tf.norm(grad) for grad in tape.gradient( self.model.total_loss, self.model.trainable_variables ) if grad is not None] if gradients: avg_grad_norm = tf.reduce_mean(gradients) logs['avg_gradient_norm'] = avg_grad_norm.numpy() ``` ## 3. Custom Early Stopping met extra voorwaarden ```python class EnhancedEarlyStopping(tf.keras.callbacks.Callback): def __init__(self, patience=10, min_delta=0.001, min_epochs=20): super().__init__() self.patience = patience self.min_delta = min_delta self.min_epochs = min_epochs self.best_weights = None self.best_val_loss = float('inf') self.wait = 0 def on_epoch_end(self, epoch, logs=None): current_val_loss = logs.get('val_loss') current_val_acc = logs.get('val_accuracy') if epoch < self.min_epochs: return if current_val_loss < self.best_val_loss - self.min_delta: self.best_val_loss = current_val_loss self.wait = 0 self.best_weights = self.model.get_weights() else: self.wait += 1 if self.wait >= self.patience: self.model.stop_training = True self.model.set_weights(self.best_weights) print(f'\nVroegtijdig stoppen na epoch {epoch+1}') ``` ## 4. Training Progress Logger ```python class TrainingProgressLogger(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): train_loss = logs.get('loss') val_loss = logs.get('val_loss') train_acc = logs.get('accuracy') val_acc = logs.get('val_accuracy') print(f'Epoch {epoch+1}:') print(f' Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}') print(f' Train Acc: {train_acc:.4f}, Val Acc: {val_acc:.4f}') # Overfitting ratio if train_loss > 0 and val_loss > 0: overfit_ratio = val_loss / train_loss print(f' Overfitting Ratio: {overfit_ratio:.2f}') logs['overfit_ratio'] = overfit_ratio ``` ## Gebruik in je model: ```python callbacks = [ EnhancedEarlyStopping(patience=15, min_epochs=25), AdaptiveLRScheduler(factor=0.5, patience=5), TrainingProgressLogger(), tf.keras.callbacks.ModelCheckpoint( 'best_model.h5', monitor='val_loss', save_best_only=True, mode='min' ), tf.keras.callbacks.ReduceLROnPlateau( monitor='val_loss', factor=0.2, patience=5, min_lr=1e-7 ) ] model.fit( x_train, y_train, validation_data=(x_val, y_val), epochs=100, batch_size=32, callbacks=callbacks, verbose=1 ) ``` ## Aanvullende tips: 1. **Gebruik Data Augmentation** voor betere generalisatie 2. **Regularisatietechnieken**: Dropout, L2 regularization, Batch Normalization 3. **Monitor zowel loss als accuracy** voor compleet beeld 4. **Gebruik TensorBoard** voor gedetailleerde visualisaties Deze callbacks helpen overfitting te voorkomen door: - Dynamische learning rate aanpassing - Gedetailleerde monitoring van training progress - Geavanceerde early stopping voorwaarden - Continue evaluatie van modelprestaties Succes met je CNN-training! 🚀