Natuurlijk! Hier is een overzicht van hoe je een multi-fase trainingspijplijn in TensorFlow kunt opzetten, inclusief gegevensvoorverwerking, modeltraining en evaluatie: 1. Gegevensvoorverwerking 2. Modeldefinitie 3. Modeltraining 4. Modelevaluatie Hier is een voorbeeldcode die deze fasen implementeert: ```python import tensorflow as tf import numpy as np # Stap 1: Gegevensgeneratie of -laden # Voorbeeld: 1000 monsters, 10 kenmerken np.random.seed(42) X = np.random.rand(1000, 10) y = np.random.randint(0, 2, size=(1000, 1)) # binaire classificatie # Stap 2: Gegevensvoorverwerking # Normaliseer gegevens from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # Gegevens splitsen in training en test from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42) # Stap 3: Modeldefinitie model = tf.keras.Sequential([ tf.keras.layers.Dense(64, activation='relu', input_shape=(10,)), tf.keras.layers.Dense(32, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # Stap 4: Modeltraining history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.2) # Stap 5: Evaluatie evaluation = model.evaluate(X_test, y_test) print(f"Test loss: {evaluation[0]:.4f}") print(f"Test accuracy: {evaluation[1]:.4f}") ``` **Verbeteringen voor hogere nauwkeurigheid en snellere trainingstijden:** - Gebruik van early stopping: ```python early_stop = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5) history = model.fit(X_train, y_train, epochs=100, batch_size=32, validation_split=0.2, callbacks=[early_stop]) ``` - Hyperparameter tuning (bijvoorbeeld via Keras Tuner) - Gebruik van GPU of TPU voor snellere training - Modelarchitectuur optimaliseren (meer/less dense lagen, activatiefuncties) Door deze fasen duidelijk te scheiden en te automatiseren, kun je de nauwkeurigheid verhogen en de trainingstijden verkorten.

Hier is een complete multi-fase trainingspijplijn in TensorFlow volgens uw specificaties: ```python import tensorflow as tf import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler import matplotlib.pyplot as plt class DataPreprocessingPhase: def __init__(self): self.scaler = StandardScaler() def execute(self, X, y): """Fase 1: Gegevensvoorverwerking""" print("=== FASE 1: Gegevensvoorverwerking ===") # Split data in training en test sets X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=42 ) # Normaliseer de kenmerken X_train_scaled = self.scaler.fit_transform(X_train) X_test_scaled = self.scaler.transform(X_test) print(f"Training set vorm: {X_train_scaled.shape}") print(f"Test set vorm: {X_test_scaled.shape}") return X_train_scaled, X_test_scaled, y_train, y_test class ModelTrainingPhase: def __init__(self, input_shape): self.model = self._build_model(input_shape) self.history = None def _build_model(self, input_shape): """Bouw het sequentiële model met 3 dense lagen""" model = tf.keras.Sequential([ tf.keras.layers.Dense(64, activation='relu', input_shape=input_shape), tf.keras.layers.Dropout(0.2), # Voorkom overfitting tf.keras.layers.Dense(32, activation='relu'), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(16, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') # Aanname: binaire classificatie ]) # Geoptimaliseerde compiler instellingen voor snellere training model.compile( optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'] ) print("Model architectuur:") model.summary() return model def execute(self, X_train, y_train, X_val, y_val): """Fase 2: Modeltraining""" print("\n=== FASE 2: Modeltraining ===") # Callbacks voor betere prestaties en snellere training callbacks = [ tf.keras.callbacks.EarlyStopping( patience=10, restore_best_weights=True, monitor='val_loss' ), tf.keras.callbacks.ReduceLROnPlateau( factor=0.5, patience=5, min_lr=1e-7 ) ] # Train het model self.history = self.model.fit( X_train, y_train, validation_data=(X_val, y_val), epochs=100, batch_size=32, # Optimal batch size voor snellere convergentie callbacks=callbacks, verbose=1 ) return self.model class EvaluationPhase: def __init__(self): self.metrics = {} def execute(self, model, X_test, y_test, history): """Fase 3: Evaluatie""" print("\n=== FASE 3: Evaluatie ===") # Model evaluatie test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0) self.metrics = { 'test_loss': test_loss, 'test_accuracy': test_accuracy } print(f"Test nauwkeurigheid: {test_accuracy:.4f}") print(f"Test verlies: {test_loss:.4f}") # Visualiseer training progress self._plot_training_history(history) return self.metrics def _plot_training_history(self, history): """Visualiseer de training geschiedenis""" fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) # Nauwkeurigheid plot ax1.plot(history.history['accuracy'], label='Training Nauwkeurigheid') ax1.plot(history.history['val_accuracy'], label='Validatie Nauwkeurigheid') ax1.set_title('Model Nauwkeurigheid') ax1.set_xlabel('Epoch') ax1.set_ylabel('Nauwkeurigheid') ax1.legend() # Verlies plot ax2.plot(history.history['loss'], label='Training Verlies') ax2.plot(history.history['val_loss'], label='Validatie Verlies') ax2.set_title('Model Verlies') ax2.set_xlabel('Epoch') ax2.set_ylabel('Verlies') ax2.legend() plt.tight_layout() plt.show() class TrainingPipeline: def __init__(self): self.phases = { 'preprocessing': DataPreprocessingPhase(), 'training': None, 'evaluation': EvaluationPhase() } self.results = {} def run(self, X, y): """Voer de complete pijplijn uit""" print("🚀 Multi-fase Trainingspijplijn Gestart") # Fase 1: Gegevensvoorverwerking X_train, X_test, y_train, y_test = self.phases['preprocessing'].execute(X, y) # Fase 2: Modeltraining self.phases['training'] = ModelTrainingPhase(input_shape=(X_train.shape[1],)) model = self.phases['training'].execute(X_train, y_train, X_test, y_test) # Fase 3: Evaluatie evaluation_results = self.phases['evaluation'].execute( model, X_test, y_test, self.phases['training'].history ) self.results = { 'model': model, 'evaluation': evaluation_results, 'history': self.phases['training'].history } print("\n✅ Pijplijn succesvol voltooid!") return self.results # Gebruiksvoorbeeld: if __name__ == "__main__": # Genereer voorbeelddata (vervang met uw eigen data) np.random.seed(42) X = np.random.randn(1000, 10) # 1000 monsters, 10 kenmerken y = np.random.randint(0, 2, 1000) # Binaire labels # Initialiseer en voer pijplijn uit pipeline = TrainingPipeline() results = pipeline.run(X, y) # Toon prestatieverbeteringen print(f"\n📈 Prestatieverbeteringen:") print(f"- Eindnauwkeurigheid: {results['evaluation']['test_accuracy']:.4f}") print(f"- Snellere training door early stopping en learning rate scheduling") print(f"- Voorkomen van overfitting door dropout lagen") ``` **Belangrijke prestatieverbeteringen in deze pijplijn:** 1. **Verhoogde Nauwkeurigheid:** - Data normalisatie met StandardScaler - Dropout lagen om overfitting te voorkomen - Early stopping om het beste model te behouden 2. **Snellere Trainingstijden:** - Geoptimaliseerde batch size (32) - Learning rate scheduling - Early stopping om onnodige epochs te voorkomen 3. **Robuuste Architectuur:** - Sequentiële model met 3 dense lagen (64-32-16 neuronen) - ReLU activatie voor betere convergentie - Gestructureerde fases voor betere onderhoudbaarheid **Gebruiksaanwijzing:** - Vervang de voorbeelddata met uw eigen dataset - Pas de output laag aan voor andere probleemtypes (multi-class, regression) - Optimaliseer hyperparameters verder op basis van uw specifieke use case De pijplijn is modulair opgezet en eenvoudig uit te breiden met extra fasen zoals hyperparameter tuning of model deployment.