TPU (Tensor Processing Unit)

Eine Tensor Processing Unit (TPU) ist ein anwendungsspezifischer integrierter Schaltkreis (ASIC), den Google zur Beschleunigung des Trainings und der Inferenz von neuronalen Netzen entwickelt. Eine TPU ist auf große Matrixmultiplikationseinheiten ausgelegt, weil die Matrixmultiplikation den Großteil der Arbeit beim Deep Learning ausmacht. Google setzt TPUs seit 2015 in seinen Rechenzentren ein, trainiert damit Gemini-Modelle und vermietet sie anderen Unternehmen als Cloud TPU. Die im April 2026 angekündigte achte Generation besteht aus zwei Chips: TPU 8t für das Training und TPU 8i für die Inferenz.

Funktionsweise einer TPU#

Das Herzstück jeder TPU ist eine Matrixmultiplikationseinheit (MXU), die als systolisches Array angeordnet ist: ein Raster aus Multiplizier-und-Akkumulier-Zellen, die Daten direkt an ihre Nachbarn weitergeben. Die Gewichte werden einmalig in die Zellen geladen, die Eingaben fließen pro Taktzyklus einen Schritt durch das Raster, und Zwischensummen laufen die Spalten hinunter. Dadurch wird jeder aus dem Speicher geladene Wert von vielen Zellen wiederverwendet. Speicherzugriffe kosten deutlich mehr Zeit und Energie als Rechenoperationen. Genau dadurch ist dieses Design so effizient. In Cloud TPU v2 und v3 war jedes MXU ein Array mit 128×128 Zellen, das in bfloat16 multiplizierte und in FP32 akkumulierte. Eine kurze Simulation veranschaulicht den Datenfluss in einem 4×4-Raster:

import numpy as np

rng = np.random.default_rng(0)
W = rng.integers(-5, 5, (4, 4))  # weights, preloaded one per cell of a 4x4 grid
X = rng.integers(-5, 5, (6, 4))  # six input rows stream through the grid
Y = np.zeros((6, 4), dtype=int)

# Cell (k, j) holds W[k, j]. Input X[i, k] enters row k from the left and reaches
# cell (k, j) at cycle i + k + j, where it is multiplied by the stored weight and
# added to the partial sum for Y[i, j] passing down column j
cycles = 6 + 4 + 4 - 2
for t in range(cycles):
    for k in range(4):
        for j in range(4):
            i = t - k - j
            if 0 <= i < 6:
                Y[i, j] += X[i, k] * W[k, j]

print(f"{X.size * 4} multiply-adds in {cycles} cycles, equal to X @ W: {np.array_equal(Y, X @ W)}")

Die Ausgabe lautet 96 multiply-adds in 12 cycles, equal to X @ W: True: Die 16 Zellen erzeugen das exakte Matrixprodukt, wobei jedes Gewicht nur einmal aus dem Speicher gelesen und für alle sechs Eingabezeilen wiederverwendet wird. Die TPU der ersten Generation führte dieses Muster auf einem Raster aus 256×256 8-Bit-Zellen aus: 65.536 Multiplikationen mit Akkumulation pro Taktzyklus, bei einer Spitzenleistung von 92 Billionen Operationen pro Sekunde. Ihre einfache, deterministische Ausführung eignete sich für Googles Ziel, bei der Inferenz die Reaktionszeitvorgabe für das 99. Perzentil einzuhalten.

TPUs führen Code aus, der von XLA kompiliert wurde. XLA übernimmt den gesamten Berechnungsgraphen aus JAX, TensorFlow oder PyTorch und ordnet ihn den Matrixeinheiten zu. Die Chips werden über spezielle Verbindungen zu Pods mit Tausenden von Chips zusammengeschaltet. So lassen sich die größten Grundlagenmodelle gleichzeitig auf vielen TPUs trainieren.

TPU im Vergleich zu GPU und CPU#

• CPU: Einige wenige leistungsstarke Kerne für Verzweigungen und universellen Code. In den meisten Trainingspipelines übernehmen sie das Laden und die Vorverarbeitung der Daten.
• GPU: Tausende programmierbare Kerne sowie Tensor Cores für Matrixberechnungen. GPUs führen nahezu jedes Modell und Framework aus und werden von vielen Anbietern und Cloud-Plattformen verkauft.
• TPU: Tauscht diese Flexibilität gegen Effizienz bei großen, dichten Matrixoperationen ein. Am besten eignen sich Arbeitslasten mit statischen Tensorformen, da eine Formänderung eine erneute Kompilierung durch XLA auslöst. Eigene Operationen, umfangreiche Verzweigungen oder hochpräzise Berechnungen eignen sich dagegen weniger für TPUs.
• NPU: Allgemeine Bezeichnung für Beschleuniger neuronaler Netze in Smartphones, Laptops und Edge-Chips. Dazu zählt auch die Edge TPU.

Die Edge TPU#

Die Edge TPU ist eine kleine TPU, die ausschließlich für Inferenz vorgesehen ist. Der Chip kommt im Coral USB Accelerator von Google sowie in M.2- und PCIe-Modulen und im Dev Board zum Einsatz. Er leistet 4 Billionen Operationen pro Sekunde bei 2 Watt und unterstützt ausschließlich 8-Bit-Ganzzahlberechnungen. Daher müssen Netzwerke mithilfe der Modellquantisierung vollständig in INT8 umgewandelt und anschließend mit Googles Edge TPU Compiler kompiliert werden. Dieser führt unterstützte Operationen auf dem Chip aus und überlässt die übrigen der Host-CPU. Ultralytics YOLO automatisiert beide Schritte mit format="edgetpu". Dadurch wird die INT8-Quantisierung aktiviert und der Compiler auf einem x86-64-Linux-Rechner ausgeführt. Das Ergebnis ist ein Modell, das auf Geräten wie einem Raspberry Pi mit Coral USB Accelerator läuft:

from ultralytics import YOLO

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

# Quantize to INT8 and compile for the Edge TPU (x86-64 Linux only)
path = model.export(format="edgetpu")
print(f"Edge TPU model: {path}")

Googles Coral-Plattform konzentriert sich inzwischen auf Coral NPU, ein Open-Source-Beschleunigerdesign auf RISC-V-Basis, das im Oktober 2025 für tragbare Geräte angekündigt wurde und auf 512 Milliarden Operationen pro Sekunde bei wenigen Milliwatt abzielt.