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.
# 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()) # TrueErste 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.
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.
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.
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.
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())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.
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 -> TypeErrortf.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.
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) # 2wTensor-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.
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.
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.
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.
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]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.
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 batchFunktionale 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.
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.
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.
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.
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].
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 imagesSchichten
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.
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).
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.
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 * 2Dropout & 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.
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).
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)) # 2Eigene 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.
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)))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.
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.
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.
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.
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.
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.
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)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.
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.
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.
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.
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.
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.
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)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.
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.
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.
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.
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.
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 augtrain_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.
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)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.
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.
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.
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.
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=./logsLearningRateScheduler
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.
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.
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()])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.
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)
breakMap, 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.
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.
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.
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.
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.
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)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.
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.
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/servingNur 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.
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.
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.
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.
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']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.
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.
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.
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.
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.
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.
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}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.
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.
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.
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.
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.
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.
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])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.
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.
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.
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.
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.
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.
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 xTensorBoard
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`.
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.
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.
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.
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.
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 recommendationsGPU-/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.
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.
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.
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.
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.
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">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.
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.
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.
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.
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.
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)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.
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.
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.
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).
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.
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},
)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.
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.
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.
# 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.
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).
# 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 opsInferenz-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.
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 stepEigene 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.
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.
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.
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.
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_lossGradient-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.
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)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.
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.
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 modelsEingabepipeline-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.
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.
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.
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 onesAutoGraph & 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).
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 retracingVerwandte TensorFlow-Snippets
Copy-paste ready code for common tasks.
Tensor Basics
Create and operate on TensorFlow tensors.
Keras Model
Build models with Sequential and the functional API.
Layers
Use core layers and build a custom one.
Compile and Train
Compile, fit, and evaluate a Keras model.
Custom Training Loop
Step through batches with GradientTape.
Callbacks
Monitor and control training with callbacks.
Save and Load
Persist models in SavedModel and Keras formats.
Data Pipeline
Build efficient input pipelines with tf.data.
Was this helpful?