TensorFlow

TensorFlow ist ein Open-Source-Framework für maschinelles Lernen (ML), das Google im November 2015 unter der Apache-2.0-Lizenz veröffentlichte, nachdem das Google-Brain-Team es für interne Forschung und Produkte entwickelt hatte. Programme für Deep Learning und andere numerische Berechnungen stellen Berechnungen als Operationen auf Tensoren dar – mehrdimensionalen Zahlenfeldern. TensorFlow berechnet ihre Ableitungen automatisch, kompiliert sie zu optimierten Graphen und führt sie auf CPUs, GPUs und TPUs aus. Das Ökosystem deckt den gesamten MLOps-Ablauf vom Training bis zur Modellbereitstellung ab: Keras zum Definieren von Modellen, TensorBoard zum Nachverfolgen von Experimenten, TensorFlow Serving für die Modellbereitstellung in der Produktion, TensorFlow.js für Browser und LiteRT – früher TensorFlow Lite – für Smartphones und eingebettete Geräte mit Edge-KI. Mit TensorFlow 2.21 im März 2026 erklärte Google, dass sich die künftige TensorFlow-Entwicklung auf Sicherheit und Fehlerbehebungen, Abhängigkeitsaktualisierungen und Beiträge aus der Community konzentrieren werde. Für neue Projekte mit generativer KI verwies das Unternehmen auf Keras 3, JAX oder PyTorch.

So funktioniert TensorFlow#

Bei TensorFlow 1.x mussten Nutzer zuerst einen statischen Berechnungsgraphen erstellen und ihn anschließend in einer Sitzung ausführen. TensorFlow 2.0, 2019 veröffentlicht, machte die eager Ausführung zum Standard: Operationen werden sofort wie gewöhnlicher Python-Code ausgeführt. Graphen blieben als Optimierung erhalten: Eine Funktion mit dem Dekorator tf.function wird für jede Eingabesignatur einmal nachverfolgt und in einen Graphen umgewandelt, den TensorFlow optimieren, mit dem XLA-Compiler kompilieren und im SavedModel-Format zur Bereitstellung ohne Python speichern kann. tf.GradientTape zeichnet die Operationen eines Vorwärtsdurchlaufs auf, damit TensorFlow die Gradienten für Backpropagation und Gradientenabstieg berechnen kann. Dieser Code erledigt beides:

import tensorflow as tf

w = tf.Variable([[1.0], [-2.0]])
x = tf.constant([[3.0, 4.0]])


@tf.function  # trace the Python function into a TensorFlow graph on the first call
def loss_fn(x):
    print("Tracing")  # Python code runs only while tracing, not on every call
    return tf.reduce_sum((x @ w) ** 2)


# Record operations on a tape to compute the gradient of the loss with respect to w
with tf.GradientTape() as tape:
    loss = loss_fn(x)
gradient = tape.gradient(loss, w)

loss_fn(x)  # same input shape and dtype: reuses the traced graph without printing
print(f"loss {loss.numpy()}, gradient {gradient.numpy().ravel()}")

Der Code gibt einmal Tracing und anschließend loss 25.0, gradient [-30. -40.] aus: Beim zweiten Aufruf wurde der zwischengespeicherte Graph ausgeführt, ohne den Python-Funktionsrumpf aufzurufen. Der Gradient von (3w₁ + 4w₂)² bei w = (1, -2) ist 2 × (-5) × (3, 4). Für verteiltes Training replizieren tf.distribute-Strategien ein Modell über mehrere GPUs, TPU-Slices oder Maschinen hinweg.

Das TensorFlow-Ökosystem#

• Keras: Die High-Level-API zum Definieren von Schichten und Modellen sowie zum Trainieren mit fit. Seit TensorFlow 2.16 wird bei der Installation von TensorFlow Keras 3 mitinstalliert. Keras 3 läuft auch auf JAX und PyTorch.
• TensorBoard: Ein Dashboard für Verlustkurven, Metriken, Histogramme und Modellgraphen während des Trainings. Es liest auch Protokolle anderer Frameworks, darunter Ultralytics-YOLO-Trainingsläufe. TensorFlow 2.21 installiert es nicht mehr als Abhängigkeit.
• TensorFlow Serving: Ein Bereitstellungssystem, das SavedModels lädt und Vorhersageanfragen über gRPC oder REST beantwortet. Die Versionsverwaltung ermöglicht den Austausch von Modellen im laufenden Betrieb.
• TFX: Ein Pipeline-Framework für maschinelles Lernen in der Produktion, das Datenvalidierung, Training und Evaluierung miteinander verknüpft und ein freigegebenes Modell zur Bereitstellung weiterleitet.
• TensorFlow.js: Führt Modelle im Browser und in Node.js aus und trainiert sie dort, sodass Schlussfolgerungen auf dem Gerät des Nutzers erfolgen können, ohne Daten an einen Server zu senden.
• LiteRT: Googles Laufzeitumgebung auf dem Gerät für Android, iOS, eingebettetes Linux und Mikrocontroller. Sie wurde im September 2024 in TensorFlow Lite umbenannt. LiteRT führt .tflite-Modelle aus, die aus TensorFlow, PyTorch oder JAX konvertiert wurden, und unterstützt die Beschleunigung auf mobilen GPUs und NPUs.

TensorFlow im Vergleich zu PyTorch und JAX#

• PyTorch im Vergleich zu TensorFlow: PyTorch setzt von Anfang an auf eager Ausführung; torch.compile ergänzt die Graph-Kompilierung. Es ist das Standard-Framework für die meisten neuen Forschungsprojekte und Modelle mit offenen Gewichten. TensorFlow punktet mit seinem ausgereiften Bereitstellungs-Stack für Server, Browser und Mobilgeräte.
• JAX: Googles Bibliothek im NumPy-Stil mit kombinierbaren Transformationen: grad für Ableitungen, jit für die XLA-Kompilierung und vmap für Vektorisierung. Google trainiert seine Gemini-Modelle mit JAX.
• Keras: Eine High-Level-API und keine separate Engine. Keras-3-Code läuft auf TensorFlow, JAX oder PyTorch. So bindet eine Modelldefinition ein Projekt nicht an ein einzelnes Framework.

Modelle für TensorFlow-Laufzeitumgebungen konvertieren#

Modelle, die mit anderen Frameworks trainiert wurden, lassen sich über Konverter mit TensorFlows Bereitstellungstools verwenden: onnx2tf erstellt einen TensorFlow-SavedModel-Graphen aus einem ONNX-Graphen, jax2tf verpackt JAX-Funktionen als TensorFlow-Funktionen, und Googles LiteRT-Torch-Konverter erzeugt LiteRT-Modelle direkt aus PyTorch. Ultralytics-YOLO-Modelle werden in PyTorch geschrieben. Ihr Exportmodus nutzt für YOLO26 diese Wege: format="saved_model" exportiert nach ONNX und konvertiert das Modell mit onnx2tf in ein SavedModel für TensorFlow Serving, format="edgetpu" kompiliert ein INT8-Modell für Coral Edge TPUs, und format="litert" nutzt LiteRT Torch, sodass keine TensorFlow-Installation erforderlich ist. Mit diesem Code exportierst du das SavedModel:

from ultralytics import YOLO

# Load the smallest YOLO26 detection model
model = YOLO("yolo26n.pt")

# Convert through ONNX to a TensorFlow SavedModel directory
path = model.export(format="saved_model")
print(f"SavedModel: {path}")

Beim Export wird ein Ordner yolo26n_saved_model erstellt, den tf.saved_model.load in Python lädt. Ultralytics YOLO selbst kann das Modell mit YOLO("yolo26n_saved_model") ausführen.