Skip to content

TensorFlow Spickzettel

End-to-End-Open-Source-Machine-Learning-Plattform von Google.

01

Erste Schritte

Installation & Grundlagen

TensorFlow 2.x läuft standardmäßig eager (Operationen führen sofort aus, wie normales Python). tf.config.list_physical_devices('GPU') nutzen, um zu verifizieren, dass CUDA-GPUs sichtbar sind. Für GPU-Unterstützung das [and-cuda]-Extra auf Linux/Windows installieren oder tensorflow-metal auf Apple Silicon. TF 2.x verschmolz Keras zu tf.keras — die hochstufige API der meisten Workflows.

tensorflow
# install TensorFlow (CPU)
pip install tensorflow

# with GPU support on Linux/Windows (CUDA-enabled)
pip install tensorflow[and-cuda]

import tensorflow as tf

# check version and devices
print(tf.__version__)
print("GPU:", tf.config.list_physical_devices('GPU'))

# eager execution is on by default in TF2
print(tf.executing_eagerly())   # True

Erste Tensors

tf.constant erzeugt einen unveränderlichen Tensor; tf.zeros / tf.ones / tf.random.* erzeugen übliche Muster. Jeder Tensor hat eine Form, dtype und Rang. .numpy() brückt zurück nach NumPy — auf GPU kann das eine Sync-Kopie auslösen. Explizite dtypes bevorzugen (float32 ist der ML-Standard), um stille Upcasts zu vermeiden, die die Performance brechen.

tensorflow
import tensorflow as tf

# constants are immutable
x = tf.constant([[1, 2], [3, 4]])
y = tf.zeros((3, 3))
z = tf.random.normal((2, 3), mean=0.0, stddev=1.0)

print(x.shape, x.dtype)   # (2, 2) int32
print(tf.reduce_sum(x))   # tf.Tensor(10, shape=(), dtype=int32)

# numpy interop is zero-copy when possible
print(x.numpy())          # array([[1, 2], [3, 4]])

Eager Execution & Gradienten

Eager Execution macht TF debuggbar wie normales Python — print, pdb und Tracebacks funktionieren alle. GradientTape zeichnet Forward-Ops auf beobachteten Tensors auf (tf.Variable wird automatisch beobachtet), sodass tape.gradient Ableitungen berechnen kann. Das Fundament eigener Trainingsschleifen. Tapes sind standardmäßig einmal verwendbar; persistent=True nutzen, um gradient mehrfach aufzurufen.

tensorflow
import tensorflow as tf

a = tf.constant(3.0)
b = tf.constant(4.0)
print(a * b + 1)   # tf.Tensor(13.0, ...)

# GradientTape records ops for automatic differentiation
with tf.GradientTape() as tape:
    tape.watch(a)
    y = a ** 2 + b    # y = a^2 + b, dy/da = 2a
grad = tape.gradient(y, a)
print(grad)   # tf.Tensor(6.0, ...)  (= 2*3)

tf.function & Graphen

@tf.function konvertiert eine Python-Funktion in einen portablen, optimierbaren TensorFlow-Graphen — viel schneller auf GPU und für Verteilung Pflicht. Die Funktion wird einmal pro Eingabesignatur getraced, also Python-Nebenwirkungen oder datenabhängigen Python-Kontrollfluss innerhalb vermeiden (tf.cond / tf.while_loop nutzen, sonst retracet die Funktion). Variablen müssen einmalig außerhalb der Funktion erzeugt werden oder tf.Variable mit gleichem Namen wiederverwenden.

tensorflow
import tensorflow as tf

@tf.function  # traces a graph; runs in graph mode after first call
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = x * w + b
        loss = tf.reduce_mean((preds - y) ** 2)
    grads = tape.gradient(loss, [w, b])
    optimizer.apply_gradients(zip(grads, [w, b]))
    return loss

w = tf.Variable(0.1)
b = tf.Variable(0.0)
optimizer = tf.keras.optimizers.SGD(0.01)

# first call builds the graph (slower); subsequent calls are fast
loss = train_step(tf.constant([1., 2.]), tf.constant([2., 4.]))

Gemischte Präzision

Gemischte Präzision rechnet in float16, behält aber float32-Masterkopien — 2-3x Durchsatz und halber Speicher auf Tensor-Core-GPUs (Volta+). Die 'mixed_float16'-Richtlinie handhabt Loss Scaling automatisch, um Underflow zu verhindern. Die Ausgabeschicht auf float32 zwingen für numerische Stabilität. Braucht Compute Capability >= 7.0; auf älteren GPUs kann es langsamer sein.

tensorflow
import tensorflow as tf

# enable mixed precision: compute in float16, store in float32
tf.keras.mixed_precision.set_global_policy('mixed_float16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', dtype='float32'),
    tf.keras.layers.Dense(10, activation='softmax', dtype='float32')
])

# loss scaling is automatic with mixed_float16 policy
print(tf.keras.mixed_precision.global_policy())
02

Tensors

tf.constant

tf.constant erzeugt einen unveränderlichen Tensor — Elemente lassen sich nicht zuweisen. Für trainierbare Tensors tf.Variable nutzen. tf.random.normal/uniform nehmen ein seed-Argument für Reproduzierbarkeit; tf.random.set_seed(42) macht das ganze Programm reproduzierbar. Für Mehrdimensionales Form-Tupel nutzen (keine Ints), um Überraschungen zu vermeiden.

tensorflow
import tensorflow as tf

a = tf.constant([1, 2, 3])
b = tf.constant([[1.0, 2.0], [3.0, 4.0]], dtype=tf.float32)

zeros = tf.zeros((2, 3))
ones = tf.ones((3, 3))
eye = tf.eye(3)
full = tf.fill((2, 3), 7.0)

arange = tf.range(0, 10, 2)       # [0, 2, 4, 6, 8]
linspace = tf.linspace(0.0, 1.0, 5)

rand = tf.random.uniform((2, 3))
randn = tf.random.normal((2, 3))

# constants are immutable: a[0] = 5  -> TypeError

tf.Variable

tf.Variable ist ein veränderlicher Tensor-Wrapper für Modellparameter und Optimiererzustand. assign / assign_add / assign_sub aktualisieren in place — gewöhnliche Python-Zuweisung (w = w + 1) erzeugt einen neuen Tensor und mutiert nicht. Variablen werden von GradientTape automatisch beobachtet, anders als tf.constant, das du explizit tape.watch()en musst. Variablen auf demselben Gerät halten wie die Ops, die sie nutzen.

tensorflow
import tensorflow as tf

w = tf.Variable(0.1, dtype=tf.float32)
W = tf.Variable(tf.random.normal((3, 4)))
b = tf.Variable(tf.zeros((4,)))

# read value
print(w.numpy())        # 0.1

# update value
w.assign(0.5)
w.assign_add(0.1)       # w += 0.1
w.assign_sub(0.05)

# assign in place on a slice
W[0, 0].assign(99.0)

# watched by GradientTape automatically
with tf.GradientTape() as tape:
    y = w ** 2
grad = tape.gradient(y, w)   # 2w

Tensor-Operationen

Die meiste Mathematik spiegelt NumPy: tf.reduce_sum / reduce_mean / reduce_max entsprechen np.sum/mean/max. axis= nutzen, um eine bestimmte Dimension zu reduzieren, und keepdims=True, um den Rang für Broadcasting zu erhalten. tf.matmul und der @-Operator machen Matrixmultiplikation (gebatcht bei 3D+-Eingaben). reshape liefert nach Möglichkeit eine View; transpose liefert in TF immer eine Kopie.

tensorflow
import tensorflow as tf

a = tf.constant([[1.0, 2.0], [3.0, 4.0]])
b = tf.constant([[5.0, 6.0], [7.0, 8.0]])

a + b; a - b; a * b; a / b      # element-wise
c = tf.matmul(a, b)              # matrix multiply
c = a @ b                        # equivalent

tf.reduce_sum(a)                 # sum of all
tf.reduce_sum(a, axis=0)         # sum along axis 0
tf.reduce_mean(a, axis=1)        # mean along axis 1
tf.reduce_max(a, axis=1)
tf.reduce_sum(a, axis=1, keepdims=True)

x = tf.range(12)
y = tf.reshape(x, (3, 4))
t = tf.transpose(y)              # shape (4, 3)

Indexierung & Slicing

TF unterstützt NumPy-artiges Slicing im eager-Modus und innerhalb von tf.function. tf.boolean_mask extrahiert Elemente, wo die Maske True ist (geflacht). tf.gather wählt standardmäßig entlang Achse 0 (wie fancy indexing). tf.where(cond, x, y) ist das vektorisierte Ternär — bei cond True aus x wählen, sonst y. Für Zuweisungen tf.tensor_scatter_nd_update oder ein tf.Variable nutzen.

tensorflow
import tensorflow as tf

x = tf.constant([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

x[0]              # first row
x[1, 2]           # element (1,2) -> 6
x[:, 1]           # second column
x[0:2]            # first two rows
x[:, ::2]         # every other column

# boolean mask
mask = x > 4
sel = tf.boolean_mask(x, mask)   # tensor([5, 6, 7, 8, 9])

# gather by indices
idx = tf.constant([0, 2])
rows = tf.gather(x, idx)         # rows 0 and 2

# where: select from two tensors
tf.where(x > 4, x, tf.zeros_like(x))

Ragged & Sparse-Tensors

Ragged-Tensors speichern Sequenzen variabler Länge ohne Padding — perfekt für NLP-Batches unterschiedlicher Länge. Sparse-Tensors speichern nur Nicht-Null-Indizes und Werte und sparen Speicher bei hochgradig sparsamen Daten (Empfehlungen, Graphen). Die meisten Ops haben sparse-bewusste Varianten; nur zu dicht konvertieren, wenn eine Op es verlangt. tf.RaggedTensor.to_tensor() pad-det zu einem Rechteck für Embedding-Lookups.

tensorflow
import tensorflow as tf

# ragged: variable-length sequences
ragged = tf.ragged.constant([[1, 2, 3], [4], [5, 6]])
print(ragged.shape)           # (3, None)
ragged.to_tensor()            # pad to (3, 3)

# sparse: mostly-zero tensors
indices = [[0, 0], [1, 2], [2, 1]]
values = [1.0, 2.0, 3.0]
sparse = tf.sparse.SparseTensor(
    indices=indices, values=values, dense_shape=[3, 3])
dense = tf.sparse.to_dense(sparse)

sp_sum = tf.sparse.reduce_sum(sparse)
sp_matmul = tf.sparse.sparse_dense_matmul(sparse, tf.eye(3))

Broadcasting & Mathematik

Broadcasting streckt Tensors kleinerer Dimension an die größeren, elementweise. clip_by_value ist TFs clamp. tf.maximum/minimum sind elementweise (anders als tf.reduce_max/min, die eine Dimension reduzieren). cumsum/cumprod liefern laufende Summen/Produkte entlang einer Achse — nützlich für kumulative Metriken und Präfixsummen-Algorithmen in eigenen Schichten.

tensorflow
import tensorflow as tf

# broadcasting follows NumPy rules
a = tf.constant([[1.0, 2.0, 3.0]])    # shape (1, 3)
b = tf.constant([[10.0], [20.0]])      # shape (2, 1)
c = a + b                              # shape (2, 3)

tf.abs(x); tf.sqrt(x); tf.exp(x); tf.log(x)
tf.square(x); tf.pow(x, 3)
tf.maximum(a, b); tf.minimum(a, b)
tf.clip_by_value(x, 0.0, 1.0)

tf.norm(x)                  # L2 norm
tf.norm(x, ord=1)           # L1 norm

tf.cumsum(tf.range(5))      # [0, 1, 3, 6, 10]
tf.cumprod(tf.range(1, 5))  # [1, 2, 6, 24]
03

Keras-Modelle

Sequential-API

Sequential ist das einfachste Keras-Modell — eine lineare Pipeline, deren Schichtausgabe die nächste speist. input_shape schließt die Batch-Dimension aus (None für variable Batch). model.summary() druckt Schichtformen und Parameterzahlen. Ohne input_shape baut sich das Modell lazy beim ersten fit/forward-Aufruf — build() explizit aufrufen, um früher zu inspizieren.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.summary()

# build later with input_shape (or first call)
model = tf.keras.Sequential()
model.add(tf.keras.layers.Dense(128, activation='relu'))
model.add(tf.keras.layers.Dense(10))
model.build((None, 784))   # None = variable batch

Funktionale API

Die funktionale API lässt Schichten verzweigen, verschmelzen und überspringen — Pflicht für alles Nicht-Lineare (ResNets, Mehr-Eingabe/-Ausgabe, siamesische Netze). Input-Tensors definieren, Schichten durch Aufruf verketten, dann inputs/outputs an Model übergeben. Das resultierende Modell verhält sich bei fit/predict identisch zu einem Sequential. Ein-/Ausgaben benennen für sauberes Speichern und Serving-Signaturen.

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(784,), name='img')
x = tf.keras.layers.Dense(128, activation='relu')(inputs)
x = tf.keras.layers.Dropout(0.5)(x)
x = tf.keras.layers.Dense(64, activation='relu')(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=outputs, name='mlp')

# multi-input / multi-output
img_in = tf.keras.Input(shape=(224, 224, 3))
meta_in = tf.keras.Input(shape=(10,))
x = tf.keras.layers.Conv2D(32, 3, activation='relu')(img_in)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.concatenate([x, meta_in])
out = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model([img_in, meta_in], out)

Modell-Subclassing

tf.keras.Model zu subklassen gibt volle Kontrolle über forward (wie PyTorch). Schichten in __init__ definieren, call(inputs, training=) implementieren. Das training-Flag schaltet Dropout- und BatchNorm-Verhalten um. Subclassing ist flexibler, verliert aber einige Vorteile der funktionalen API: schwerer zu inspizieren/plotten, keine automatische Eingabeform-Ableitung, und Serialisierung ist kniffliger. Für die meisten Architekturen funktional bevorzugen; subklassen für Forschungsmodelle.

tensorflow
import tensorflow as tf

class MLP(tf.keras.Model):
    def __init__(self, hidden=128, num_classes=10):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(hidden, activation='relu')
        self.drop = tf.keras.layers.Dropout(0.5)
        self.dense2 = tf.keras.layers.Dense(hidden, activation='relu')
        self.out = tf.keras.layers.Dense(num_classes, activation='softmax')

    def call(self, inputs, training=False):
        x = self.dense1(inputs)
        x = self.drop(x, training=training)
        x = self.dense2(x)
        return self.out(x)

model = MLP(hidden=64)
model.build((None, 784))
model.summary()

Modell-Kompilierung

compile verdrahtet Optimierer, Loss und Metriken vor fit. Strings ('adam', 'mse') sind Kurzbefehle zu den entsprechenden Klassen; Objekte für eigene Hyperparameter übergeben. Bei Mehr-Ausgabe-Modellen Dicts übergeben, die Ausgabenamen auf Verluste mappen. run_eagerly=True deaktiviert tf.function-Tracing, sodass pdb und print nutzbar sind — unbezahlbar zum Debuggen, aber langsam.

tensorflow
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
    loss_weights={'cls': 1.0, 'box': 0.5},
)

# explicit objects (more control)
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(),
    metrics=[tf.keras.metrics.SparseCategoricalAccuracy(name='acc')],
    run_eagerly=False,   # debug mode: run without graph
)

Modell-Zusammenfassung & Plot

summary() druckt eine Tabelle pro Schicht mit Ausgabeformen und Parameterzahlen — der schnellste Weg, Form-Bugs zu entdecken. plot_model speichert einen visuellen Graphen (braucht pydot und Graphviz). get_config liefert ein serialisierbares Dict, sodass die Architektur ohne Gewichte neu gebaut werden kann — genutzt von model.to_json() und dem Keras-Save-Format. Bei funktionalen Modellen erfasst die Config die Architektur vollständig; bei subklassierten musst du get_config selbst implementieren.

tensorflow
model.summary()
print(model.layers)
print(model.inputs, model.outputs)

# plot architecture (needs pydot + graphviz)
tf.keras.utils.plot_model(
    model, to_file='model.png', show_shapes=True,
    show_layer_names=True, rankdir='TB',
)

print(f"{model.count_params():,} params")

config = model.get_config()
new_model = tf.keras.Model.from_config(config)

Vorverarbeitung im Modell

Vorverarbeitung im Modell zu platzieren (Rescaling, Augmentations-Keras-Schichten) macht es deploybar: dasselbe SavedModel nimmt bei Inferenz rohe Bilder an, kein separater Vorverarbeitungsschritt. Keras-Vorverarbeitungsschichten laufen auf GPU und innerhalb von tf.function, sind also schnell. Für nur-Trainings-Augmentation training=True in fit setzen, damit die Schichten zur Inferenz inaktiv sind. Rescaling(1./255) konvertiert uint8-[0,255]-Bilder zu float [0,1].

tensorflow
import tensorflow as tf

# preprocessing as part of the model (deployable)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
    # ...
])
# the model now includes preprocessing, so inference needs raw images
04

Schichten

Dense-Schicht

Dense ist die vollverbundene Schicht: y = activation(xW + b). Die Gewichtungsform ist (in_features, out_features) — das Transpose von PyTorch. kernel_initializer ist standardmäßig Glorot/Xavier uniform, gut für tanh/sigmoid; 'he_normal' für die ReLU-Familie. L2-Regularisierung via kernel_regularizer ergänzen. GELU ist die Standardaktivierung in Transformers.

tensorflow
import tensorflow as tf

dense = tf.keras.layers.Dense(
    units=64, activation='relu', use_bias=True,
    kernel_initializer='glorot_uniform',
    bias_initializer='zeros',
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
)

x = tf.random.normal((4, 128))
y = dense(x)                     # shape (4, 64)

print(dense.kernel.shape)        # (128, 64)
print(dense.bias.shape)          # (64,)

dense = tf.keras.layers.Dense(64, activation=tf.nn.gelu)

Conv2D-Schicht

TF/Keras nutzt standardmäßig NHWC (channels-last), entgegengesetzt zu PyTorchs NCHW. padding='same' pad-det, sodass die räumliche Ausgabegröße = Eingabegröße / stride; 'valid' heißt kein Padding. DepthwiseConv2D wendet einen Filter pro Eingabekanal an (genutzt in MobileNet). Conv2DTranspose sampelt hoch (genutzt in Segmentierungs-Decodern). Die Kernel-Form ist (kH, kW, in_channels, filters).

tensorflow
import tensorflow as tf

conv = tf.keras.layers.Conv2D(
    filters=32, kernel_size=3, strides=(1, 1),
    padding='same', activation='relu', use_bias=True,
)

x = tf.random.normal((4, 28, 28, 3))   # NHWC
out = conv(x)
print(out.shape)                        # (4, 28, 28, 32) with padding='same'

dw = tf.keras.layers.DepthwiseConv2D(3, padding='same', activation='relu')
up = tf.keras.layers.Conv2DTranspose(32, 3, strides=2, padding='same')

Rekurrente Schichten (LSTM/GRU)

Die Eingabeform für RNNs ist (batch, timesteps, features). return_sequences=True ist nötig beim Stapeln von RNNs oder für Sequenz-zu-Sequenz-Modelle; False für Sequenz-zu-Vektor. Bidirectional verdoppelt die Ausgabegröße durch Konkatenation von Vorwärts und Rückwärts. recurrent_dropout ist bequem, aber langsam (keine cuDNN-Beschleunigung) — lieber plain Dropout auf Eingaben.

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(units=128, return_sequences=False)
x = tf.random.normal((4, 10, 64))   # (batch, time, features)
out = lstm(x)                       # (4, 128)

# stacked LSTM needs return_sequences=True
model = tf.keras.Sequential([
    tf.keras.layers.LSTM(128, return_sequences=True, input_shape=(10, 64)),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(10),
])

gru = tf.keras.layers.GRU(128)
bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)   # shape (4, 128) — 64 * 2

Dropout & Regularisierung

Dropout setzt während des Trainings zufällig Einheiten auf Null, um Ko-Adaption zu verhindern — zur Inferenz wird er automatisch deaktiviert (training=False). SpatialDropout2D wirft ganze Feature-Maps, besser für Conv-Netze. L2 (weight decay) ist der häufigste Regularisierer. LayerNormalization normalisiert über die Feature-Achse (pro Stichprobe), anders als BatchNorm, das über die Batch-Achse normalisiert — bevorzugt für Transformers und RNNs.

tensorflow
import tensorflow as tf

drop = tf.keras.layers.Dropout(0.5)
x = tf.random.normal((4, 10))
y = drop(x, training=True)   # training=True activates dropout

tf.keras.layers.SpatialDropout2D(0.5)   # drop entire feature maps
tf.keras.layers.GaussianDropout(0.5)
tf.keras.layers.AlphaDropout(0.5)

# weight regularization
tf.keras.layers.Dense(64,
    kernel_regularizer=tf.keras.regularizers.l2(1e-4),
    activity_regularizer=tf.keras.regularizers.l1(1e-5))

norm = tf.keras.layers.LayerNormalization()

Batch-Normalisierung

BatchNormalization normalisiert Aktivierungen pro Kanal und hält EMA-Laufstatistiken für die Inferenz. axis=-1 normalisiert die letzte (Kanal-)Achse für NHWC. BN nach dem Conv und vor der Aktivierung platzieren und den Conv-Bias deaktivieren (use_bias=False), da BNs beta die Verschiebung übernimmt. momentum steuert, wie schnell Laufstatistiken den Daten folgen — hohe Werte (0.99) sind stabiler. BN verhält sich im Training anders als zur Inferenz (training-Flag).

tensorflow
import tensorflow as tf

bn = tf.keras.layers.BatchNormalization(
    axis=-1, momentum=0.99, epsilon=1e-3,
)

model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, 3, padding='same', use_bias=False),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.ReLU(),
])

print(len(bn.weights))         # 4
print(len(bn.trainable_weights))    # 2

Eigene Schicht

Layer subklassen, um eigene Ops zu bauen. Gewichte in build() definieren (einmal mit der Eingabeform aufgerufen) statt in __init__, damit sich die Schicht an die Eingabegröße anpasst. get_config() implementieren, damit die Schicht serialisierbar und nachladbar ist. add_weight registriert den Tensor bei Keras' Tracking (erscheint also in weights, wird gespeichert und aufs Gerät bewegt). Für zustandslose Transformationen kannst du build() weglassen und nur call() überschreiben.

tensorflow
import tensorflow as tf

class Linear(tf.keras.layers.Layer):
    def __init__(self, units=32, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer='glorot_uniform', trainable=True, name='w')
        self.b = self.add_weight(
            shape=(self.units,), initializer='zeros', trainable=True, name='b')

    def call(self, inputs):
        return tf.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({'units': self.units})
        return config

layer = Linear(64)
out = layer(tf.random.normal((4, 10)))
05

Verluste

BinaryCrossentropy

BinaryCrossentropy ist für binäre Aufgaben oder Multi-Label (jede Klasse unabhängig). from_logits=True übergeben, wenn dein Modell rohe Logits ausgibt — numerisch sicherer, als Sigmoid + BCE getrennt anzuwenden. pos_weight gewichtet positive Beispiele auf, um Ungleichgewicht zu behandeln. Bei Multi-Label-Problemen mit C Klassen ist die Zielform (N, C) aus 0/1 und die Vorhersagen sind (N, C)-Wahrscheinlichkeiten oder Logits.

tensorflow
import tensorflow as tf

bce = tf.keras.losses.BinaryCrossentropy(from_logits=False)
y_true = tf.constant([[1.0], [0.0], [1.0], [0.0]])
y_pred = tf.constant([[0.9], [0.1], [0.8], [0.2]])
loss = bce(y_true, y_pred)

# from_logits=True is more numerically stable
bce_logits = tf.keras.losses.BinaryCrossentropy(from_logits=True)
logits = tf.constant([[2.0], [-2.0], [1.5], [-1.5]])
loss = bce_logits(y_true, logits)

bce = tf.keras.losses.BinaryCrossentropy(
    from_logits=True, pos_weight=tf.constant([5.0]))

CategoricalCrossentropy

CategoricalCrossentropy erwartet one-hot-Ziele; SparseCategoricalCrossentropy erwartet ganzzahlige Klassenindizes (speichereffizienter bei vielen Klassen). Immer from_logits=True übergeben, wenn das Modell nicht in Softmax endet — er nutzt den log-sum-exp-Trick für numerische Stabilität. Für Label Smoothing CategoricalCrossentropy(label_smoothing=0.1) nutzen, ein starker Regularisierer für Klassifikation und NLP.

tensorflow
import tensorflow as tf

# one-hot labels
cce = tf.keras.losses.CategoricalCrossentropy(from_logits=False)
y_true = tf.constant([[0, 1, 0], [1, 0, 0]], dtype=tf.float32)
y_pred = tf.constant([[0.1, 0.8, 0.1], [0.7, 0.2, 0.1]])
loss = cce(y_true, y_pred)

# integer labels -> use sparse version
scce = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
y_true_int = tf.constant([1, 0])
logits = tf.constant([[1.0, 3.0, 0.5], [2.5, 0.2, 0.1]])
loss = scce(y_true_int, logits)

MSE & Regressionsverluste

MSE bestraft große Fehler quadratisch (empfindlich gegen Ausreißer); MAE ist linear. Huber verhält sich nahe Null wie MSE und fern wie MAE — der Standard für Objektdetektions-Regression. LogCosh ist ähnlich, aber überall zweifach differenzierbar, nützlich, wenn Gradienten zweiter Ordnung nötig sind. Die Reduktion ist standardmäßig der Mittelwert über den Batch; mit reduction=tf.keras.losses.Reduction.NONE überschreiben für Verluste pro Stichprobe.

tensorflow
import tensorflow as tf

mse = tf.keras.losses.MeanSquaredError()
y_true = tf.constant([3.0, -0.5, 2.0, 7.0])
y_pred = tf.constant([2.5, 0.0, 2.0, 8.0])
loss = mse(y_true, y_pred)

mae = tf.keras.losses.MeanAbsoluteError()
loss = mae(y_true, y_pred)

huber = tf.keras.losses.Huber(delta=1.0)
loss = huber(y_true, y_pred)

logcosh = tf.keras.losses.LogCosh()
loss = logcosh(y_true, y_pred)

Eigener Loss

Ein eigener Loss ist jedes aufrufbare Objekt, das (y_true, y_pred) nimmt und einen skalaren Tensor zurückgibt. Für Serialisierung oder Hyperparameter tf.keras.losses.Loss subklassen und call() + get_config() implementieren. Jede Op differenzierbar halten. FocalLoss gewichtet einfache Beispiele ab, um sich auf harte zu konzentrieren — beliebt in der Objektdetektion. Reduction.NONE in call() nutzen und Keras am Ende reduzieren lassen, wenn Maskierung funktionieren soll.

tensorflow
import tensorflow as tf

def weighted_mse(y_true, y_pred):
    weights = tf.cast(y_true != 0, tf.float32)
    return tf.reduce_sum(weights * tf.square(y_true - y_pred)) / tf.reduce_sum(weights)

class FocalLoss(tf.keras.losses.Loss):
    def __init__(self, alpha=0.25, gamma=2.0, **kwargs):
        super().__init__(**kwargs)
        self.alpha = alpha
        self.gamma = gamma

    def call(self, y_true, y_pred):
        bce = tf.keras.losses.binary_crossentropy(y_true, y_pred)
        p = y_pred
        pt = p * y_true + (1 - p) * (1 - y_true)
        return self.alpha * tf.pow(1 - pt, self.gamma) * bce

    def get_config(self):
        config = super().get_config()
        config.update({'alpha': self.alpha, 'gamma': self.gamma})
        return config

loss = FocalLoss(alpha=0.25, gamma=2.0)

Loss aus Logits

Softmax und Cross-Entropie getrennt zu berechnen kann bei großen Logits überlaufen (e^100). from_logits=True zu übergeben lässt TF beide mit dem log-sum-exp-Trick verschmelzen, was numerisch stabil ist. Die funktionalen tf.nn.*_cross_entropy_with_logits-APIs machen dasselbe. Sicherstellen, dass dein Modell bei from_logits=True NICHT in Softmax/Sigmoid endet, sonst wendest du die Aktivierung doppelt an.

tensorflow
import tensorflow as tf

# why logits? numerical stability
logits = tf.constant([[100.0, 0.0, 0.0]])

# BAD: softmax first then CCE (can overflow)
probs = tf.nn.softmax(logits)
loss_bad = tf.keras.losses.CategoricalCrossentropy()(
    tf.constant([[1.0, 0.0, 0.0]]), probs)

# GOOD: from_logits=True uses log-sum-exp internally
loss_good = tf.keras.losses.CategoricalCrossentropy(from_logits=True)(
    tf.constant([[1.0, 0.0, 0.0]]), logits)

loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=y, logits=z)
loss = tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=z)

Mehr-Ausgabe-Verluste

Bei Mehr-Ausgabe-Modellen ein Dict übergeben, das Ausgabenamen auf Verlustfunktionen mappt, plus ein loss_weights-Dict zum Ausbalancieren. Der Gesamtverlust ist die gewichtete Summe. Das ist das Standardmuster für Multi-Task-Lernen — jeder Kopf bekommt seinen eigenen Loss und seine Metrik. Trainingsziele zur fit-Zeit als Dict mit denselben Schlüsseln übergeben. loss_weights so tunen, dass keine Aufgabe den Gradienten dominiert.

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss={
        'priority': tf.keras.losses.BinaryCrossentropy(from_logits=True),
        'department': tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    },
    loss_weights={'priority': 1.0, 'department': 0.5},
    metrics={'priority': ['accuracy'], 'department': ['accuracy']},
)

inputs = tf.keras.Input(shape=(64,))
x = tf.keras.layers.Dense(64, activation='relu')(inputs)
out_a = tf.keras.layers.Dense(1, name='priority')(x)
out_b = tf.keras.layers.Dense(10, name='department')(x)
model = tf.keras.Model(inputs, [out_a, out_b])

model.fit(x_train, {'priority': y_pri, 'department': y_dep}, epochs=5)
06

Optimierer

Adam

Adam ist der Standardoptimierer für die meisten Aufgaben — adaptive Lernraten pro Parameter, robust gegenüber Hyperparameterwahl. beta_1/beta_2 steuern den EMA-Zerfall des ersten und zweiten Moments. Statt eines Floats ein LearningRateSchedule-Objekt übergeben, um die LR über das Training abklingen zu lassen. global_clipnorm skaliert alle Gradienten um, wenn ihre kombinierte Norm die Schwelle überschreitet — wichtig für RNNs und Transformers.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(learning_rate=1e-3)

opt = tf.keras.optimizers.Adam(
    learning_rate=1e-3, beta_1=0.9, beta_2=0.999,
    epsilon=1e-7, amsgrad=False,
)

# schedule as learning_rate
lr_schedule = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000)
opt = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

# gradient clipping
opt = tf.keras.optimizers.Adam(learning_rate=1e-3, global_clipnorm=1.0)

SGD

SGD + momentum verallgemeinert beim CNN-Training mit großen Batches oft besser als Adam, auf Kosten von mehr LR-Tuning. momentum=0.9 ist Standard; Nesterov gibt einen kleinen Extraschub. weight_decay ergänzt entkoppelte L2-Regularisierung (Keras 3) — ältere Versionen nutzen stattdessen kernel_regularizer auf Schichten. SGD braucht Warmup und LR-Planung, um mit Adam ab Werk zu konkurrieren.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.SGD(learning_rate=0.01)
opt = tf.keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, nesterov=True)

# with weight decay (Keras 2.13+ / 3.x)
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, weight_decay=1e-4)

# clip gradients by value
opt = tf.keras.optimizers.SGD(
    learning_rate=0.01, momentum=0.9, clipvalue=0.5)

AdamW & weitere Optimierer

AdamW entkoppelt Weight Decay vom Gradientenupdate, was bei Skala zählt (Transformers, große CNNs). RMSprop ist der klassische RNN-Optimierer. Adagrad passt sich pro Parameter an, kann aber früh stocken — fein für sparsame Features. FTRL ist für großmaßstäbliches Online-Lernen mit sparsamen Features entworfen (Click-Through-Vorhersage). Für neue Projekte mit AdamW beginnen.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.AdamW(
    learning_rate=3e-4, weight_decay=0.01,
    beta_1=0.9, beta_2=0.999)

opt = tf.keras.optimizers.RMSprop(learning_rate=1e-3, rho=0.9)
opt = tf.keras.optimizers.Adagrad(learning_rate=1e-2)
opt = tf.keras.optimizers.Adadelta(learning_rate=1.0)
opt = tf.keras.optimizers.Nadam(learning_rate=1e-3)
opt = tf.keras.optimizers.Ftrl(learning_rate=0.1)

Gradienten anwenden

In einer eigenen Trainingsschleife berechnest du Gradienten mit GradientTape und rufst dann opt.apply_gradients(zip(grads, vars)) auf. Das ist der Baustein eigener Trainingsschleifen (siehe Sektion eigene Trainingsschleife). clip_by_global_norm skaliert Gradienten um, sodass ihre kombinierte L2-Norm unter der Schwelle bleibt. None-Gradienten heißen, dass die Variable den Loss nicht berührte — üblich bei ungenutzten Parametern und loggenswert.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3)
vars = [w, b]

with tf.GradientTape() as tape:
    preds = model(x)
    loss = loss_fn(y, preds)
grads = tape.gradient(loss, vars)

grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

for v, g in zip(vars, grads):
    print(v.name, g is not None, g.numpy().norm() if g is not None else None)

Lernraten-Pläne

LearningRateSchedule-Objekte berechnen die LR als Funktion des Schritt-Zählers des Optimierers. CosineDecay glüht sanft auf alpha*initial_lr ab — ein starker Standard. CosineDecayRestarts implementiert SGDR-artige Warm Restarts. Den Schedule als learning_rate beim Konstruieren des Optimierers übergeben; Keras ruft ihn automatisch bei jedem Schritt auf. Für Warmup mit einem eigenen Schedule umhüllen oder den WarmUp-Callback aus tensorflow/addons nutzen.

tensorflow
import tensorflow as tf

sched = tf.keras.optimizers.schedules.PiecewiseConstantDecay(
    boundaries=[500, 1500], values=[1e-3, 1e-4, 1e-5])

sched = tf.keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate=1e-3, decay_steps=1000, decay_rate=0.96,
    staircase=True)

sched = tf.keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3, decay_steps=10000, alpha=0.0)

opt = tf.keras.optimizers.Adam(learning_rate=sched)
print(opt.learning_rate(opt.iterations))

Gradient-Clipping & EMA

global_clipnorm (skaliert alle Gradienten gemeinsam um) ist die häufigste Wahl und wird von Transformers genutzt. clipvalue klemmt jedes Element hart. Für eigenes Clipping die Gradienten zwischen tape.gradient und apply_gradients ändern. Das Exponential Moving Average (EMA) der Gewichte bringt zur Inferenz oft einen kleinen Genauigkeitsschub — nach jedem Schritt anwenden und die gemittelten Gewichte zur Evaluation nutzen. TF Addons hat einen MovingAverage-Optimierer-Wrapper.

tensorflow
import tensorflow as tf

opt = tf.keras.optimizers.Adam(1e-3, global_clipnorm=1.0)
opt = tf.keras.optimizers.Adam(1e-3, clipvalue=0.5)
opt = tf.keras.optimizers.Adam(1e-3, clipnorm=1.0)

# manual clipping (more control)
grads = tape.gradient(loss, vars)
grads = [tf.clip_by_norm(g, 1.0) if g is not None else g for g in grads]
grads, _ = tf.clip_by_global_norm(grads, 1.0)
opt.apply_gradients(zip(grads, vars))

# exponential moving average of weights (improves generalization)
ema = tf.train.ExponentialMovingAverage(decay=0.999)
07

Training

compile & fit

fit ist die hochstufige Trainings-API: Er handhabt Batching, Mischen, Validierung, Callbacks und Fortschritt. Entweder validation_data=(x, y) oder validation_split=0.2 übergeben (aus dem Training herausgehalten). verbose=2 druckt eine Zeile pro Epoche (gut für Logs); 1 zeigt eine Fortschrittsleiste. Das zurückgegebene history-Objekt speichert Loss und Metriken pro Epoche — plotten, um Overfitting zu erkennen.

tensorflow
import tensorflow as tf

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy'],
)

history = model.fit(
    x_train, y_train, batch_size=32, epochs=10,
    validation_data=(x_val, y_val),
    validation_split=0.2, shuffle=True, verbose=2,
)

print(history.history['loss'])

Validierung & Metriken

Metriken sind zustandsbehaftete Objekte, die über Batches akkumulieren und am Epochende den Endwert berechnen — anders als Verluste beeinflussen sie das Training nicht. Strings ('accuracy') oder Metric-Objekte für eigene Metriken übergeben. tf.keras.metrics.Metric subklassen und update_state/result/reset_state implementieren. reset_state (umbenannt von reset_states in TF 2.11+) wird zu Beginn jeder Epoche aufgerufen.

tensorflow
model.compile(
    optimizer='adam', loss='sparse_categorical_crossentropy',
    metrics=[
        'accuracy',
        tf.keras.metrics.SparseTopKCategoricalAccuracy(k=5, name='top5_acc'),
        tf.keras.metrics.Precision(name='precision'),
        tf.keras.metrics.Recall(name='recall'),
    ],
)

class F1Score(tf.keras.metrics.Metric):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.precision = tf.keras.metrics.Precision()
        self.recall = tf.keras.metrics.Recall()
    def update_state(self, y_true, y_pred, sample_weight=None):
        self.precision.update_state(y_true, y_pred, sample_weight)
        self.recall.update_state(y_true, y_pred, sample_weight)
    def result(self):
        p, r = self.precision.result(), self.recall.result()
        return 2 * p * r / (p + r + 1e-8)
    def reset_state(self):
        self.precision.reset_state(); self.recall.reset_state()

Epochen, Batch-Größe & Schritte

Bei Nutzung eines tf.data.Dataset batch_size nicht übergeben — der Datensatz ist bereits gebatcht. steps_per_epoch sagt fit, wie viele Batches eine Epoche ausmachen, wenn der Datensatz unbegrenzt wiederholt. validation_steps macht dasselbe für die Validierung. initial_epoch nutzen, um das Training von einem Checkpoint fortzusetzen — fit überspringt die ersten N Epochen, aber der Optimiererzustand (LR-Schedule, Momentum) läuft korrekt weiter.

tensorflow
model.fit(x_train, y_train, batch_size=32, epochs=10)

# with tf.data.Dataset
model.fit(train_dataset, epochs=10, validation_data=val_dataset)

# Dataset of unknown size: use steps_per_epoch
model.fit(
    train_dataset, epochs=10, steps_per_epoch=500,
    validation_data=val_dataset, validation_steps=50,
)

# initial epoch (resume training)
model.fit(train_dataset, initial_epoch=5, epochs=10)

Klassen- & Stichproben-Gewichte

class_weight skaliert den Loss je Klasse, um Ungleichgewicht auszugleichen — äquivalent zu Oversampling ohne die Extra-Berechnung. sample_weight gibt Kontrolle pro Beispiel, nützlich für Hard-Example-Mining oder das Maskieren gepaddeter Positionen. Bei einem tf.data.Dataset sample_weight als drittes Tupel-Element einschließen, sodass der Datensatz (x, y, w) liefert. sklearn.utils.class_weight nutzen, um balancierte Gewichte automatisch zu berechnen.

tensorflow
class_weight = {0: 1.0, 1: 5.0, 2: 1.0}   # class 1 is rare
model.fit(x_train, y_train, class_weight=class_weight, epochs=10)

sample_weight = np.where(y_train == 1, 5.0, 1.0)
model.fit(x_train, y_train, sample_weight=sample_weight, epochs=10)

# with Dataset: yield (x, y, sample_weight) tuples
ds = tf.data.Dataset.from_tensor_slices((x, y, w))
model.fit(ds, epochs=10)

from sklearn.utils import class_weight
cw = class_weight.compute_class_weight('balanced', classes=np.unique(y), y=y)
class_weight = dict(enumerate(cw))

Predict & Evaluate

predict liefert ein NumPy-Array von Vorhersagen für die gesamte Eingabe — mit batch_size den Speicher steuern. evaluate liefert den Loss plus alle Metriken aus compile. Bei sehr großen Eingaben Batches manuell mit predict_on_batch iterieren. Das Modell direkt aufzurufen (model(x)) liefert einen Tensor und respektiert training=, während predict immer im Inferenzmodus läuft und NumPy zurückgibt. model(x, training=True) für Test-Zeit-Augmentation nutzen.

tensorflow
preds = model.predict(x_test, batch_size=64)
print(preds.shape)   # (N, num_classes)

pred = model.predict(x_test[:1])

loss, acc = model.evaluate(x_test, y_test, batch_size=64, verbose=2)
test_loss, test_acc, test_prec = model.evaluate(test_dataset)

for batch in test_dataset:
    preds = model.predict_on_batch(batch[0])

preds = model(x_test, training=True)   # callable form, test-time aug

train_step überschreiben

train_step zu überschreiben erlaubt es, zu bestimmen, was in jedem fit-Batch passiert, während fit's Epochenschleife, Callbacks und Verteilung erhalten bleiben. Die Brücke zwischen hochstufigem fit und einer vollkommen eigenen Schleife — super für GANs, kontrastives Lernen oder jedes nicht-Standard-Ziel. self.compiled_loss und self.compiled_metrics nutzen, damit Loss/Metriken aus compile() weiterwirken. test_step überschreibt das Validierungsverhalten auf dieselbe Weise.

tensorflow
import tensorflow as tf

class CustomModel(tf.keras.Model):
    def train_step(self, data):
        x, y = data
        with tf.GradientTape() as tape:
            y_pred = self(x, training=True)
            loss = self.compiled_loss(y, y_pred, regularization_losses=self.losses)
        grads = tape.gradient(loss, self.trainable_variables)
        self.optimizer.apply_gradients(zip(grads, self.trainable_variables))
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

    def test_step(self, data):
        x, y = data
        y_pred = self(x, training=False)
        self.compiled_loss(y, y_pred)
        self.compiled_metrics.update_state(y, y_pred)
        return {m.name: m.result() for m in self.metrics}

model = CustomModel(inputs, outputs)
model.compile(optimizer='adam', loss='...', metrics=['accuracy'])
model.fit(dataset, epochs=10)
08

Callbacks

EarlyStopping

EarlyStopping stoppt das Training, wenn die beobachtete Metrik aufhört sich zu verbessern — spart Zeit und verhindert Overfitting. patience=N wartet N Epochen ohne Verbesserung, bevor gestoppt wird. restore_best_weights=True rollt am Ende auf die beste Epoche zurück — ohne behältst du die (möglicherweise schlechteren) Endgewichte. mode='min' für Verluste, 'max' für Genauigkeit. Immer eine großzügige Max-Epochenzahl setzen und den Callback entscheiden lassen.

tensorflow
import tensorflow as tf

early = tf.keras.callbacks.EarlyStopping(
    monitor='val_loss', min_delta=0.001, patience=5,
    mode='auto', restore_best_weights=True, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[early])

ModelCheckpoint

ModelCheckpoint speichert das Modell während des Trainings, sodass du nach Crashes wiederherstellen oder die beste Epoche wählen kannst. save_best_only=True behält nur den besten Checkpoint (nach monitor-Metrik) — monitor auf deine val-Metrik setzen. save_weights_only=True ist kleiner und architekturagnostisch, aber du brauchst die Modellklasse zum Neuladen. Format-Platzhalter wie {epoch:02d} betten die Epochennummer in den Dateinamen ein. save_freq='epoch' ist der Standard; eine Ganzzahl N speichert alle N Batches.

tensorflow
import tensorflow as tf

ckpt = tf.keras.callbacks.ModelCheckpoint(
    filepath='checkpoints/epoch-{epoch:02d}-val-{val_loss:.3f}.keras',
    monitor='val_loss', save_best_only=True, save_weights_only=False,
    mode='min', save_freq='epoch', verbose=1,
)

ckpt = tf.keras.callbacks.ModelCheckpoint(
    'weights.{epoch:02d}.h5', save_weights_only=True, save_freq='epoch',
)

model.fit(train_ds, validation_data=val_ds, epochs=50, callbacks=[ckpt])

ReduceLROnPlateau

ReduceLROnPlateau senkt die LR, wenn die beobachtete Metrik ein Plateau erreicht — nützlich, wenn man den richtigen Schedule nicht vorab kennt. factor ist der Multiplikator (0.5 = halbieren), patience die Warteepochen, min_lr die Untergrenze. cooldown pausiert das Monitoring direkt nach einer Senkung, damit sich die neue LR setzt. Mit EarlyStopping kombinieren: zuerst die LR senken, dann stoppen, wenn keine weitere Verbesserung kommt. verbose=1 druckt jede Senkung.

tensorflow
import tensorflow as tf

reduce = tf.keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss', factor=0.5, patience=3, min_lr=1e-7,
    mode='min', min_delta=1e-4, cooldown=0, verbose=1,
)

model.fit(train_ds, validation_data=val_ds, epochs=100, callbacks=[reduce])

TensorBoard-Callback

Der TensorBoard-Callback streamt Trainingsmetriken, Gewichtshistogramme, den Modellgraphen und Profiling-Daten in log_dir während fit. histogram_freq=1 loggt Gewichtsverteilungen pro Epoche — auf 0 setzen, um Platz zu sparen. profile_batch=2 lässt den TF-Profiler auf Batch 2 laufen, um Performance-Flaschenhälße zu identifizieren (Eingabepipeline, Op-Latenz). TensorBoard mit Verweis auf log_dir starten, um Charts zu sehen. Getrennte Unterverzeichnisse pro Experiment nutzen, um Läufe zu vergleichen.

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='./logs/fit', histogram_freq=1, write_graph=True,
    write_images=False, update_freq='epoch',
    profile_batch=2, embeddings_freq=0,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])
# launch: tensorboard --logdir=./logs

LearningRateScheduler

LearningRateScheduler nimmt eine Funktion von (epoch, lr) und wendet die neue LR zu jedem Epochenanfang an — einfach, aber nur pro Epoche. Für Schedules pro Schritt lieber ein LearningRateSchedule-Objekt an den Optimierer übergeben (siehe Optimierer-Sektion) — es wird bei jedem Batch aufgerufen und funktioniert innerhalb von tf.function. Die Callback-Form reicht für grobe Schedules. Für Warmup+Abfall ist ein Schedule-Objekt sauberer.

tensorflow
import tensorflow as tf

def schedule(epoch, lr):
    if epoch < 10:
        return lr
    return lr * tf.math.exp(-0.1).numpy()

scheduler = tf.keras.callbacks.LearningRateScheduler(schedule, verbose=1)

class StepScheduler(tf.keras.callbacks.Callback):
    def on_train_batch_begin(self, batch, logs=None):
        step = self.model.optimizer.iterations.numpy()
        new_lr = 1e-3 * (0.5 ** (step // 1000))
        self.model.optimizer.learning_rate.assign(new_lr)

scheduler = tf.keras.callbacks.LearningRateScheduler(
    lambda epoch: 1e-3 * 0.9 ** epoch)

Eigener Callback

Callbacks haken in den Trainingslebenszyklus ein: on_epoch_begin/end, on_train_batch_begin/end, on_test_*, on_predict_*. Auf das Modell via self.model zugreifen und auf den Optimierer via self.model.optimizer. logs ist ein Dict aktueller Metriken. Eigene Callbacks sind super fürs Logging, LR-Manipulation, frühe Beendigung (self.model.stop_training = True) oder die Synchronisation mit externen Systemen (W&B, MLflow). Billig halten — sie laufen bei jedem Batch.

tensorflow
import tensorflow as tf

class DebugCallback(tf.keras.callbacks.Callback):
    def on_epoch_end(self, epoch, logs=None):
        lr = self.model.optimizer.learning_rate
        if hasattr(lr, 'numpy'):
            lr = lr.numpy()
        print(f"Epoch {epoch}: lr={lr}, logs={logs}")

    def on_train_batch_end(self, batch, logs=None):
        if batch % 100 == 0:
            print(f"  batch {batch}: loss={logs.get('loss'):.4f}")

    def on_train_end(self, logs=None):
        print("Training finished!")

model.fit(train_ds, epochs=5, callbacks=[DebugCallback()])
09

tf.data-Pipeline

tf.data.Dataset

tf.data.Dataset ist die Streaming-Daten-API von TF — sie pipelined Daten effizient von Platte/CPU zur GPU. from_tensor_slices zipt Tensors entlang Achse 0. Die kanonische Kette ist shuffle -> batch -> prefetch: shuffle randomisiert, batch gruppiert, prefetch überlappt die Vorbereitung des nächsten Batch mit dem aktuellen Training. AUTOTUNE nutzen, damit TF die Prefetch-Buffer-Größen automatisch wählt.

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x_train, y_train))

def gen():
    for i in range(len(x_train)):
        yield x_train[i], y_train[i]
ds = tf.data.Dataset.from_generator(gen, output_signature=(
    tf.TensorSpec(shape=(28, 28), dtype=tf.float32),
    tf.TensorSpec(shape=(), dtype=tf.int32),
))

ds = ds.shuffle(10000).batch(32).prefetch(tf.data.AUTOTUNE)

for x, y in ds:
    print(x.shape, y.shape)
    break

Map, Filter & Cache

map wendet eine Funktion auf jedes Element an — Augmentation, Normalisierung, Tokenisierung. num_parallel_calls=AUTOTUNE parallelisiert über CPU-Kerne. cache() speichert den Datensatz im Speicher (oder in einer Datei), sodass nachfolgende Epochen die Quelle überspringen — riesiger Beschleuniger für kleine bis mittlere Daten, aber VOR den Zufalls-Ops cachen, sonst wiederholst du dieselben Augmentationen in jeder Epoche. Die kanonische Reihenfolge ist cache -> map(augment) -> shuffle -> batch -> prefetch.

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, 0.2)
    return image, label

ds = tf.data.Dataset.from_tensor_slices((images, labels))
ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)
ds = ds.map(lambda x, y: (tf.cast(x, tf.float32) / 255.0, y))
ds = ds.filter(lambda x, y: y < 10)

ds = ds.cache()                    # in memory
ds = ds.cache('/tmp/data.cache')   # to file

ds = ds.cache().shuffle(1000).batch(32).prefetch(tf.data.AUTOTUNE)

Batch, Shuffle & Repeat

shuffle nutzt einen Buffer der Größe N: Er füllt den Buffer, sampelt einen, füllt nach — ein Buffer >= Datensatzgröße liefert also echte Zufallsreihenfolge. shuffle -> repeat -> batch mischt jede Epoche neu. Fürs Training mit steps_per_epoch repeat() nutzen, damit der Datensatz nie ausgeht. drop_remainder=True verwirft den letzten kurzen Batch — wichtig für BatchNorm und Modelle fester Form. Ein Seed macht das Mischen nur über Iterationen hinweg reproduzierbar, wenn reshuffle_each_iteration=True mit demselben Seed gilt.

tensorflow
import tensorflow as tf

ds = tf.data.Dataset.from_tensor_slices((x, y))
ds = ds.batch(32, drop_remainder=False)
ds = ds.shuffle(buffer_size=10000, seed=42, reshuffle_each_iteration=True)
ds = ds.repeat()         # infinite
ds = ds.repeat(5)        # 5 epochs

# recommended order: shuffle -> repeat -> batch
ds = ds.shuffle(10000).repeat().batch(32)

Prefetch & Performance

prefetch(AUTOTUNE) ist der größte einzelne Gewinn — er lässt die CPU Batch N+1 vorbereiten, während die GPU auf Batch N trainiert, sodass keiner wartet. num_parallel_calls=AUTOTUNE auf map parallelisiert CPU-gebundene Vorverarbeitung. Die optimale Pipeline-Reihenfolge ist: Quelle -> cache -> shuffle -> map(augment) -> batch -> prefetch. tf.data.experimental.AUTOTUNE (dasselbe wie tf.data.AUTOTUNE) nutzen und TF die Buffer-Größen tunen lassen. Vor dem Optimieren immer profilieren — der Flaschenhals liegt oft woanders.

tensorflow
import tensorflow as tf

ds = ds.prefetch(tf.data.AUTOTUNE)
ds = ds.map(parse_fn, num_parallel_calls=tf.data.AUTOTUNE)

# full recommended pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32)
      .prefetch(tf.data.AUTOTUNE))

Dateien lesen

TextLineDataset streamt Zeilen aus Textdateien (Logs, CSV-Zeilen). make_csv_dataset parst CSVs mit automatischer Spaltentyp-Inferenz. image_dataset_from_directory ist das Keras-Äquivalent von PyTorchs ImageFolder — er leitet Labels aus Unterverzeichnisnamen ab und liefert (image_batch, label_batch). Für mehr Kontrolle über das Bildladen tf.io.read_file + tf.io.decode_image innerhalb einer map-Funktion nutzen. Den Datensatz immer batchen, bevor er an fit geht.

tensorflow
import tensorflow as tf

ds = tf.data.TextLineDataset(['file1.txt', 'file2.txt'])

ds = tf.data.experimental.make_csv_dataset(
    'data.csv', batch_size=32, label_name='label',
    num_epochs=1, shuffle_buffer_size=1000,
)

ds = tf.keras.utils.image_dataset_from_directory(
    'data/train', image_size=(224, 224), batch_size=32,
    shuffle=True, seed=42, validation_split=0.2, subset='training',
)

TFRecord

TFRecord ist TFs binäres Record-Format — der schnellste Weg, große Datensätze von der Platte zu speisen. Jeder Record ist ein serialisiertes tf.train.Example (ein Dict aus Features). Lesen ist sequenzielles I/O, viel schneller als wahlfreie Lesevorgänge auf Cloud-Storage (GCS/S3). Für Bilder rohe Bytes speichern und in map() dekodieren. tf.data.TFRecordDataset mit compression='GZIP' für kleinere Dateien nutzen. Sharding (mehrere .tfrecord-0000N-of-0000M-Dateien) ermöglicht paralleles Lesen.

tensorflow
import tensorflow as tf

def serialize(x, y):
    feature = {
        'x': tf.train.Feature(float_list=tf.train.FloatList(value=x.flatten())),
        'y': tf.train.Feature(int64_list=tf.train.Int64List(value=[y])),
    }
    return tf.train.Example(features=tf.train.Features(feature=feature)).SerializeToString()

with tf.io.TFRecordWriter('data.tfrecord') as w:
    for x, y in dataset:
        w.write(serialize(x, y))

def parse(serialized):
    feature = {'x': tf.io.FixedLenFeature([784], tf.float32),
               'y': tf.io.FixedLenFeature([], tf.int64)}
    parsed = tf.io.parse_single_example(serialized, feature)
    return parsed['x'], parsed['y']

ds = tf.data.TFRecordDataset('data.tfrecord').map(parse).batch(32)
10

Speichern & Laden

SavedModel-Format

SavedModel ist das produktionsreife Format: Es bündelt Architektur, Gewichte und einen getraceden Graphen, sodass das Modell in TF Serving, TFLite, TF.js oder C++ geladen werden kann, ohne den Original-Python-Code. tf.keras.models.load_model nutzen, um in Python neu zu laden. Eine input_signature übergeben, um die Serving-Signatur explizit zu definieren — für TF Serving Pflicht. SavedModel ist ein Verzeichnis, keine einzelne Datei.

tensorflow
import tensorflow as tf

model.save('saved_model')   # SavedModel directory
loaded = tf.keras.models.load_model('saved_model')
loaded.evaluate(x_test, y_test)

# export for serving (explicit signature)
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def serve(x):
    return {'outputs': model(x)}

tf.saved_model.save(model, 'serving_model', signatures=serve)

Keras-Format (.keras)

Das .keras-Format (Keras-3-Standard) ist eine einzelne gezippte Datei mit Architektur-Config, Gewichten und Optimiererzustand — leicht zu teilen und zu versionieren. .h5 ist das Legacy-HDF5-Format, weiterhin unterstützt, aber für neue Projekte nicht empfohlen. SavedModel (ein Verzeichnis) ist fürs Deployment Pflicht (TFLite, TF Serving). Bei eigenen Schichten speichert .keras die Config, sodass die Schicht neu gebaut werden kann — sicherstellen, dass get_config() korrekt ist.

tensorflow
import tensorflow as tf

model.save('model.keras')   # Keras 3 default
loaded = tf.keras.models.load_model('model.keras')

# legacy HDF5 format
model.save('model.h5')
loaded = tf.keras.models.load_model('model.h5')

# .keras  — Keras 3 default, supports custom layers via config
# .h5     — legacy, weights + architecture but limited custom layer support
# SavedModel — directory, best for deployment/serving

Nur Gewichte speichern & laden

save_weights speichert nur die Parameter-Tensors — viel kleiner als ein volles Modell und von der Architektur entkoppelt. Vor dem Laden das Modell mit derselben Struktur neu bauen. skip_mismatch=True (Keras 3) lädt nur passende Schichten — nützlich fürs Transfer Learning. Das Checkpoint-Format ('ckpt'-Präfix) erzeugt checkpoint/weights-of-ckpt-1.index-Dateien — TFs natives Checkpoint-Format, intern von fit-Callbacks genutzt.

tensorflow
import tensorflow as tf

model.save_weights('weights.keras')

model = build_model()   # must match the saved architecture
model.load_weights('weights.keras')

model.save_weights('weights.h5')
model.load_weights('weights.h5')

# load weights from one model into another (partial)
model.load_weights('weights.keras', skip_mismatch=True, by_name=True)

model.save_weights('ckpt')
model.load_weights('ckpt')

Checkpoint-Manager

Checkpoint + CheckpointManager geben dir volle Kontrolle über das Speichern in eigenen Trainingsschleifen — die letzten N Checkpoints behalten, den neuesten automatisch wiederherstellen und nach Schritt versionieren. expect_partial() unterdrückt Warnungen über nicht wiederhergestellte Slots (etwa Optimierer-Momentum für neue Variablen). Checkpoints speichern den Objektgraphen, nicht Klassendefinitionen — du brauchst weiterhin den Modellcode zum Wiederherstellen. CheckpointManager.max_to_keep=3 löscht alte Checkpoints automatisch.

tensorflow
import tensorflow as tf

ckpt = tf.train.Checkpoint(model=model, optimizer=optimizer, step=optimizer.iterations)
manager = tf.train.CheckpointManager(
    ckpt, directory='./ckpts', max_to_keep=3,
    checkpoint_name='step-{step}',
)

manager.save()
ckpt.restore(manager.latest_checkpoint).expect_partial()

# in a custom loop: save every N steps
if step % 1000 == 0:
    manager.save()

Mit eigenen Objekten laden

Beim Laden eines Modells mit eigenen Schichten, Verlusten oder Metriken muss Keras wissen, wie es sie rekonstruiert. Ein custom_objects-Dict übergeben, das Namen auf Klassen/Funktionen mappt. Für saubereren Code Klassen mit @register_keras_serializable dekorieren, damit sie global registriert sind und kein custom_objects brauchen. Sicherstellen, dass get_config alle Konstruktorargumente liefert, damit das Objekt exakt neu gebaut werden kann — Keras ruft intern from_config(config) auf.

tensorflow
import tensorflow as tf

class MyLayer(tf.keras.layers.Layer):
    ...

custom_objects = {'MyLayer': MyLayer, 'focal_loss': FocalLoss}

loaded = tf.keras.models.load_model(
    'model.keras', custom_objects=custom_objects,
)

# or register globally
@tf.keras.utils.register_keras_serializable(package='my_pkg')
class MyLayer(tf.keras.layers.Layer):
    ...

Fürs Serving exportieren

TF Serving erwartet versionierte Verzeichnisse (serving/1/, serving/2/), sodass es Modelle im Betrieb tauschen kann. Die Serving-Signatur definiert die Ein-/Ausgabe-Tensor-Namen und -Formen, die Clients nutzen. model.export() (Keras 3) wickelt das automatisch. Für eigene Vorverarbeitung das Modell in ein tf.Module wickeln und __call__ mit einer input_signature definieren, die die rohe Eingabe (z. B. uint8-Bild) einschließt und die endgültige Ausgabe liefert. Tensors benennen, damit Clients sie adressieren können.

tensorflow
import tensorflow as tf

# Keras 3 export API (recommended)
model.export('serving/1')

class ServingModule(tf.Module):
    def __init__(self, model):
        self.model = model
    @tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32, name='inputs')])
    def __call__(self, x):
        return {'outputs': self.model(x)}

module = ServingModule(model)
tf.saved_model.save(module, 'serving/1',
                    signatures={'serving_default': module.__call__})

loaded = tf.saved_model.load('serving/1')
print(list(loaded.signatures.keys()))   # ['serving_default']
11

CNN

Conv2D & Pooling

Der kanonische CNN-Block in Keras: Conv2D -> BatchNormalization -> ReLU -> MaxPooling. padding='same' hält die räumliche Größe bei Stride 1. GlobalAveragePooling2D kollabiert räumliche Dimensionen zu einem Vektor — parameter-effizienter als Flatten + Dense und weniger overfittingsanfällig. Keras nutzt standardmäßig NHWC (channels-last), die Input-Form ist also (H, W, C) ohne Batch-Dimension. Strided Convs können Pooling ersetzen für lernbares Downsampling.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 28 -> 14
    tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D(),                # 14 -> 7
    tf.keras.layers.Conv2D(128, 3, padding='same', activation='relu'),
    tf.keras.layers.GlobalAveragePooling2D(),      # (7,7,128) -> (128,)
    tf.keras.layers.Dense(10, activation='softmax'),
])
model.summary()

Ein CNN bauen

Ein VGG-artiges CNN mit verdoppelten Filtern pro Stufe (32 -> 64 -> 128) und halbierter räumlicher Größe via MaxPooling. Zwei Convs pro Stufe (VGG-Block) extrahieren reichhaltigere Features als einer. Rescaling im Modell macht es deploybar — rohe uint8-Bilder gehen direkt hinein. GlobalAveragePooling + Dropout regularisiert den Kopf. Mit sparse_categorical_crossentropy kompilieren, weil Labels ganzzahlige Klassenindizes sind.

tensorflow
import tensorflow as tf

inputs = tf.keras.Input(shape=(32, 32, 3))
x = tf.keras.layers.Rescaling(1./255)(inputs)

for filters in [32, 64, 128]:
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', activation='relu')(x)
    x = tf.keras.layers.MaxPooling2D()(x)
    x = tf.keras.layers.Dropout(0.25)(x)

x = tf.keras.layers.GlobalAveragePooling2D()(x)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Feature-Maps & Visualisierung

Ein Model mit derselben Eingabe, aber mehreren Ausgaben (die Conv-Schichtaktivierungen) erzeugen, um zu inspizieren, was jede Schicht lernt. Frühe Schichten erkennen Kanten/Farben, tiefere Texturen/Teile. Unbezahlbar zum Debuggen — tote Feature-Maps (durchgehend Nullen) deuten auf kaputte ReLUs oder Lernratenprobleme. Für Grad-CAM (Klassenaktivierungskarten) tf-keras-vis nutzen oder gradientengewichtete Klassenaktivierungen implementieren, um zu sehen, welche Regionen eine Vorhersage trieben.

tensorflow
import tensorflow as tf
import matplotlib.pyplot as plt

feature_model = tf.keras.Model(
    inputs=model.inputs,
    outputs=[layer.output for layer in model.layers if 'conv2d' in layer.name],
)

img = x_test[0:1]
features = feature_model.predict(img)
print([f.shape for f in features])

fig, axes = plt.subplots(4, 8, figsize=(12, 6))
for i, ax in enumerate(axes.flat):
    if i < features[0].shape[-1]:
        ax.imshow(features[0][0, :, :, i], cmap='viridis')
    ax.axis('off')

Vortrainierte CNN-Backbones

keras.applications exponiert ResNet, EfficientNet, MobileNet, ViT und mehr mit ImageNet-Gewichten. include_top=False wirft den 1000-Klassen-Kopf ab, sodass du deinen eigenen anhängen kannst. preprocess_input wendet die exakte Normalisierung an, mit der der Backbone trainiert wurde — im Modell aufrufen fürs Deployment. Den Backbone einfrieren (trainable=False) und training=False beim Aufruf setzen, damit BatchNorm Inferenzstatistiken nutzt — kritisch fürs Transfer Learning mit kleinen Datensätzen.

tensorflow
import tensorflow as tf

backbone = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
backbone.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = backbone(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Residual-Verbindungen

Residual-(Skip-)Verbindungen addieren die Eingabe zur Ausgabe eines Blocks und lassen Gradienten direkt zu früheren Schichten fließen — das ermöglicht das Training sehr tiefer Netze (ResNet). Der Shortcut muss zu Kanälen und räumlicher Größe der Ausgabe passen; bei Abweichung einen 1x1-Conv mit Stride nutzen. Add() verschmilzt die zwei Pfade. Die funktionale API (nicht Sequential) für jede Architektur mit Skip-Verbindungen nutzen. ResNet-50 stapelt viele solcher Blöcke.

tensorflow
import tensorflow as tf

def residual_block(x, filters, stride=1):
    shortcut = x
    x = tf.keras.layers.Conv2D(filters, 3, strides=stride, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.ReLU()(x)
    x = tf.keras.layers.Conv2D(filters, 3, padding='same', use_bias=False)(x)
    x = tf.keras.layers.BatchNormalization()(x)
    if stride != 1 or shortcut.shape[-1] != filters:
        shortcut = tf.keras.layers.Conv2D(filters, 1, strides=stride, use_bias=False)(shortcut)
        shortcut = tf.keras.layers.BatchNormalization()(shortcut)
    x = tf.keras.layers.Add()([x, shortcut])
    return tf.keras.layers.ReLU()(x)

inputs = tf.keras.Input(shape=(32, 32, 3))
x = residual_block(inputs, 64)
x = residual_block(x, 128, stride=2)
model = tf.keras.Model(inputs, x)

Detektions-Kopf

Detektionsköpfe sagen Boxen pro Anker oder pro Pixel plus Klassenwahrscheinlichkeiten voraus. Die funktionale API macht Mehr-Ausgabe-Modelle einfach: ein Dict benannter Tensors zurückgeben. Für echte Projekte die TensorFlow-Object-Detection-API oder KerasCV nutzen (Detektion, Segmentierung) — sie handhaben Anker-Matching, NMS und Evaluation. Einen vollen Detektor von Grund auf zu schreiben ist eine fortgeschrittene Übung: Box-Kodierung, IoU-Loss und Focal Loss sorgfältig behandeln.

tensorflow
import tensorflow as tf

# YOLO-style detection head: conv to (grid * grid * (5 + num_classes))
def detection_head(x, num_classes, num_anchors=3):
    out = tf.keras.layers.Conv2D(
        num_anchors * (5 + num_classes), 1, activation='linear')(x)
    return out

# anchor-free alternative: predict (cx, cy, w, h, obj, class_logits)
def center_net_head(features, num_classes):
    cls = tf.keras.layers.Conv2D(num_classes, 1, activation='sigmoid', name='cls')(features)
    wh = tf.keras.layers.Conv2D(2, 1, name='wh')(features)
    offset = tf.keras.layers.Conv2D(2, 1, name='offset')(features)
    return {'cls': cls, 'wh': wh, 'offset': offset}
12

RNN & LSTM

LSTM- & GRU-Schichten

Die Eingabeform von LSTM/GRU ist (batch, timesteps, features). return_sequences=False liefert die letzte Ausgabe (für Klassifikation); True die volle Sequenz (fürs Stapeln oder seq2seq). Bidirectional konkateniert Vorwärts- und Rückwärtsausgaben und verdoppelt die Feature-Größe. stateful=True trägt den Hidden State über Batches hinweg — nützlich für sehr lange, in Häppchen geteilte Sequenzen, verlangt aber fixe batch_size und manuelle Zustandsresets zwischen Epochen.

tensorflow
import tensorflow as tf

lstm = tf.keras.layers.LSTM(128, return_sequences=False)
x = tf.random.normal((4, 10, 64))
out = lstm(x)                       # (4, 128)

gru = tf.keras.layers.GRU(128)
out = gru(x)                        # (4, 128)

lstm = tf.keras.layers.LSTM(128, return_sequences=True)
out = lstm(x)                       # (4, 10, 128)

bi = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64))
out = bi(x)                         # (4, 128) — 64*2

lstm = tf.keras.layers.LSTM(64, stateful=True)

Gestapelte RNNs

RNNs stapeln, indem return_sequences=True auf allen LSTM/GRU außer dem letzten gesetzt wird. mask_zero=True in der Embedding-Schicht erzeugt eine Maske, die RNNs respektieren — sie überspringen gepaddete Positionen, sodass Sequenzen variabler Länge gebatcht werden können, ohne den Hidden State zu beeinflussen. Dropout zwischen RNN-Schichten regularisiert; recurrent_dropout innerhalb eines RNN ist langsamer (kein cuDNN) — Eingabe-Dropout bevorzugen. Für Textklassifikation ist dieses biLSTM eine starke Basislinie.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 128, input_length=100, mask_zero=True),
    tf.keras.layers.LSTM(128, return_sequences=True),
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.LSTM(64),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

Textklassifikation mit RNN

Ein Standard-Textklassifikator: Embedding -> biLSTM -> biLSTM -> Dense -> sigmoid. mask_zero=True ist kritisch — ohne verarbeitet das LSTM Padding-Tokens und verzerrt den Hidden State. Bidirectional verdoppelt die Repräsentationskraft, indem es die Sequenz in beide Richtungen liest. Für binäre Klassifikation sigmoid + binary_crossentropy nutzen. Bei langen Sequenzen (>500 Tokens) übertreffen Transformers LSTMs, brauchen aber mehr Daten und Rechenleistung.

tensorflow
import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(200,)),
    tf.keras.layers.Embedding(10000, 128, mask_zero=True),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64, return_sequences=True)),
    tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dropout(0.5),
    tf.keras.layers.Dense(1, activation='sigmoid'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='binary_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

Encoder-Decoder-Seq2Seq

Encoder-Decoder-LSTM für seq2seq (Übersetzung, Zusammenfassung). Der finale Hidden State des Encoders initialisiert den Decoder, der die Zielsequenz Token für Token erzeugt. Mit Teacher Forcing trainieren: die verschobene Zielsequenz als Decoder-Eingabe füttern. Zur Inferenz eine separate Schleife schreiben, die jedes vorhergesagte Token als nächste Eingabe zurückfüttert. Attention (Bahdanau/Luong) verbessert seq2seq dramatisch und ist der konzeptuelle Vorfahre der Transformers.

tensorflow
import tensorflow as tf

encoder_input = tf.keras.Input(shape=(None,), name='enc_in')
enc_emb = tf.keras.layers.Embedding(vocab_src, 128)(encoder_input)
encoder = tf.keras.layers.LSTM(256, return_state=True)
enc_out, state_h, state_c = encoder(enc_emb)

decoder_input = tf.keras.Input(shape=(None,), name='dec_in')
dec_emb = tf.keras.layers.Embedding(vocab_tgt, 128)(decoder_input)
decoder_lstm = tf.keras.layers.LSTM(256, return_sequences=True, return_state=True)
dec_out, _, _ = decoder_lstm(dec_emb, initial_state=[state_h, state_c])
decoder_dense = tf.keras.layers.Dense(vocab_tgt, activation='softmax')
outputs = decoder_dense(dec_out)

model = tf.keras.Model([encoder_input, decoder_input], outputs)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

Zeitreihen-Vorhersage

Für Zeitreihen (Eingabe, Ziel)-Paare mit Fenstern bauen: der letzte Wert jedes Fensters ist das Ziel, der Rest sind Eingaben. window(shift=1) erzeugt überlappende Fenster; drop_remainder hält sie gleich groß. LSTM lernt zeitliche Muster; ein abschließendes Dense(1) sagt den nächsten Wert voraus. Für Mehrschritt-Vorhersage einen Horizontvektor vorhersagen oder eine seq2seq-Architektur nutzen. Die Reihe immer nur mit Trainingsstatistiken standardisieren.

tensorflow
import tensorflow as tf

def make_dataset(series, window=20, batch=32):
    ds = tf.data.Dataset.from_tensor_slices(series)
    ds = ds.window(window + 1, shift=1, drop_remainder=True)
    ds = ds.flat_map(lambda w: w.batch(window + 1))
    ds = ds.map(lambda w: (w[:-1][..., tf.newaxis], w[-1:]))
    return ds.shuffle(1000).batch(batch).prefetch(tf.data.AUTOTUNE)

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(20, 1)),
    tf.keras.layers.LSTM(32, return_sequences=False),
    tf.keras.layers.Dense(1),
])
model.compile(optimizer='adam', loss='mse')
model.fit(make_dataset(train_series), epochs=10)

Attention-Mechanismus

Attention lässt den Decoder sich auf relevante Encoder-Zustände konzentrieren, statt auf einen einzigen festen Vektor zu bauen — eine große Verbesserung für lange Sequenzen. Bahdanau (additiv) und Luong (multiplikativ) sind die zwei klassischen Varianten. Keras liefert tf.keras.layers.AdditiveAttention und Attention als fertige Schichten. Attention ist die konzeptuelle Brücke zu Transformers: Multi-Head-Self-Attention ist nur Attention, angewendet auf dieselbe Sequenz.

tensorflow
import tensorflow as tf

class BahdanauAttention(tf.keras.layers.Layer):
    def __init__(self, units):
        super().__init__()
        self.W1 = tf.keras.layers.Dense(units)
        self.W2 = tf.keras.layers.Dense(units)
        self.V = tf.keras.layers.Dense(1)
    def call(self, query, values):
        q = tf.expand_dims(query, 1)
        scores = self.V(tf.nn.tanh(self.W1(values) + self.W2(q)))
        attn = tf.nn.softmax(scores, axis=1)
        context = tf.reduce_sum(attn * values, axis=1)
        return context, attn

attn = tf.keras.layers.AdditiveAttention()
context = attn([query, value])
13

Transformer

MultiHeadAttention

MultiHeadAttention ist die Kern-Transformer-Schicht — sie projiziert q/k/v in mehrere Köpfe, attendiert parallel und kombiniert neu. Für Self-Attention denselben Tensor als query, key und value übergeben. attention_mask kann eine kausale Maske (unteres Dreieck) fürs Dekodieren oder eine Padding-Maske sein (True = ignorieren). return_attention_scores=True liefert die Attention-Matrix zur Visualisierung. Die Ausgabedimension entspricht der Eingabedimension, Blöcke können also stapeln.

tensorflow
import tensorflow as tf

mha = tf.keras.layers.MultiHeadAttention(
    num_heads=8, key_dim=64, dropout=0.1, use_bias=True)

x = tf.random.normal((4, 10, 512))
out, attn_weights = mha(query=x, value=x, key=x,
                        return_attention_scores=True)
print(out.shape)          # (4, 10, 512)
print(attn_weights.shape) # (4, 8, 10, 10)

# causal mask (decoder self-attention)
mask = tf.linalg.band_part(tf.ones((10, 10)), -1, 0)
out = mha(query=x, value=x, key=x, attention_mask=mask)

# key padding mask (ignore pad positions)
padding = tf.cast(tokens == 0, tf.bool)[:, tf.newaxis, tf.newaxis, :]
out = mha(query=x, value=x, key=x, attention_mask=padding)

Transformer-Encoder-Block

Ein Transformer-Encoder-Block ist: Multi-Head-Self-Attention + add & norm + Feed-Forward (MLP) + add & norm. Pre-LN (Norm vor der Unterschicht) ist stabiler beim Training von Grund auf; Post-LN braucht Warmup. Die FFN ist ein 2-schichtiges MLP mit GELU, expandierend auf 'ff' Hidden Units und zurück auf 'dim'. N davon stapeln für einen vollen Encoder. epsilon=1e-6 in LayerNorm vermeidet Division durch Null bei kleinen Varianzen.

tensorflow
import tensorflow as tf

class TransformerBlock(tf.keras.layers.Layer):
    def __init__(self, dim=512, heads=8, ff=2048, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.att = tf.keras.layers.MultiHeadAttention(num_heads=heads, key_dim=dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop1 = tf.keras.layers.Dropout(dropout)
        self.drop2 = tf.keras.layers.Dropout(dropout)

    def call(self, x, training=False, mask=None):
        attn = self.att(x, x, x, attention_mask=mask)
        x = self.norm1(x + self.drop1(attn, training=training))
        ffn = self.ffn(x)
        return self.norm2(x + self.drop2(ffn, training=training))

Positional Encoding

Transformers sind permutationsinvariant — sie brauchen Positionsinformation, um die Tokenreihenfolge zu kennen. Sinusförmige Kodierungen ergänzen ein festes Muster basierend auf Position und Dimension; sie verallgemeinern auf längere Sequenzen als im Training gesehene. Das Positional Encoding zur Embedding-Ausgabe addieren. Alternativ gelernte Positionsembeddings nutzen (eine nach Position indizierte Embedding-Schicht) oder relative Positionskodierungen (genutzt in modernen Transformers wie T5). Für Bilder (ViT) ein lernbares Positionsembedding pro Patch ergänzen.

tensorflow
import tensorflow as tf
import numpy as np

class PositionalEncoding(tf.keras.layers.Layer):
    def __init__(self, max_len=5000, dim=512, **kwargs):
        super().__init__(**kwargs)
        pos = np.arange(max_len)[:, np.newaxis]
        i = np.arange(dim)[np.newaxis, :]
        angle = pos / np.power(10000, (2 * (i // 2)) / np.float32(dim))
        angle[:, 0::2] = np.sin(angle[:, 0::2])
        angle[:, 1::2] = np.cos(angle[:, 1::2])
        self.pos = tf.constant(angle[np.newaxis, ...], dtype=tf.float32)

    def call(self, x):
        return x + self.pos[:, :tf.shape(x)[1], :]

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 512),
    PositionalEncoding(max_len=200, dim=512),
    tf.keras.layers.Dropout(0.1),
])

Textklassifikations-Transformer

Ein Transformer-Textklassifikator von Grund auf: Embedding + Positional Encoding + N Encoder-Blöcke + globaler Durchschnittspool + Dense-Kopf. GlobalAveragePooling1D kollabiert die Sequenzdimension (für lernbare Aggregation ein CLS-Token nutzen). mask_zero=True propagiert eine Maske, die MultiHeadAttention respektiert — bei Bedarf manuell durchreichen. Für echtes NLP einen vortrainierten Transformer (BERT, T5) von HuggingFace nutzen — Training von Grund auf braucht riesige Datenmengen.

tensorflow
import tensorflow as tf

class TransformerEncoder(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, num_layers, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.blocks = [TransformerBlock(dim, heads, ff, dropout)
                       for _ in range(num_layers)]
    def call(self, x, training=False, mask=None):
        for block in self.blocks:
            x = block(x, training=training, mask=mask)
        return x

inputs = tf.keras.Input(shape=(200,))
x = tf.keras.layers.Embedding(10000, 128, mask_zero=True)(inputs)
x = PositionalEncoding(200, 128)(x)
x = TransformerEncoder(128, 4, 512, 4)(x)
x = tf.keras.layers.GlobalAveragePooling1D()(x)
x = tf.keras.layers.Dropout(0.3)(x)
outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
model = tf.keras.Model(inputs, outputs)

Vision-Transformer (ViT)

Ein Vision Transformer zerschneidet das Bild mit einem strided Conv2d (kernel=stride=patch_size) in Patches, behandelt Patches als Tokens, stellt ein CLS-Token voran, ergänzt Positionsembeddings und führt Transformer-Encoder-Blöcke aus. Der finale Hidden State des CLS-Tokens ist die globale Bildrepräsentation fürs Klassifizieren. Für echte Nutzung ein vortrainiertes ViT aus keras.applications oder HuggingFace laden — sie brauchen ImageNet-21k-Pretraining, um gut zu funktionieren. Patch-Größe 16 und dim 768 sind die ViT-Base-Defaults.

tensorflow
import tensorflow as tf

class ViTPatchEmbed(tf.keras.layers.Layer):
    def __init__(self, patch_size=16, dim=768, **kwargs):
        super().__init__(**kwargs)
        self.proj = tf.keras.layers.Conv2D(dim, patch_size, strides=patch_size)
    def call(self, x):
        x = self.proj(x)
        shape = tf.shape(x)
        x = tf.reshape(x, [shape[0], -1, x.shape[-1]])
        return x

inputs = tf.keras.Input(shape=(224, 224, 3))
x = ViTPatchEmbed(16, 768)(inputs)
x = x + tf.Variable(tf.random.normal((1, 196, 768)))
cls = tf.Variable(tf.random.normal((1, 1, 768)))
x = tf.keras.layers.Concatenate(axis=1)([cls, x])
for _ in range(6):
    x = TransformerBlock(768, 12, 3072, 0.1)(x)
x = tf.keras.layers.Lambda(lambda t: t[:, 0])(x)
outputs = tf.keras.layers.Dense(10, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Transformer-Decoder

Ein Decoder-Block hat drei Unterschichten: maskierte Self-Attention (kausale Maske, Position t kann die Zukunft nicht sehen), Cross-Attention (query vom Decoder, key/value von der Encoder-Ausgabe) und eine FFN. Jede Unterschicht hat ein Residual + LayerNorm. Cross-Attention ist, was den Decoder 'zurückschauen' auf die Quellsequenz lässt. Bei Decoder-only-Modellen (GPT) die Cross-Attention-Unterschicht weglassen. N Blöcke stapeln für einen vollen Decoder. Die Inferenz braucht eine autoregressive Schleife, die vorhergesagte Tokens zurückfüttert.

tensorflow
import tensorflow as tf

class DecoderBlock(tf.keras.layers.Layer):
    def __init__(self, dim, heads, ff, dropout=0.1, **kwargs):
        super().__init__(**kwargs)
        self.self_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.cross_att = tf.keras.layers.MultiHeadAttention(heads, dim // heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(ff, activation='gelu'),
            tf.keras.layers.Dense(dim),
        ])
        self.norm1 = self.norm2 = self.norm3 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.drop = tf.keras.layers.Dropout(dropout)

    def call(self, x, enc_out, training=False, causal_mask=None, padding_mask=None):
        attn = self.self_att(x, x, x, attention_mask=causal_mask)
        x = self.norm1(x + self.drop(attn, training=training))
        cross = self.cross_att(query=x, value=enc_out, key=enc_out, attention_mask=padding_mask)
        x = self.norm2(x + self.drop(cross, training=training))
        x = self.norm3(x + self.drop(self.ffn(x), training=training))
        return x
14

TensorBoard

Setup & Callback

Der TensorBoard-Callback streamt Metriken, Graphen und Profiling-Daten während fit in log_dir. histogram_freq=1 loggt Gewichtsverteilungen pro Epoche — auf 0 setzen, um Platz zu sparen. profile_batch=2 lässt den TF-Profiler auf diesem Batch laufen, um Flaschenhälße zu identifizieren (Eingabepipeline, Op-Latenz, Speicher). Getrennte Unterverzeichnisse pro Experiment nutzen (logs/exp1, logs/exp2), sodass TensorBoard sie überlagert — perfekt für Hyperparameter-Sweeps. Starten mit `tensorboard --logdir=logs`.

tensorflow
import tensorflow as tf

tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/experiment_1', histogram_freq=1,
    write_graph=True, profile_batch=2,
)

model.fit(train_ds, validation_data=val_ds, epochs=10, callbacks=[tb])

# launch tensorboard
# tensorboard --logdir=logs

import datetime
log_dir = 'logs/fit/' + datetime.datetime.now().strftime('%Y%m%d-%H%M%S')

Eigene Skalare (Summary-Writer)

tf.summary.create_file_writer gibt dir ein niedrigstufiges Handle, um in eigenen Trainingsschleifen eigene Skalare zu loggen. writer.as_default() und tf.summary.scalar(name, value, step=step) zum Schreiben nutzen. Der Schritt muss eine Ganzzahl sein (meist der Iterationszähler des Optimierers). Periodisch spülen, damit Events die Platte erreichen. Namensräume nutzen (train/loss, val/loss), um Charts in der TensorBoard-UI zu organisieren. LR, Gradient-Normen und jede eigene Metrik loggen, die dich interessiert.

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/custom')

with writer.as_default():
    tf.summary.scalar('train/loss', loss, step=step)
    tf.summary.scalar('train/lr', lr, step=step)
    tf.summary.scalar('val/accuracy', acc, step=step)
    tf.summary.text('config', 'lr=1e-3, batch=32', step=0)
    writer.flush()

# in a custom training loop
for step, (x, y) in enumerate(train_ds):
    # ... train step ...
    if step % 100 == 0:
        with writer.as_default():
            tf.summary.scalar('loss', loss, step=step)

Bilder & Histogramme

tf.summary.image loggt Bilder für visuelle QA — Form (B, H, W, C) übergeben mit B bis max_outputs. Histogramme zeigen Gewichts- und Gradientenverteilungen über die Zeit; plötzliche Spitzen deuten auf Instabilität. Pro Epoche ein paar Validierungsstichproben loggen, um qualitativen Fortschritt zu sehen, nicht nur skalare Metriken. Audio ist nützlich für Sprachmodelle. Alle Summaries nehmen ein step-Argument, das zur x-Achse in TensorBoard wird. Logging billig halten, indem alle N Schritte gesampelt wird.

tensorflow
import tensorflow as tf

writer = tf.summary.create_file_writer('logs/viz')

with writer.as_default():
    tf.summary.image('sample', img[None, ...], step=step)
    tf.summary.image('batch', images[:8], step=step, max_outputs=8)
    for var in model.trainable_variables:
        tf.summary.histogram('weights/' + var.name, var, step=step)
    tf.summary.audio('waveform', audio[None, ...], sample_rate=16000, step=step)
    writer.flush()

Hyperparameter-Tuning

Das HParams-Plugin organisiert Hyperparameter-Sweeps in TensorBoard — eine Tabellenansicht erlaubt es, Läufe zu filtern und die beste Konfiguration zu finden. HParam-Objekte mit Bereichen/diskreten Werten definieren, eine Konfiguration einmal mit hp.hparams_config loggen, dann pro Lauf hp.hparams(hparams) plus die finale Metrik loggen. Für ernsthafte Sweeps KerasTuner nutzen (RandomSearch, Hyperband, BayesianOptimization), das die Suche automatisiert und in TensorBoard integriert.

tensorflow
import tensorflow as tf
# from tensorboard.plugins.hparams import api as hp
# (run: pip install tensorboard-plugin-hparams)

HP_LR = hp.HParam('lr', hp.RealInterval(1e-4, 1e-2))
HP_DROPOUT = hp.HParam('dropout', hp.Discrete([0.1, 0.3, 0.5]))
METRIC_ACC = 'accuracy'

with tf.summary.create_file_writer('logs/hparam_tuning').as_default():
    hp.hparams_config(hparams=[HP_LR, HP_DROPOUT], metrics=[hp.Metric(METRIC_ACC)])

for lr in [1e-3, 5e-3]:
    for dropout in [0.1, 0.3]:
        hparams = {HP_LR: lr, HP_DROPOUT: dropout}
        run_name = f"lr-{lr}-drop-{dropout}"
        with tf.summary.create_file_writer('logs/hparam_tuning/' + run_name).as_default():
            hp.hparams(hparams)
            acc = train(hparams)
            tf.summary.scalar(METRIC_ACC, acc, step=1)

Performance-Profiling

Der TF-Profiler zeigt, wohin die Zeit fließt: pro Op, pro Gerät und in der Eingabepipeline. profile_batch='10,20' profiliert Batches 10-20 (die ersten überspringen, damit das Warmup erledigt ist). Die Übersichtsseite liefert umsetzbare Empfehlungen (z. B. 'die Eingabepipeline ist der Flaschenhals'). Der Memory Viewer zeigt Spitzen und welche Tensors dominieren. Der Trace Viewer ist eine Chrome-artige Zeitachse für Tiefenbohrungen. Immer auf der Zielhardware profilieren — CPU- und GPU-Flaschenhälße unterscheiden sich.

tensorflow
import tensorflow as tf

# profile via callback
tb = tf.keras.callbacks.TensorBoard(
    log_dir='logs/profile', profile_batch='10,20',
)

# or use the Profiler API directly
tf.profiler.experimental.start('logs/profile')
# ... run a few batches ...
tf.profiler.experimental.stop()

# in TensorBoard, open the Profile tab to see:
# - op-level time breakdown
# - input pipeline analysis (tf.data bottleneck)
# - memory viewer
# - overview page with recommendations
15

GPU-/TPU-Training

GPU-Erkennung & Speicher

Standardmäßig greift TF beim Start den ganzen GPU-Speicher und blockiert andere Prozesse. set_memory_growth(True) allokiert nur das Nötige — essenziell, um eine GPU zu teilen. set_logical_device_configuration begrenzt den Speicher oder splittet eine GPU in mehrere logische Geräte (nützlich, um Multi-GPU-Code auf einer GPU zu testen). tf.device('/GPU:1') platziert Ops auf einem bestimmten Gerät. CPU-Ops laufen auf '/CPU:0'. Falsche Geräteplatzierung verursacht implizite Kopien, die die Performance schädigen.

tensorflow
import tensorflow as tf

gpus = tf.config.list_physical_devices('GPU')
print('GPUs:', gpus)

# set memory growth (don't grab all GPU memory at start)
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

# or limit GPU memory explicitly
tf.config.set_logical_device_configuration(
    gpus[0],
    [tf.config.LogicalDeviceConfiguration(memory_limit=4096)],
)

with tf.device('/GPU:1'):
    x = tf.random.normal((1000, 1000))
    y = tf.matmul(x, x)

Verteilungsstrategie

Verteilungsstrategien abstrahieren die Gerätetopologie weg. MirroredStrategy ist für Multi-GPU auf einer Maschine (spiegelt Variablen über GPUs, all-reduziert Gradienten) — der einfachste Multi-GPU-Weg. MultiWorkerMirroredStrategy erweitert auf mehrere Maschinen. TPUStrategy läuft auf Google-TPUs (Colab/Cloud). Die Modellerzeugung immer innerhalb strategy.scope() vornehmen, damit Variablen korrekt gespiegelt werden. Derselbe fit/predict-Code funktioniert über Strategien hinweg.

tensorflow
import tensorflow as tf

strategy = tf.distribute.OneDeviceStrategy(device='/gpu:0')
strategy = tf.distribute.MirroredStrategy()
print('num replicas:', strategy.num_replicas_in_sync)

# TPU
resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
tf.config.experimental_connect_to_cluster(resolver)
tf.tpu.experimental.initialize_tpu_system(resolver)
strategy = tf.distribute.TPUStrategy(resolver)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='...', metrics=['accuracy'])

model.fit(train_ds, epochs=10)

Multi-GPU-Training

MirroredStrategy spiegelt Modellvariablen auf jeder GPU und teilt jeden Batch über Replicas — die effektive Batch-Größe ist global_batch (z. B. 64 pro GPU * 4 GPUs = 256). Die globale Batch-Größe an den Datensatz übergeben; TF verteilt Shards automatisch. fit() handhabt das Gradient-All-Reduce unter der Haube. Für eigene Trainingsschleifen strategy.experimental_distribute_dataset und strategy.run(train_step) nutzen.

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()
print(f'using {strategy.num_replicas_in_sync} GPUs')

global_batch = 64 * strategy.num_replicas_in_sync
train_ds = make_dataset().batch(global_batch)

with strategy.scope():
    model = build_model()
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

model.fit(train_ds, epochs=10, validation_data=val_ds)

TPU-Training (Colab)

TPUs gibt es in Google Colab (Laufzeittyp ändern -> TPU) und in der Google Cloud. Das TPU-System einmal initialisieren, dann die Modellerzeugung in strategy.scope() wickeln. TPUs sind am schnellsten mit großen Batch-Größen (1024+) und fixen Formen — drop_remainder=True beim Batchen nutzen. TPUs können lokale Dateien nicht direkt lesen; Daten in den Speicher laden oder via tf.data von GCS streamen. Gemischte Präzision (bfloat16) bringt auf TPU einen großen Beschleuniger und braucht kein Loss Scaling.

tensorflow
import tensorflow as tf

try:
    resolver = tf.distribute.cluster_resolver.TPUClusterResolver()
    tf.config.experimental_connect_to_cluster(resolver)
    tf.tpu.experimental.initialize_tpu_system(resolver)
    strategy = tf.distribute.TPUStrategy(resolver)
    print('TPUs:', strategy.num_replicas_in_sync)
except ValueError:
    print('No TPU found')
    strategy = tf.distribute.get_strategy()

with strategy.scope():
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

model.fit(x_train, y_train, batch_size=1024, epochs=5)

Gemischte Präzision

Gemischte Präzision rechnet in float16/bfloat16, hält aber float32-Masterkopien — 2-3x Durchsatz auf Tensor-Core-GPUs (Volta+) und halber Speicher. 'mixed_float16' braucht Loss Scaling (Keras erledigt das automatisch via LossScaleOptimizer). 'mixed_bfloat16' hat denselben Bereich wie float32, braucht also kein Scaling, wird aber nur von Ampere+-GPUs und TPUs unterstützt. Die letzte Schicht auf float32 zwingen für numerische Stabilität (softmax/logits). Gemischte Präzision ist der einfachste einzelne Performance-Gewinn.

tensorflow
import tensorflow as tf

tf.keras.mixed_precision.set_global_policy('mixed_float16')
# or bfloat16 on Ampere+ / TPU (no loss scaling needed)
tf.keras.mixed_precision.set_global_policy('mixed_bfloat16')

model = tf.keras.Sequential([
    tf.keras.layers.Dense(512, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(10, dtype='float32'),
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
print(model.layers[0].dtype_policy)   # <Policy "mixed_float16">
16

Datenaugmentation

Keras-Vorverarbeitungsschichten

Keras-Vorverarbeitungsschichten (RandomFlip, RandomRotation usw.) laufen auf GPU und innerhalb von tf.function — weit schneller als PIL/numpy-Augmentation. Im Modell bedeutet das, dass sie zur Inferenz automatisch deaktiviert sind (training=False). Alternativ in einem tf.data map anwenden für mehr Kontrolle. Diese Schichten sind zustandslos und JIT-kompilieren, sie verlangsamen die Inferenz also nicht. Für zustandsbehaftete Vorverarbeitung (etwa gefittete Scaler) die Adapt-API nutzen.

tensorflow
import tensorflow as tf

augment = tf.keras.Sequential([
    tf.keras.layers.RandomFlip('horizontal'),
    tf.keras.layers.RandomRotation(0.1),
    tf.keras.layers.RandomZoom(0.1),
    tf.keras.layers.RandomContrast(0.2),
    tf.keras.layers.RandomTranslation(0.1, 0.1),
])

# put augmentation INSIDE the model (training-only, inactive at inference)
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.layers.Rescaling(1./255),
    augment,
    tf.keras.layers.Conv2D(32, 3, activation='relu'),
])

# or apply via dataset.map
ds = ds.map(lambda x, y: (augment(x, training=True), y))

ImageDataGenerator (Legacy)

ImageDataGenerator ist die Legacy-Augmentations-API — er funktioniert, läuft aber auf CPU und ist langsamer als Keras-Vorverarbeitungsschichten. Nur nutzen, wenn du seine Verzeichnis-Iterations-Bequemlichkeit oder Legacy-Code brauchst. Für neue Projekte keras.utils.image_dataset_from_directory + Keras-Vorverarbeitungsschichten bevorzugen (RandomFlip usw.) — GPU-beschleunigt und in tf.data integriert. flow_from_directory leitet Klassenlabels aus Unterverzeichnisnamen ab wie ImageFolder.

tensorflow
from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(
    rescale=1./255, rotation_range=20,
    width_shift_range=0.2, height_shift_range=0.2,
    shear_range=0.2, zoom_range=0.2,
    horizontal_flip=True, fill_mode='nearest',
    validation_split=0.2,
)

train_gen = train_datagen.flow_from_directory(
    'data/train', target_size=(224, 224), batch_size=32,
    class_mode='binary', subset='training',
)

model.fit(train_gen, epochs=10)

Bildaugmentations-Ops

tf.image.*-Ops geben feingranulare Kontrolle für eigene Augmentation. random_brightness/contrast/saturation/hue ändern Farbe ohne Geometrie. Cutout und Mixup sind fortgeschrittene Augmentationen, die Regularisierung verbessern; mit tf.image-Ops + tf.tensor_scatter_nd_update implementieren. Augmentation in einem tf.data map mit num_parallel_calls=AUTOTUNE anwenden, sodass sie auf CPU-Workern läuft und die GPU nie blockiert. Nach Farb-Jitter immer auf gültige Pixelbereiche zurückclippen.

tensorflow
import tensorflow as tf

def augment(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.2)
    image = tf.image.random_contrast(image, lower=0.8, upper=1.2)
    image = tf.image.random_saturation(image, lower=0.8, upper=1.2)
    image = tf.image.random_hue(image, max_delta=0.1)
    image = tf.clip_by_value(image, 0.0, 1.0)
    return image, label

ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)

Mixup & CutMix

Mixup blendt zwei Bilder und ihre Labels linear und erzeugt virtuelle Beispiele zwischen Klassen — starke Regularisierung, die Overfitting senkt und die Kalibrierung verbessert. CutMix klebt ein rechteckiges Patch von einem Bild auf ein anderes und erhält lokale Struktur besser als Mixup. Beide brauchen einen Loss, der weiche (gemischte) Labels akzeptiert — categorical_crossentropy, nicht sparse. Pro Batch nach dem Batchen anwenden. Mit Standard-geometrischer Augmentation kombinieren für beste Ergebnisse.

tensorflow
import tensorflow as tf

def mixup(images, labels, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    batch_size = tf.shape(images)[0]
    idx = tf.random.shuffle(tf.range(batch_size))
    mixed_images = lam * images + (1 - lam) * tf.gather(images, idx)
    mixed_labels = lam * labels + (1 - lam) * tf.gather(labels, idx)
    return mixed_images, mixed_labels

ds = ds.batch(32).map(mixup, num_parallel_calls=tf.data.AUTOTUNE)

Text- & Tabellen-Augmentation

Für Text sind einfache Wortebenen-Augmentationen (Synonym-Tausch, zufälliges Löschen/Tauschen) billig und wirksam; für ernsthaftes NLP Back-Translation oder Modelle wie EDA/AugBERT nutzen. Für Tabellendaten mischt mixup Zeilen; Gaußsches Rauschen auf numerischen Features regularisiert. Augmentation immer nur auf Trainingsdaten anwenden, nie auf Validierung/Test. Augmentationen label-erhaltend halten (oder label-mischend wie mixup) — Labels zu korrumpieren schadet mehr, als es nützt.

tensorflow
import tensorflow as tf
import random

def text_augment(text):
    words = text.split()
    if random.random() < 0.2:
        words = [w for w in words if random.random() > 0.2]
    if len(words) > 1 and random.random() < 0.2:
        i, j = random.sample(range(len(words)), 2)
        words[i], words[j] = words[j], words[i]
    return ' '.join(words)

def tabular_mixup(x, y, alpha=0.2):
    lam = tf.random.beta([], alpha, alpha)
    idx = tf.random.shuffle(tf.range(tf.shape(x)[0]))
    return lam * x + (1 - lam) * tf.gather(x, idx), lam * y + (1 - lam) * tf.gather(y, idx)

def add_noise(x, std=0.01):
    return x + tf.random.normal(tf.shape(x), stddev=std)
17

Transfer Learning

Vortrainierte Modelle

keras.applications exponiert ResNet, EfficientNet, MobileNet, ViT und mehr mit ImageNet-Gewichten. include_top=False wirft den 1000-Klassen-Kopf ab, sodass du deinen eigenen anhängen kannst. preprocess_input wendet die exakte Normalisierung an, die der Backbone erwartet — im Modell aufrufen fürs Deployment. Den Backbone einfrieren (trainable=False) und base(x, training=False) aufrufen, damit BatchNorm Inferenzstatistiken nutzt — kritisch bei kleinen Datensätzen, wo BN-Statistiken sonst verrauscht wären.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(
    include_top=False, weights='imagenet',
    input_shape=(224, 224, 3), pooling='avg',
)
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
x = base(x, training=False)
x = tf.keras.layers.Dense(256, activation='relu')(x)
x = tf.keras.layers.Dropout(0.5)(x)
outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
model = tf.keras.Model(inputs, outputs)

Feature-Extraktion

Feature-Extraktion friert den ganzen Backbone ein und trainiert nur einen neuen Kopf — die schnellste Transfer-Learning-Basislinie. Weil der Backbone fix ist, lassen sich Features einmal vorberechnen (base.predict(train_ds)) und ein winziger Klassifikator darauf trainieren — riesige Rechenersparnis. training=False setzen beim Aufruf des Backbones, damit BatchNorm Laufstatistiken nutzt — sonst korrumpieren kleine Batches sie. Gut für kleine Datensätze (hunderte Bilder), wo Feintuning overfitten würde.

tensorflow
import tensorflow as tf

base = tf.keras.applications.MobileNetV2(
    include_top=False, weights='imagenet', pooling='avg')
base.trainable = False

model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(224, 224, 3)),
    tf.keras.applications.mobilenet_v2.preprocess_input,
    base,
    tf.keras.layers.Dropout(0.3),
    tf.keras.layers.Dense(num_classes, activation='softmax'),
])

model.compile(optimizer=tf.keras.optimizers.Adam(1e-3),
              loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(train_ds, validation_data=val_ds, epochs=5)

Feintuning

Feintuning gibt einige Backbone-Schichten frei und trainiert sie mit kleiner LR, damit vortrainierte Features sich an deine Aufgabe anpassen. Immer zuerst Feature-Extraktion (nur Kopf) für ein paar Epochen, DANN freigeben — sonst zerstören die großen Gradienten des zufälligen Kopfs die vortrainierten Features. Eine viel kleinere LR nutzen (1e-5 vs. 1e-3 für den Kopf). Von oben nach unten freigeben (spätere Schichten sind aufgabenspezifischer; frühere allgemeiner). BatchNorm-Schichten eingefroren lassen, um ihre Laufstatistiken zu erhalten.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet', pooling='avg')
base.trainable = True

# freeze everything except the last few blocks
for layer in base.layers[:-20]:
    layer.trainable = False

model.compile(
    optimizer=tf.keras.optimizers.Adam(1e-5),   # 10x smaller than head
    loss='sparse_categorical_crossentropy', metrics=['accuracy'],
)
model.fit(train_ds, validation_data=val_ds, epochs=5)

Einfrieren & Freigeben

layer.trainable=False setzen, um ihn einzufrieren. Nach dem Ändern von trainable das Modell MUSST du neu kompilieren, damit der Optimierer die neue trainierbare Menge aufnimmt. BatchNorm-Schichten während des Feintunings eingefroren lassen — ihre Laufstatistiken sind kostbar und kleine Feintuning-Batches würden sie korrumpieren. trainable_weights vs. weights inspizieren, um zu bestätigen, was aktualisiert wird. Die Anzahl trainierbarer Parameter loggen, damit du nicht versehentlich alles ein- oder freigibst (ein häufiger stiller Bug).

tensorflow
import tensorflow as tf

base = tf.keras.applications.EfficientNetB0(
    include_top=False, weights='imagenet', pooling='avg')

base.trainable = False
for layer in base.layers:
    layer.trainable = 'block7' in layer.name

# freeze BatchNorm specifically (recommended during fine-tuning)
for layer in base.layers:
    if isinstance(layer, tf.keras.layers.BatchNormalization):
        layer.trainable = False

n_train = sum(tf.keras.backend.count_params(w) for w in model.trainable_weights)
n_total = sum(tf.keras.backend.count_params(w) for w in model.weights)
print(f"trainable: {n_train:,} / {n_total:,}")

Multi-Task-Transfer

Multi-Task-Lernen teilt einen Backbone über verwandte Aufgaben hinweg, regularisiert die Repräsentation und spart Rechenleistung. Jeder Kopf ist ein kleiner Zweig der geteilten Features. In compile Verluste pro Ausgabe und loss_weights übergeben, um Aufgabengradienten auszubalancieren (Gewichte tunen, damit keine Aufgabe dominiert). Zur fit-Zeit Ziele als Dict übergeben, das den Ausgabenamenen entspricht. Multi-Task-Transfer ist mächtig, wenn eine Aufgabe viele Daten hat und eine andere wenige — der geteilte Backbone nützt beiden.

tensorflow
import tensorflow as tf

base = tf.keras.applications.ResNet50(include_top=False, weights='imagenet')
base.trainable = False

inputs = tf.keras.Input(shape=(224, 224, 3))
x = tf.keras.applications.resnet50.preprocess_input(inputs)
features = base(x, training=False)
features = tf.keras.layers.GlobalAveragePooling2D()(features)

cls_out = tf.keras.layers.Dense(num_classes, activation='softmax', name='cls')(features)
box_out = tf.keras.layers.Dense(4, name='box')(features)
attr_out = tf.keras.layers.Dense(num_attr, activation='sigmoid', name='attr')(features)

model = tf.keras.Model(inputs, [cls_out, box_out, attr_out])
model.compile(
    optimizer='adam',
    loss={'cls': 'sparse_categorical_crossentropy', 'box': 'mse',
          'attr': 'binary_crossentropy'},
    loss_weights={'cls': 1.0, 'box': 5.0, 'attr': 0.5},
)
18

Modell-Deployment

TFLite-Konverter

TFLite konvertiert TF-Modelle in ein Flatbuffer-Format für Mobilgeräte, Embedded und Edge. Optimize.DEFAULT wendet automatisch Quantisierung nach dem Training an; volle int8-Quantisierung braucht einen repräsentativen Datensatz, um Aktivierungsbereiche zu kalibrieren, und liefert ein Modell, das auf Edge TPU/Mikrocontrollern läuft. float16 erhält GPU-Kompatibilität und ist sicherer, wenn int8 der Genauigkeit schadet. Der Konverter leitet Eingabeformen aus dem Modell ab; bei dynamischen Formen mit konkreten Funktionen fixieren.

tensorflow
import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

# with quantization (8-bit, ~4x smaller, faster on CPU)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# float16 quantization (GPU-friendly, 2x smaller)
converter.target_spec.supported_types = [tf.float16]
# full integer quantization (needs representative dataset)
converter.representative_dataset = rep_data
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
tflite_quant = converter.convert()

TFLite-Interpreter

Der TFLite-Interpreter führt .tflite-Modelle auf CPU, GPU, Edge TPU oder Mikrocontrollern aus. allocate_tensors bereitet den Speicher anhand der fixen Eingabeform vor — mit resize_tensor_input für dynamische Formen umdimensionieren. set_tensor / invoke / get_tensor ist die Inferenzschleife. Für gebatchte Inferenz muss das Modell mit fixer Batch-Größe konvertiert sein oder resize_tensor_input nutzen. TFLite hat Python-, C++-, Java-, Swift- und JavaScript-Bindings — dieselbe .tflite-Datei läuft überall.

tensorflow
import tensorflow as tf
import numpy as np

interpreter = tf.lite.Interpreter(model_path='model.tflite')
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
print(input_details)
# [{'name': 'input', 'shape': (1, 224, 224, 3), 'dtype': tf.float32, ...}]

input_data = np.expand_dims(img, axis=0).astype(np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])
print(output.shape, output.argmax())

TF Serving

TF Serving hostet SavedModels hinter einer gRPC-/REST-API mit Versionierung, Batching und GPU-Unterstützung. Die Verzeichnisstruktur serving/1/, serving/2/ ermöglicht heiße Modellwechsel. Das Docker-Image ist das einfachste lokale Deployment; für Produktion Vertex AI, SageMaker oder KServe nutzen. TF Serving bündelt Requests automatisch, um die GPU-Auslastung zu maximieren. Die REST-API nutzt {instances: [...]} für Eingaben und liefert {predictions: [...]}; für benannte Ein-/Ausgaben den Parameter signature_name nutzen.

tensorflow
# save model in SavedModel format with versioning
# model.export('serving/1')  # Keras 3
tf.saved_model.save(model, 'serving/1')

# run TF Serving via Docker
# docker run -p 8501:8501 --name tfserving \
#   -v $(pwd)/serving:/models/my_model \
#   -e MODEL_NAME=my_model \
#   tensorflow/serving

# query via REST
import json, requests
data = json.dumps({'instances': x_test[:3].tolist()})
resp = requests.post(
    'http://localhost:8501/v1/models/my_model:predict',
    data=data, headers={'content-type': 'application/json'})
print(resp.json()['predictions'])

Quantisierungsbewusstes Training

Quantisierungsbewusstes Training (QAT) fügt während des Trainings Scheinquantisierungs-Ops ein, sodass sich das Modell an das Rundungsrauschen gewöhnt, das es bei int8-Inferenz sehen wird — das holt meist den Großteil der Genauigkeit zurück, den Quantisierung nach dem Training verliert. tfmot (tensorflow-model-optimization) nutzen, um ein trainiertes Modell zu umhüllen, ein paar Epochen feintunen, dann zu TFLite konvertieren. QAT ist essenziell, wenn int8-Quantisierung nach dem Training die Genauigkeit unter deine Schwelle drückt (z. B. EfficientNet, Objektdetektoren). Das resultierende TFLite-Modell läuft auf Edge TPU.

tensorflow
import tensorflow as tf
# (requires: pip install tensorflow-model-optimization)
import tensorflow_model_optimization as tfmot

model = tf.keras.applications.MobileNetV2(weights='imagenet')
annot_model = tfmot.quantization.keras.quantize_model(model)
annot_model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
annot_model.fit(train_ds, epochs=3)

converter = tf.lite.TFLiteConverter.from_keras_model(annot_model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_qat = converter.convert()

TF.js & Edge-Deployment

TF.js führt Modelle im Browser oder Node.js aus. Der Konverter wandelt SavedModel/.keras/.h5 in ein model.json + binäres Gewichtsverzeichnis um. Layers-Modelle unterstützen die Keras-API (fit, predict, sogar Training on the fly); Graph-Modelle sind kompatibler, aber weniger flexibel. Browser-Inferenz nutzt WebGL/WASM; Node.js kann CUDA nutzen. TF.js ist super für clientseitiges ML (kein Server-Round-Trip, Datenschutz, offline). Für Mobilgeräte TFLite bevorzugen (kleiner, schneller, Hardware-Beschleunigung).

tensorflow
# convert to TF.js format
# pip install tensorflowjs
# tensorflowjs_converter --input_format=keras model.keras tfjs_model/

# in JavaScript:
# import * as tf from '@tensorflow/tfjs';
# const model = await tf.loadLayersModel('tfjs_model/model.json');
# const out = model.predict(tf.tensor4d(img, [1, 224, 224, 3]));

# OR convert SavedModel -> TF.js
# tensorflowjs_converter \
#   --input_format=tf_saved_model \
#   --output_format=tfjs_graph_model \
#   saved_model/ tfjs_model/

# TF.js layers model: full Keras-like API in the browser
# TF.js graph model: lower-level, supports more ops

Inferenz-Optimierung

Für Low-Latency-Deployment Optimierungen stapeln: Pruning (kleine Gewichte auf Null setzen, komprimieren), Wissensdestillation (einen kleinen Studenten trainieren, der den Logits eines großen Lehrers entspricht), Quantisierung (int8/float16) und XLA-Kompilierung (Ops verschmelzen). Jeder Schritt hat Trade-offs — immer auf der Zielhardware benchmarken. Destillation erhält die Genauigkeit meist am besten; Pruning+Quantisierung bringen die größten Größenreduktionen. XLA (jit_compile=True) verschmilzt Ops für einen kostenlosen 1,2-2x-Beschleuniger auf GPU/TPU.

tensorflow
import tensorflow as tf

# knowledge distillation: train a small student to mimic a large teacher
def distill_loss(teacher_logits, student_logits, temperature=3.0):
    soft_targets = tf.nn.softmax(teacher_logits / temperature)
    soft_probs = tf.nn.log_softmax(student_logits / temperature)
    return tf.reduce_mean(
        tf.keras.losses.categorical_crossentropy(soft_targets, soft_probs, from_logits=True))

# XLA compilation (faster inference)
@tf.function(jit_compile=True)
def predict(x):
    return model(x)

# stack optimizations: prune + quantize + distill + XLA
# always benchmark latency and accuracy before/after each step
19

Eigene Trainingsschleife

Einfache eigene Schleife

Eine eigene Schleife gibt dir volle Kontrolle: Gradientenmanipulation, mehrere Modelle, eigene Ziele. Das Muster ist GradientTape -> loss -> grads -> apply_gradients, in @tf.function gewickelt für Tempo. model.losses nicht vergessen — das sind die Regularisierungsverluste aus kernel_regularizer, die zum Hauptverlust addiert werden sollten. Metriken mit zustandsbehafteten Metric-Objekten tracken und reset_state() bei jeder Epoche aufrufen. Ausführlicher als fit, schaltet aber alles frei.

tensorflow
import tensorflow as tf

optimizer = tf.keras.optimizers.Adam(1e-3)
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_loss = tf.keras.metrics.Mean(name='train_loss')
train_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='train_acc')

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits)
        loss += sum(model.losses)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    train_loss.update_state(loss)
    train_acc.update_state(y, logits)
    return loss

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    print(f"epoch {epoch}: loss={train_loss.result():.4f} acc={train_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()

Validierung in der eigenen Schleife

Validierung spiegelt das Training wider, aber mit training=False (Dropout aus, BatchNorm nutzt Laufstatistiken) und ohne Gradient Tape oder Optimierer. Separate Metric-Objekte für val nutzen, damit train und val sich nicht mischen. test_step in @tf.function wickeln für Tempo. Alle Metriken nach dem Logging jeder Epoche zurücksetzen. Um das beste Modell zu speichern, val_acc.result() mit dem laufenden Bestwert vergleichen und model.save() aufrufen, wenn er sich verbessert.

tensorflow
import tensorflow as tf

val_loss = tf.keras.metrics.Mean(name='val_loss')
val_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='val_acc')

@tf.function
def test_step(x, y):
    logits = model(x, training=False)
    loss = loss_fn(y, logits)
    val_loss.update_state(loss)
    val_acc.update_state(y, logits)

for epoch in range(epochs):
    for x, y in train_ds:
        train_step(x, y)
    for x, y in val_ds:
        test_step(x, y)
    print(f"epoch {epoch}: val_loss={val_loss.result():.4f} val_acc={val_acc.result():.4f}")
    train_loss.reset_state(); train_acc.reset_state()
    val_loss.reset_state(); val_acc.reset_state()

Verteilte eigene Schleife

Eine verteilte eigene Schleife nutzt strategy.run, um den Pro-Replica-Schritt auf jeder GPU auszuführen, und strategy.reduce, um den Loss zu aggregieren. Den Pro-Replica-Loss durch num_replicas_in_sync teilen, damit die summierten Gradienten dem Global-Batch-Gradient entsprechen (sonst skaliert sich die effektive LR mit der GPU-Zahl). Gradienten normal anwenden — die Strategie übernimmt das All-Reduce unter der Haube. Dasselbe Muster funktioniert für MultiWorkerMirroredStrategy und TPUStrategy.

tensorflow
import tensorflow as tf

strategy = tf.distribute.MirroredStrategy()

with strategy.scope():
    model = build_model()
    optimizer = tf.keras.optimizers.Adam(1e-3)
    loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

train_ds_dist = strategy.experimental_distribute_dataset(train_ds)

@tf.function
def distributed_train_step(x, y):
    def step_fn(x, y):
        with tf.GradientTape() as tape:
            logits = model(x, training=True)
            loss = loss_fn(y, logits)
            loss += sum(model.losses)
            loss /= strategy.num_replicas_in_sync
        grads = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))
        return loss
    per_replica_loss = strategy.run(step_fn, args=(x, y))
    return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_loss, axis=None)

for epoch in range(epochs):
    for x, y in train_ds_dist:
        distributed_train_step(x, y)

GAN-Trainingsschleife

GANs trainieren zwei Modelle antagonistisch: Der Generator versucht, den Diskriminator zu täuschen, der Diskriminator versucht, Fälschungen zu erkennen. Zwei GradientTapes (eins pro Modell) und zwei Optimierer nutzen. beta_1=0.5 (niedriger als Standard) stabilisiert das GAN-Training. Diskriminator und Generator bei jedem Schritt trainieren (oder Verhältnisse alternieren). GANs sind berüchtigt instabil — d_loss und g_loss überwachen, spektrale Normalisierung nutzen und bei Mode Collapse ein Wasserstein-GAN mit Gradientenstrafe erwägen.

tensorflow
import tensorflow as tf

generator = build_generator()
discriminator = build_discriminator()
g_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
d_opt = tf.keras.optimizers.Adam(1e-4, beta_1=0.5)
bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)

@tf.function
def train_gan_step(real_images):
    batch = tf.shape(real_images)[0]
    noise = tf.random.normal((batch, 100))
    with tf.GradientTape() as g_tape, tf.GradientTape() as d_tape:
        fake = generator(noise, training=True)
        real_logits = discriminator(real_images, training=True)
        fake_logits = discriminator(fake, training=True)
        d_loss = bce(tf.ones_like(real_logits), real_logits) + \
                 bce(tf.zeros_like(fake_logits), fake_logits)
        g_loss = bce(tf.ones_like(fake_logits), fake_logits)
    g_grads = g_tape.gradient(g_loss, generator.trainable_variables)
    d_grads = d_tape.gradient(d_loss, discriminator.trainable_variables)
    g_opt.apply_gradients(zip(g_grads, generator.trainable_variables))
    d_opt.apply_gradients(zip(d_grads, discriminator.trainable_variables))
    return g_loss, d_loss

Gradient-Akkumulation

Echte Gradient-Akkumulation ist in TF knifflig, weil GradientTape das Summieren von Gradienten über Aufrufe hinweg nicht leicht unterstützt — man würde Gradienten manuell in tf.Variables akkumulieren. Die einfache Näherung oben skaliert den Loss und wendet bei jedem Schritt Gradienten an, was für SGD einen ähnlichen Effekt hat, aber für Adam nicht identisch ist (der Optimierer sieht kleinere, verrauschtere Gradienten). Für exakte Akkumulation Gradienten in persistenten Variablen sammeln und alle N Schritte anwenden. Hauptsächlich nützlich, wenn GPU-Speicher die Batch-Größe begrenzt.

tensorflow
import tensorflow as tf

accum_steps = 4
optimizer = tf.keras.optimizers.Adam(1e-3)

@tf.function
def accumulated_train_step(x, y):
    with tf.GradientTape() as tape:
        logits = model(x, training=True)
        loss = loss_fn(y, logits) / accum_steps
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# simple accumulation via averaging
for batch_idx, (x, y) in enumerate(train_ds):
    accumulated_train_step(x, y)
    # equivalent effective batch = accum_steps * batch_size
    # (Adam moments are updated every step, so this is an approximation)
20

Performance-Optimierung

tf.function

@tf.function traced eine Python-Funktion in einen statischen Graphen — schneller auf GPU und für Verteilung Pflicht. Der erste Aufruf pro Eingabesignatur traced (langsam); spätere nutzen den Graphen wieder. Pythons Kontrollfluss vermeiden, der von Tensor-WERTEN abhängt (if tensor > 0: ...) innerhalb von tf.function — er erzwingt Retracing. tf.cond / tf.while_loop oder Kontrollfluss nutzen, der nur von Formen/Python-Literalen abhängt. input_signature fixiert Formen und verhindert Retracing ganz. reduce_retracing=True erweitert den Cache.

tensorflow
import tensorflow as tf

@tf.function
def train_step(x, y):
    with tf.GradientTape() as tape:
        preds = model(x, training=True)
        loss = loss_fn(y, preds)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# first call traces the graph (slow), subsequent calls reuse it (fast)
train_step(x_batch, y_batch)

# experimental_relax_shapes allows retracing only when needed
@tf.function(reduce_retracing=True)
def fn(x): return model(x)

# input_signature pins the signature so no retracing
@tf.function(input_signature=[tf.TensorSpec([None, 784], tf.float32)])
def predict(x): return model(x)

XLA-Kompilierung

XLA (Accelerated Linear Algebra) kompiliert Teilgraphen zu verschmolzenen Kerneln, senkt Start-Overhead und ermöglicht Op-übergreifende Optimierungen. jit_compile=True auf einem tf.function löst XLA für diese Funktion aus. Am wirksamsten bei rechenlastigen Modellen (Transformers, Attention) und weniger hilfreich bei I/O-gebundenen. XLA verlangt statische Formen innerhalb einer kompilierten Region — variable Formen verursachen Neukompilierung. Bei Formproblemen auf fixe Formen padden. Immer benchmarken: XLA kann bei kleinen Modellen gelegentlich langsamer sein.

tensorflow
import tensorflow as tf

# JIT-compile a function with XLA (fuses ops for speed)
@tf.function(jit_compile=True)
def train_step(x, y):
    with tf.GradientTape() as tape:
        loss = loss_fn(y, model(x, training=True))
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(grads, model.trainable_variables))
    return loss

# enable XLA globally
tf.config.optimizer.set_jit(True)

# XLA fuses element-wise ops, reduces kernel launches,
# and can give 1.5-3x speedup on GPU/TPU
# especially effective for transformer / attention heavy models

Eingabepipeline-Optimierung

Der Flaschenhals beim GPU-Training ist meist die Eingabepipeline, nicht das Modell. Die kanonische Pipeline cache-t nach dem Laden, mischt, map-t Augmentation parallel, batch-t und prefetch-t. interleave liest mehrere TFRecord-Dateien parallel für plattengebundene Workloads. drop_remainder=True vermeidet einen letzten Batch variabler Form, der Graph-Retracing erzwingt. Den Input-Pipeline-Analyzer des TF-Profilers nutzen, um deinen konkreten Flaschenhals zu finden. AUTOTUNE lässt TF Parallelität und Prefetch-Größen automatisch wählen.

tensorflow
import tensorflow as tf

# the canonical high-performance pipeline
ds = (tf.data.Dataset.from_tensor_slices((x, y))
      .cache()                                      # cache after loading
      .shuffle(10000)
      .map(augment, num_parallel_calls=tf.data.AUTOTUNE)
      .batch(32, drop_remainder=True)
      .prefetch(tf.data.AUTOTUNE))

# parallel file reading for TFRecord
files = tf.data.Dataset.list_files('data-*.tfrecord')
ds = files.interleave(
    tf.data.TFRecordDataset,
    cycle_length=4, num_parallel_calls=tf.data.AUTOTUNE)

# options for autotuning
options = tf.data.Options()
options.autotune.enabled = True
ds = ds.with_options(options)

Gemischte Präzision & TF32

Gemischte Präzision (float16/bfloat16) bringt 2-3x Durchsatz auf Tensor-Core-GPUs. TF32 ist sogar einfacher — ein 19-Bit-Mantissenformat, das transparent für matmul auf Ampere+ (A100, H100) genutzt wird und ~3x Beschleunigung mit minimalem Genauigkeitsverlust und OHNE Codeänderungen oder Loss Scaling liefert. Beides aktivieren für maximale Geschwindigkeit. TF32 ist in CUDA 11+ standardmäßig an, aber TF exponiert das Flag für explizite Kontrolle. Für strenge fp32-Reproduzierbarkeit (wissenschaftliches Rechnen) TF32 deaktivieren.

tensorflow
import tensorflow as tf

# mixed precision (float16 compute, float32 master)
tf.keras.mixed_precision.set_global_policy('mixed_float16')

# enable TF32 on Ampere+ (big matmul speedup, slight precision loss)
tf.config.experimental.enable_tensor_float_32_execution(True)

# TF32 uses 19-bit mantissa for matmul on A100/H100
# it's transparent — no code changes, no loss scaling
# gives ~3x matmul speedup with minimal accuracy impact

# check policy
print(tf.keras.mixed_precision.global_policy())
print('TF32:', tf.config.experimental.tensor_float_32_execution_enabled())

Graph-Optimierung

Grappler ist TFs Graph-Optimierer, der automatisch vor der Ausführung läuft: konstantes Falten, Layoutoptimierung (NCHW vs. NHWC für cuDNN), Op-Fusion (remapping), toter Code-Entfernung und mehr. All das ist standardmäßig an — du musst nur ran, um bestimmte Optimierungen zum Debuggen zu deaktivieren. debug_stripper entfernt Assert/CheckNumerics für Produktions-tempo. Der Layoutoptimierer wählt für cuDNN-Convs auf GPU automatisch NCHW, selbst wenn dein Modell NHWC angibt.

tensorflow
import tensorflow as tf

# enable grappler (default graph optimizer)
tf.config.optimizer.set_jit(True)       # XLA
tf.config.optimizer.set_experimental_options({
    'disable_model_pruning': False,
    'disable_meta_optimizer': False,
    'layout_optimizer': True,           # optimize data layout (NCHW vs NHWC)
    'constant_folding': True,           # fold constants at build time
    'shape_optimization': True,
    'remapping': True,                  # fuse compatible ops
    'arithmetic_optimization': True,
    'loop_optimization': True,
    'dependency_optimization': True,
    'function_optimization': True,
    'debug_stripper': True,             # remove Assert/CheckNumerics
})

# all on by default — only set explicitly to disable specific ones

AutoGraph & Kontrollfluss

AutoGraph konvertiert Pythons if/for/while innerhalb von tf.function in TF-Graph-Ops (tf.cond / tf.while_loop), sodass sie effizient auf GPU laufen. Schleifen über einen tf.data.Dataset mit Python-'for' sind fein — sie iterieren zur Trace-Zeit. if/for vermeiden, das von Tensor-WERTEN (nicht Formen) abhängt — das erzwingt Retracing bei jeder Wertänderung. Für Laufzeit-Kontrollfluss auf Tensor-Werten tf.cond und tf.while_loop explizit nutzen oder AutoGraph machen lassen (es tut es, aber die Konvertierung kann subtil sein).

tensorflow
import tensorflow as tf

# AutoGraph converts Python if/for/while into tf.cond / tf.while_loop
@tf.function
def fn(x):
    if x > 0:          # AutoGraph converts this
        return x * 2
    else:
        return x

@tf.function
def sum_loop(n):
    total = tf.constant(0)
    for i in tf.range(n):    # AutoGraph converts to tf.while_loop
        total += i
    return total

# Python-side (compile-time) loop vs TF-side (runtime) loop
@tf.function
def train_epoch(dataset):
    for x, y in dataset:   # Python iteration over dataset (fine)
        train_step(x, y)

# avoid data-dependent Python control flow
# if x.shape[0] > 10: ...  # OK (static shape)
# if tf.reduce_sum(x) > 0: ...  # forces retracing

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.