Natuurlijk! Hier is een uitgebreide gids voor het opzetten van een log- en bewakingskader voor je TensorFlow-model, inclusief aanbevelingen voor het vastleggen van belangrijke metrics, trainingsvoortgang en foutopsporing, met aandacht voor geheugenbeperkingen. 1. Gebruik van TensorBoard voor Logging en Bewaking a. Setup TensorBoard: import tensorflow as tf import datetime log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, update_freq='epoch') b. Metrics toevoegen tijdens modeltraining: model.fit( train_dataset, epochs=..., # aantal epochs validation_data=val_dataset, callbacks=[tensorboard_callback] ) 2. Bijhouden van Belangrijke Metrics a. Accuracy en verlies worden standaard gelogd via TensorBoard. b. Voor extra controle kun je custom callbacks toevoegen: class CustomMetricsLogger(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): print(f"Epoch {epoch+1}: Loss={logs['loss']}, Accuracy={logs['accuracy']}") # eventueel logging naar externe systemen 3. Foutopsporing en Diagnostiek a. Gebruik tf.debugging en tf.summary voor gedetailleerde logs: # Bijvoorbeeld: tf.summary.scalar('custom_metric', value, step=epoch) b. Voeg exception handling toe in je training: try: model.fit(...) except Exception as e: print("Fout tijdens training:", e) 4. Beperkingen in Geheugen a. Gebruik kleinere batch sizes: batch_size = 32 # of lager afhankelijk van geheugen b. Laad data efficiënt: train_dataset = tf.data.Dataset.from_tensor_slices(...).batch(batch_size).prefetch(tf.data.AUTOTUNE) c. Overweeg model- en data-optimisaties: - Gebruik model-pruning of quantization indien mogelijk - Verwijder niet-essentiële logs of callbacks na gebruik 5. Overzicht en Automatisering a. Script voor opzetten en starten van training: - Zorg dat logging directories gestructureerd zijn - Automatiseer het starten van TensorBoard: tensorboard --logdir=logs/fit b. Monitoring op afstand: - Gebruik TensorBoard.dev of andere cloud-gebaseerde monitoring diensten voor centrale bewaking 6. Aanvullende Tips - Gebruik ModelCheckpoint callback om de beste gewichten op te slaan. - Log ook modelarchitectuur en hyperparameters. - Overweeg het gebruik van GPU-geheugenbeheer opties (zoals tf.config.set_visible_devices) om geheugen efficiënt te gebruiken. Door deze aanpak te implementeren, krijg je een overzichtelijk, krachtig en geheugenbewust log- en bewakingskader voor je CNN-model met belangrijke metrics en foutdetectie.

Hier is een uitgebreid log- en bewakingskader voor uw TensorFlow-model, rekening houdend met geheugenbeperkingen: ## 1. Basis Callbacks Setup ```python import tensorflow as tf import numpy as np import os from datetime import datetime # Basis callbacks voor bewaking def create_monitoring_callbacks(log_dir="logs", model_name="cnn_model"): callbacks = [] # TensorBoard logging log_path = os.path.join(log_dir, model_name, datetime.now().strftime("%Y%m%d-%H%M%S")) tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=log_path, histogram_freq=1, # Elke epoch histograms write_graph=True, write_images=False, # Uitgeschakeld voor geheugenbesparing update_freq='epoch' ) callbacks.append(tensorboard_callback) return callbacks ``` ## 2. Aangepaste Callback voor Geheugenefficiënte Logging ```python class MemoryEfficientLogger(tf.keras.callbacks.Callback): def __init__(self, log_file="training_log.csv", metrics_to_log=['accuracy', 'loss']): super().__init__() self.log_file = log_file self.metrics_to_log = metrics_to_log self.epoch_data = [] def on_epoch_end(self, epoch, logs=None): # Log alleen essentiële metrics per epoch log_entry = { 'epoch': epoch + 1, 'timestamp': datetime.now().isoformat() } # Voeg metrics toe for metric in self.metrics_to_log: if metric in logs: log_entry[metric] = float(logs[metric]) if f'val_{metric}' in logs: log_entry[f'val_{metric}'] = float(logs[f'val_{metric}']) self.epoch_data.append(log_entry) # Schrijf naar CSV elke 5 epochs om geheugen te sparen if (epoch + 1) % 5 == 0: self._save_to_csv() def on_train_end(self, logs=None): # Zorg dat alle data wordt opgeslagen self._save_to_csv() def _save_to_csv(self): import pandas as pd if self.epoch_data: df = pd.DataFrame(self.epoch_data) df.to_csv(self.log_file, index=False) # Wis data na opslaan voor geheugenbesparing self.epoch_data.clear() ``` ## 3. Uitgebreid Bewakingsframework ```python class ComprehensiveMonitoring: def __init__(self, model, log_dir="monitoring_logs"): self.model = model self.log_dir = log_dir os.makedirs(log_dir, exist_ok=True) # Metrics geschiedenis (beperkt voor geheugen) self.history = { 'train_loss': [], 'train_accuracy': [], 'val_loss': [], 'val_accuracy': [] } def log_metrics(self, epoch, train_metrics, val_metrics=None): """Log metrics voor huidige epoch""" # Bewaar alleen laatste 50 epochs in geheugen max_history = 50 for key in self.history: if len(self.history[key]) >= max_history: self.history[key].pop(0) self.history['train_loss'].append(float(train_metrics[0])) self.history['train_accuracy'].append(float(train_metrics[1])) if val_metrics: self.history['val_loss'].append(float(val_metrics[0])) self.history['val_accuracy'].append(float(val_metrics[1])) # Console logging print(f"Epoch {epoch+1}:") print(f" Train - Loss: {train_metrics[0]:.4f}, Accuracy: {train_metrics[1]:.4f}") if val_metrics: print(f" Val - Loss: {val_metrics[0]:.4f}, Accuracy: {val_metrics[1]:.4f}") def detect_anomalies(self): """Detecteer mogelijke training problemen""" warnings = [] if len(self.history['train_loss']) > 5: # Check voor overfitting recent_train_acc = np.mean(self.history['train_accuracy'][-5:]) recent_val_acc = np.mean(self.history['val_accuracy'][-5:]) if recent_train_acc - recent_val_acc > 0.15: # 15% verschil warnings.append("Mogelijk overfitting gedetecteerd") # Check voor divergerend verlies recent_loss = self.history['train_loss'][-5:] if any(l > 2 * np.mean(recent_loss) for l in recent_loss): warnings.append("Onverwacht hoge verlieswaarden") return warnings # Gebruik in training def train_with_monitoring(model, train_data, val_data=None, epochs=100): monitoring = ComprehensiveMonitoring(model) # Callbacks verzamelen callbacks = create_monitoring_callbacks() memory_logger = MemoryEfficientLogger() callbacks.append(memory_logger) # Early stopping om resources te besparen early_stopping = tf.keras.callbacks.EarlyStopping( monitor='val_loss' if val_data else 'loss', patience=10, restore_best_weights=True ) callbacks.append(early_stopping) # ReduceLROnPlateau voor betere convergentie reduce_lr = tf.keras.callbacks.ReduceLROnPlateau( monitor='val_loss' if val_data else 'loss', factor=0.5, patience=5, min_lr=1e-7 ) callbacks.append(reduce_lr) # Training history = model.fit( train_data, validation_data=val_data, epochs=epochs, callbacks=callbacks, verbose=1 # Toon progressie ) return history, monitoring ``` ## 4. Geheugenbewuste ModelCheckpoint ```python # Lightweight model checkpointing class MemoryAwareModelCheckpoint(tf.keras.callbacks.Callback): def __init__(self, filepath, save_freq='epoch', save_best_only=True): super().__init__() self.filepath = filepath self.save_freq = save_freq self.save_best_only = save_best_only self.best_loss = float('inf') def on_epoch_end(self, epoch, logs=None): if self.save_best_only: current_loss = logs.get('val_loss', logs.get('loss')) if current_loss < self.best_loss: self.best_loss = current_loss # Sla alleen gewichten op om geheugen te besparen self.model.save_weights(f"{self.filepath}_epoch{epoch+1}.h5") print(f"Model opgeslagen met verlies: {current_loss:.4f}") ``` ## 5. Gebruik in uw Training Script ```python # Voorbeeld gebruik def setup_and_train(): # Uw model architectuur model = tf.keras.Sequential([ tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation='relu'), tf.keras.layers.Dense(10, activation='softmax') ]) model.compile( optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'] ) # Train met monitoring history, monitoring = train_with_monitoring( model=model, train_data=train_dataset, # Uw training data val_data=val_dataset, # Uw validatie data epochs=100 ) # Controleer voor anomalieën warnings = monitoring.detect_anomalies() if warnings: print("Waarschuwingen:", warnings) return model, history # Start training # model, history = setup_and_train() ``` ## Belangrijke Geheugenbesparende Features: 1. **Batch-gewijs loggen**: Data wordt elke 5 epochs opgeslagen 2. **Beperkte geschiedenis**: Slechts laatste 50 epochs in geheugen 3. **Gewichten-only opslag**: Model checkpointing slaat alleen gewichten op 4. **Geen image logging**: TensorBoard write_images uitgeschakeld 5. **Vroeg stoppen**: Voorkomt onnodige training 6. **Automatische LR reductie**: Verbeterde convergentie met minder epochs Dit framework biedt uitgebreide monitoring terwijl het rekening houdt met uw geheugenbeperkingen.