Natuurlijk! Hier is een voorbeeld van hoe je een aangepaste trainingslus kunt ontwikkelen in TensorFlow die meer controle biedt, inclusief dynamische aanpassing van de leersnelheid. We maken gebruik van een custom training loop met `tf.GradientTape` en passen de learning rate aan tijdens het trainen. ### Stappenplan: 1. **Model definiëren** 2. **Optimizer instellen met een leringschema of handmatige aanpassing** 3. **Datasets voorbereiden** 4. **Aangepaste trainingslus schrijven** 5. **Leersnelheid dynamisch aanpassen gebaseerd op bijvoorbeeld validatieprestaties of epochs** --- ### Voorbeeldcode: ```python import tensorflow as tf # Model bouwen (voorbeeld) model = tf.keras.Sequential([ tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(img_height, img_width, channels)), tf.keras.layers.MaxPooling2D((2,2)), tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D((2,2)), tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ]) # Initiale learning rate initial_lr = 0.001 optimizer = tf.keras.optimizers.Adam(learning_rate=initial_lr) # Loss- en metricdefinitie loss_fn = tf.keras.losses.BinaryCrossentropy() train_acc_metric = tf.keras.metrics.BinaryAccuracy() # Dataset voorbereiden (voorbeeld) train_dataset = ... # je hebt hier je dataset val_dataset = ... # validatie dataset # Aangepaste trainingsloop epochs = 10 for epoch in range(epochs): print(f'Start epoch {epoch+1}') # Mogelijkheid om leersnelheid aan te passen # Bijvoorbeeld op basis van epoch of validatieprestaties if epoch == 5: new_lr = 0.0005 optimizer.learning_rate.assign(new_lr) print(f'Leersnelheid aangepast naar {new_lr}') for step, (x_batch_train, y_batch_train) in enumerate(train_dataset): with tf.GradientTape() as tape: logits = model(x_batch_train, training=True) loss_value = loss_fn(y_batch_train, logits) grads = tape.gradient(loss_value, model.trainable_weights) optimizer.apply_gradients(zip(grads, model.trainable_weights)) # Bijwerken metrics train_acc_metric.update_state(y_batch_train, logits) if step % 100 == 0: print(f'Step {step}: loss = {loss_value.numpy():.4f}, accuracy = {train_acc_metric.result().numpy():.4f}') # Na elke epoch, metrics resetten en validatie uitvoeren train_acc = train_acc_metric.result() print(f'Einde epoch {epoch+1}: Training accuracy = {train_acc:.4f}') train_acc_metric.reset_states() # Validatie uitvoeren (optioneel) # ... ``` ### Extra tips: - Je kunt de leersnelheid aanpassen op basis van validatieprestaties, bijvoorbeeld door een learning rate scheduler te implementeren. - Gebruik `tf.keras.callbacks.LearningRateScheduler` voor automatische aanpassingen, maar in custom loops is het handmatig aanpassen vaak overzichtelijker. - Overweeg om een `tf.Variable` voor de learning rate te gebruiken zodat je deze flexibel kunt wijzigen tijdens het trainen. --- Wil je dat ik je help met een volledige code inclusief dataset voorbereiding en validatie?

Hier is een aangepaste trainingslus voor je TensorFlow-model waarmee je volledige controle hebt over het trainingsproces, inclusief dynamische aanpassing van de leersnelheid: ```python import tensorflow as tf import numpy as np from tensorflow.keras import layers, models # Voorbeeld modelarchitectuur (pas aan naar jouw specifieke model) def create_model(): model = models.Sequential([ layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)), layers.MaxPooling2D((2, 2)), layers.Conv2D(64, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Conv2D(128, (3, 3), activation='relu'), layers.MaxPooling2D((2, 2)), layers.Flatten(), layers.Dense(512, activation='relu'), layers.Dense(1, activation='sigmoid') ]) return model # Aangepaste trainingslus met leersnelheid aanpassing class CustomTrainingLoop: def __init__(self, model, initial_learning_rate=0.001): self.model = model self.learning_rate = initial_learning_rate self.optimizer = tf.keras.optimizers.Adam(learning_rate=initial_learning_rate) self.loss_fn = tf.keras.losses.BinaryCrossentropy() # Metrics bijhouden self.train_loss = tf.keras.metrics.Mean(name='train_loss') self.train_accuracy = tf.keras.metrics.BinaryAccuracy(name='train_accuracy') self.val_loss = tf.keras.metrics.Mean(name='val_loss') self.val_accuracy = tf.keras.metrics.BinaryAccuracy(name='val_accuracy') def adjust_learning_rate(self, epoch, loss_history): """Dynamisch aanpassen leersnelheid op basis van prestaties""" if len(loss_history) > 5: # Verminder leersnelheid als verlies stagneert recent_losses = loss_history[-5:] if max(recent_losses) - min(recent_losses) < 0.001: self.learning_rate *= 0.5 self.optimizer.learning_rate.assign(self.learning_rate) print(f"Leersnelheid aangepast naar: {self.learning_rate}") # Stapsgewijze vermindering elke 10 epochs if epoch % 10 == 0 and epoch > 0: self.learning_rate *= 0.9 self.optimizer.learning_rate.assign(self.learning_rate) print(f"Geplande leersnelheid aanpassing: {self.learning_rate}") @tf.function def train_step(self, x_batch, y_batch): """Enkele trainingsstap""" with tf.GradientTape() as tape: predictions = self.model(x_batch, training=True) loss = self.loss_fn(y_batch, predictions) gradients = tape.gradient(loss, self.model.trainable_variables) self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables)) self.train_loss(loss) self.train_accuracy(y_batch, predictions) return loss @tf.function def val_step(self, x_batch, y_batch): """Validatiestap""" predictions = self.model(x_batch, training=False) loss = self.loss_fn(y_batch, predictions) self.val_loss(loss) self.val_accuracy(y_batch, predictions) def train(self, train_dataset, val_dataset, epochs): """Hoofd trainingslus""" train_loss_history = [] for epoch in range(epochs): # Reset metrics self.train_loss.reset_states() self.train_accuracy.reset_states() self.val_loss.reset_states() self.val_accuracy.reset_states() # Trainingsloop for x_batch, y_batch in train_dataset: loss = self.train_step(x_batch, y_batch) # Validatieloop for x_batch, y_batch in val_dataset: self.val_step(x_batch, y_batch) # Huidige verlies toevoegen aan geschiedenis current_loss = self.train_loss.result() train_loss_history.append(current_loss.numpy()) # Leersnelheid aanpassen self.adjust_learning_rate(epoch, train_loss_history) # Print voortgang template = 'Epoch {}, Loss: {:.4f}, Accuracy: {:.2f}%, Val Loss: {:.4f}, Val Accuracy: {:.2f}%, LR: {:.6f}' print(template.format( epoch + 1, self.train_loss.result(), self.train_accuracy.result() * 100, self.val_loss.result(), self.val_accuracy.result() * 100, self.learning_rate )) # Vroegtijdig stoppen controle (optioneel) if len(train_loss_history) > 10 and current_loss > np.mean(train_loss_history[-10:]): print("Training stagneert - overweeg te stoppen") return train_loss_history # Gebruiksvoorbeeld: def main(): # Maak model en trainingslus model = create_model() custom_trainer = CustomTrainingLoop(model, initial_learning_rate=0.001) # Voorbeeld datasets (vervang met jouw data) # train_dataset en val_dataset moeten tf.data.Dataset objecten zijn # train_dataset = ... # val_dataset = ... # Start training # loss_history = custom_trainer.train(train_dataset, val_dataset, epochs=50) if __name__ == "__main__": main() ``` **Belangrijke aanpassingsmogelijkheden:** 1. **Leersnelheid strategieën**: ```python # Cosine annealing def cosine_annealing(epoch, total_epochs, initial_lr): return initial_lr * 0.5 * (1 + np.cos(epoch / total_epochs * np.pi)) # Stapsgewijze vermindering def step_decay(epoch): if epoch < 10: return 0.001 elif epoch < 20: return 0.0005 else: return 0.0001 ``` 2. **Geavanceerde monitoring**: ```python # Callback voor model checkpointing checkpoint_callback = tf.keras.callbacks.ModelCheckpoint( 'best_model.h5', monitor='val_accuracy', save_best_only=True, mode='max' ) ``` Deze aangepaste trainingslus geeft je volledige controle over het trainingsproces en maakt dynamische aanpassingen van de leersnelheid mogelijk op basis van de trainingsvoortgang.