AI & Machine Learning

Modelltraining mit TensorFlow: Datenvorbereitung, Training & Evaluation

15 Min. Lesezeit20. März 2026
TensorFlow eğitimTensorFlow tutorialModel eğitimiKerasTensorFlow TürkçeDerin öğrenme modelHiperparametre ayarıTransfer learningModel değerlendirmePython TensorFlowYapay zeka modelML model training

TensorFlow und Keras sind Industriestandard-Tools für die Entwicklung, das Training und die Bereitstellung von Deep-Learning-Modellen. Die Verwaltung des gesamten Trainingsprozesses — von der Datenvorverarbeitung bis zur Hyperparameter-Optimierung — ist entscheidend für ein erfolgreiches KI-Projekt.

Daten-Pipeline erstellen

Effizientes Laden mit tf.data

Bei großen Datensätzen ist die effiziente Datenversorgung der GPU leistungskritisch:

python
import tensorflow as tf

# Daten laden und vorverarbeiten
def laden_und_verarbeiten(bild_pfad, label):
    """Bild von Festplatte laden und vorverarbeiten."""
    bild = tf.io.read_file(bild_pfad)
    bild = tf.image.decode_jpeg(bild, channels=3)
    bild = tf.image.resize(bild, [224, 224])
    bild = tf.cast(bild, tf.float32) / 255.0
    mean = tf.constant([0.485, 0.456, 0.406])
    std = tf.constant([0.229, 0.224, 0.225])
    bild = (bild - mean) / std
    return bild, label

# Hochleistungs-Pipeline
def pipeline_erstellen(dateipfade, labels, batch_size=32, training=True):
    ds = tf.data.Dataset.from_tensor_slices((dateipfade, labels))
    if training:
        ds = ds.shuffle(buffer_size=10000, seed=42)
    ds = ds.map(laden_und_verarbeiten, num_parallel_calls=tf.data.AUTOTUNE)
    ds = ds.batch(batch_size)
    ds = ds.prefetch(tf.data.AUTOTUNE)
    return ds

Modell erstellen und kompilieren

python
from tensorflow.keras import layers, models, optimizers

def modell_erstellen(klassen_anzahl, lernrate=0.001):
    """Transfer-Learning-Klassifikationsmodell erstellen."""
    backbone = tf.keras.applications.EfficientNetV2S(
        include_top=False,
        weights='imagenet',
        input_shape=(224, 224, 3)
    )
    backbone.trainable = False

    eingaben = layers.Input(shape=(224, 224, 3))
    x = backbone(eingaben, training=False)
    x = layers.GlobalAveragePooling2D()(x)
    x = layers.BatchNormalization()(x)
    x = layers.Dense(512, activation='relu')(x)
    x = layers.Dropout(0.4)(x)
    x = layers.Dense(256, activation='relu')(x)
    x = layers.Dropout(0.3)(x)
    ausgaben = layers.Dense(klassen_anzahl, activation='softmax')(x)

    modell = models.Model(inputs=eingaben, outputs=ausgaben)

    modell.compile(
        optimizer=optimizers.Adam(learning_rate=lernrate),
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )
    return modell

Callbacks und Trainingskontrolle

python
import os
from datetime import datetime

log_verzeichnis = os.path.join("logs", datetime.now().strftime("%Y%m%d-%H%M%S"))

callbacks = [
    tf.keras.callbacks.EarlyStopping(
        monitor='val_loss', patience=7,
        restore_best_weights=True, verbose=1
    ),
    tf.keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss', factor=0.5,
        patience=3, min_lr=1e-7, verbose=1
    ),
    tf.keras.callbacks.ModelCheckpoint(
        filepath='bestes_modell.keras',
        monitor='val_accuracy',
        save_best_only=True, verbose=1
    ),
    tf.keras.callbacks.TensorBoard(
        log_dir=log_verzeichnis,
        histogram_freq=1, write_graph=True
    ),
]

# Phase 1: Nur Klassifikationsschichten trainieren
history_1 = model.fit(
    train_ds, epochs=20,
    validation_data=val_ds,
    callbacks=callbacks
)

# Phase 2: Fine-Tuning
backbone = model.layers[1]
backbone.trainable = True
for layer in backbone.layers[:-30]:
    layer.trainable = False

model.compile(
    optimizer=optimizers.Adam(learning_rate=1e-5),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

history_2 = model.fit(
    train_ds, epochs=30,
    validation_data=val_ds,
    callbacks=callbacks
)

Benutzerdefinierte Trainingsschleife mit GradientTape

Die model.fit()-Methode von Keras ist für die meisten Fälle ausreichend. Für Szenarien wie GANs, Meta-Learning oder Forschungsprojekte benötigt man jedoch volle Kontrolle über die Trainingsschleife. tf.GradientTape zeichnet die Operationen des Forward-Passes auf und berechnet daraus automatisch die Gradienten.

python
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3)
verlust_fn = tf.keras.losses.SparseCategoricalCrossentropy()
train_genauigkeit = tf.keras.metrics.SparseCategoricalAccuracy()
val_genauigkeit = tf.keras.metrics.SparseCategoricalAccuracy()

@tf.function
def trainingsschritt(bilder, labels):
    with tf.GradientTape() as tape:
        vorhersagen = model(bilder, training=True)
        verlust = verlust_fn(labels, vorhersagen)
        gesamt_verlust = verlust + tf.add_n(model.losses) if model.losses else verlust

    gradienten = tape.gradient(gesamt_verlust, model.trainable_variables)
    gradienten = [tf.clip_by_norm(g, 1.0) for g in gradienten]
    optimizer.apply_gradients(zip(gradienten, model.trainable_variables))
    train_genauigkeit.update_state(labels, vorhersagen)
    return gesamt_verlust

for epoch in range(30):
    train_genauigkeit.reset_state()
    val_genauigkeit.reset_state()

    for batch_bilder, batch_labels in train_ds:
        verlust = trainingsschritt(batch_bilder, batch_labels)

    print(f"Epoch {epoch+1} - Train: {train_genauigkeit.result():.4f}")

Mixed Precision Training

Mixed Precision Training beschleunigt das Training erheblich, indem Berechnungen teilweise in FP16 durchgeführt werden. Moderne GPUs mit NVIDIA Tensor Cores führen FP16-Operationen deutlich schneller aus. Gradienten und Gewichte bleiben in FP32 erhalten.

python
tf.keras.mixed_precision.set_global_policy('mixed_float16')

eingaben = layers.Input(shape=(224, 224, 3))
x = backbone(eingaben, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(512, activation='relu')(x)
x = layers.Dropout(0.4)(x)
# Letzte Schicht in FP32 für numerische Stabilität
ausgaben = layers.Dense(klassen_anzahl, activation='softmax', dtype='float32')(x)

model_mp = models.Model(inputs=eingaben, outputs=ausgaben)

Modell-Quantisierung für Mobilgeräte (TFLite)

Für den Einsatz auf Mobilgeräten oder eingebetteten Systemen muss die Modellgröße reduziert und die Inferenzgeschwindigkeit erhöht werden. Die Quantisierung konvertiert Gewichte von 32-Bit-Gleitkomma in 8-Bit-Ganzzahlen und reduziert die Modellgröße um das Vierfache.

python
# Keras-Format
model.save('finales_modell.keras')

# TFLite mit dynamischer Quantisierung
converter = tf.lite.TFLiteConverter.from_saved_model('saved_model/my_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_modell = converter.convert()
with open('modell.tflite', 'wb') as f:
    f.write(tflite_modell)

# Volle Integer-Quantisierung
def repräsentativer_datensatz():
    for i in range(100):
        daten = np.random.rand(1, 224, 224, 3).astype(np.float32)
        yield [daten]

converter_int8 = tf.lite.TFLiteConverter.from_saved_model('saved_model/my_model')
converter_int8.optimizations = [tf.lite.Optimize.DEFAULT]
converter_int8.representative_dataset = repräsentativer_datensatz
converter_int8.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter_int8.inference_input_type = tf.uint8
converter_int8.inference_output_type = tf.uint8

tflite_int8 = converter_int8.convert()
with open('modell_int8.tflite', 'wb') as f:
    f.write(tflite_int8)

Bereitstellungsüberlegungen

Die Bereitstellungsstrategie variiert je nach Zielplattform:

  • Webserver: TensorFlow Serving als REST/gRPC-API
  • Mobile App: TFLite auf Android/iOS mit Quantisierung
  • Browser: TensorFlow.js für clientseitige Inferenz
  • Eingebettete Systeme: TFLite Micro auf Mikrocontrollern

Für jedes Szenario sollten Modellversionierung, A/B-Tests und Performance-Monitoring eingeplant werden.

Hyperparameter-Optimierung

Kritische Hyperparameter:

  • Lernrate: Zu hoch = Divergenz, zu niedrig = langsame Konvergenz
  • Batch-Größe: Größerer Batch = stabilere Gradienten, mehr Speicher (16, 32, 64)
  • Optimizer: Adam für die meisten Fälle; SGD + Momentum für Fine-Tuning
  • Dropout-Rate: Typischerweise zwischen 0.2 und 0.5

TensorBoard-Monitoring

bash
tensorboard --logdir logs --port 6006

TensorBoard ermöglicht die Überwachung von Trainings- und Validierungsmetriken, Gewichtsverteilungen, Modellgraph-Struktur und Lernratenänderungen in Echtzeit.

Zusammenfassung

Modelltraining mit TensorFlow vereint effiziente Daten-Pipelines, passende Modellarchitektur, intelligente Callback-Nutzung und systematische Hyperparameter-Suche. Benutzerdefinierte Trainingsschleifen mit GradientTape geben volle Kontrolle, während Mixed Precision Training die GPU-Effizienz steigert. Mit Transfer Learning und zweiphasiger Trainingsstrategie erreicht man auch mit begrenzten Daten hohe Leistung. TFLite-Quantisierung bringt Modelle auf Mobilgeräte, und TensorBoard-Monitoring sowie Modell-Checkpoints sind unverzichtbare Praktiken für professionelle ML-Projekte.

Verwandte Artikel

Was ist Machine Learning? Grundlagen & Ihr erstes Modell mit Python

Einführung in Machine Learning. Supervised, Unsupervised und Reinforcement Learning Konzepte. Erstes Modell mit Python.

Deep Learning mit CNN: Convolutional Neural Network Leitfaden

Convolutional Neural Network (CNN) Architektur und Deep Learning. Convolution, Pooling, Fully Connected Layer und Bildklassifizierung.

Haben Sie ein Flutter-Projekt?

Ich entwickle hochleistungsfähige Flutter-Anwendungen für iOS, Android und Web.

Kontakt aufnehmen