Tensoren: Die Sprache der GPUs
Tensoren: der Begriff, der einschüchternder klingt, als die Sache ist.
Du kennst bereits Skalare, Vektoren und Matrizen. Aber Deep Learning hört nicht bei 2D auf. Ein Farbbild braucht drei Schichten (Rot, Grün, Blau) — das ist ein 3D-Tensor. Ein Stapel von Bildern fügt eine weitere Dimension hinzu — 4D. Ein Stapel von Videos? 5D.
In diesem Artikel kletterst du die Dimensionsleiter hinauf, verstehst, warum JEDER KI-Input in einen Tensor umgewandelt wird, und lernst, warum GPUs Stapel von Daten verlangen statt einzelner Beispiele.
Die Dimensionsleiter
Definition
Tensor
Analogie
Beispiel
Definition
- 1. SkalarEin einzelner Wert. Keine Indizes nötig. Form: () — z.B. Temperatur = 23.5
- 2. VektorEine Reihe von Werten. Ein Index nötig. Form: (n) — z.B. Gewichte = [0.3, 0.7, 0.1]
- 3. MatrixEin Raster von Werten. Zwei Indizes. Form: (m, n) — z.B. Graustufen-Bild (4, 4) = 16 Werte
- 4. 3D-TensorGestapelte Matrizen. Drei Indizes. Form: (k, m, n) — z.B. RGB-Bild (3, 4, 4) = 48 Werte
- 5. 4D-TensorStapel von 3D-Tensoren. Form: (b, k, m, n) — z.B. Batch von 32 Bildern (32, 3, 256, 256)
Ein kleines 4x4 RGB-Bild zeigt die Dimensionsleiter in Aktion. Graustufen: eine Matrix mit Form (4, 4) = 16 Werte. Farbe: ein 3D-Tensor mit Form (3, 4, 4) = 48 Werte. Drei Schichten übereinander: Rot, Grün, Blau. Pixel an Position (2, 3): Rot=220, Grün=45, Blau=180 — ein kräftiges Magenta.
import numpy as np
# Skalar (0D)
scalar = np.array(42) # Form: ()
# Vektor (1D)
vector = np.array([1.0, 2.0, 3.0]) # Form: (3,)
# Matrix (2D)
matrix = np.zeros((4, 4)) # Form: (4, 4)
# 3D-Tensor (RGB-Bild)
rgb_image = np.random.randint(0, 256, (3, 4, 4)) # Form: (3, 4, 4)
print(rgb_image.shape) # (3, 4, 4)
print(rgb_image[0, 2, 3]) # Rot-Wert an Position (2,3)Achtung
Missverständnis: Tensor in Code = Tensor in Physik
In der Physik hat ein Tensor spezifische Transformationsregeln bei Koordinatenwechseln (z.B. Spannungstensor, metrischer Tensor). In PyTorch und TensorFlow ist ein Tensor einfach ein mehrdimensionales Array mit GPU-Unterstützung und automatischer Gradientenberechnung. Gleicher Name, verschiedene Bedeutung.
In einem 0D-Skalar steckt ein einziger Wert. Aber mit jeder neuen Dimension wächst, was sich darstellen lässt: Ein Vektor mit 768 Einträgen (im Embedding-Jargon „768-dimensional“, als Tensor aber 1D) kodiert die Bedeutung eines ganzen Wortes, eine Matrix transformiert diese Bedeutung — und ein 4D-Tensor kann 32 Bilder gleichzeitig durch ein neuronales Netz schleusen.
Interaktiv: Drei Sichtweisen auf Tensoren
Tensoren sind abstrakt — aber verschiedene Analogien machen sie greifbar. Wechsle zwischen drei Sichtweisen, um zu verstehen, was ein Tensor ist: ein Datenwürfel zum Stapeln, eine mathematische Transformation oder ein nummerierter Zahlenspeicher.
Was ist ein Tensor?
Ein Tensor ist die grundlegende Datenstruktur in modernen KI-Systemen. Doch je nach Blickwinkel lassen sich Tensoren ganz unterschiedlich verstehen. Wechsle zwischen drei Analogien, um verschiedene Perspektiven zu erleben.
Tensor als mehrdimensionaler Datenwürfel
Stell dir einen Tensor als Container vor, der Zahlen in mehreren Dimensionen organisiert. Ein Skalar ist ein einzelner Punkt. Ein Vektor ist eine Linie von Zahlen. Eine Matrix ist ein Blatt mit Zeilen und Spalten. Ein 3D-Tensor ist ein Würfel. Und es geht weiter: ein 4D-Tensor ist ein Regal voller Würfel.
Ein Farbbild mit 256 x 256 Pixeln wird als Rang-3-Tensor gespeichert: [3, 256, 256] — drei Farbkanäle (Rot, Grün, Blau), Höhe und Breite. Ein Batch von 32 Bildern ergibt einen Rang-4-Tensor: [32, 3, 256, 256].
Tensor-Dimensionen im Vergleich
| Rang | Mathematik | Datenwürfel | KI-Beispiel |
|---|---|---|---|
| 0 | Skalar | Einzelner Punkt | Lernrate: 0.001 |
| 1 | Vektor | Linie von Zahlen | Word Embedding: [768] |
| 2 | Matrix | Blatt mit Zeilen + Spalten | Gewichtsmatrix: [768, 512] |
| 3 | 3D-Tensor | Würfel von Zahlen | Farbbild: [3, 256, 256] |
| 4 | 4D-Tensor | Regal voller Würfel | Bild-Batch: [32, 3, 256, 256] |
Warum ML in Tensoren denkt
GPUs und TPUs verarbeiten dichte, numerische Arrays mit fester Größe und vektorisierten Instruktionen. Deshalb muss JEDER Input — Bild, Text, Audio, Tabelle — in einen Tensor mit definierter Form übersetzt werden. Die GPU spricht nur eine Sprache: Tensor.
Bild (Kanäle × Höhe × Breite)
(3, 256, 256 )
Text (5 Tokens × 768 Zahlen)
(5, 768 )
Audio (128 Zeitschritte × 80 Frequenzbänder)
(128, 80 )
Tabelle (1000 Zeilen × 10 Spalten)
(1000, 10 )
Die Form sagt dir zusammen mit der Konvention (etwa Channels First), was jede Dimension bedeutet. Falsche Form = falsche Interpretation = Bugs oder unsinnige Ergebnisse. Die Form eines Tensors ist das wichtigste Stück Metadaten im Deep Learning.
Achtung
Shape-Fehler: ein Dauerbrenner im Deep Learning
Shape-Mismatch-Fehler gehören zu den häufigsten Laufzeitfehlern im Deep Learning. Du wirst sie unweigerlich treffen:
RuntimeError: mat1 and mat2 shapes cannot be multiplied
(32x768 and 512x256)
# Erwartet: (32, 512) @ (512, 256) → (32, 256)
# Erhalten: (32, 768) @ (512, 256) → Fehler!Tipp: Gib bei jedem Zwischenschritt die Form aus. print(tensor.shape) ist dein bester Freund beim Debugging.
Warum feste Größe? Ein Tensor ist rechteckig: Entlang jeder Achse sind alle Einträge gleich lang. Darum lassen sich die Beispiele eines Batches nur dann zu einem Tensor stapeln, wenn sie gleich lang sind. Inputs mit variabler Länge werden auf eine feste Maximallänge aufgefüllt (Padding) oder abgeschnitten (Truncation).
PyTorch verwendet Channels First: (Batch, Channels, Height, Width) = (B, C, H, W). TensorFlow verwendet standardmäßig Channels Last: (Batch, Height, Width, Channels) = (B, H, W, C). Dieselben Pixel-Werte, aber komplett andere Speicheranordnung. Beim Portieren zwischen Frameworks musst du explizit permutieren — sonst interpretiert das Netz die Kanäle als Pixel und umgekehrt.
# PyTorch: Channels First (B, C, H, W)
pytorch_image = torch.randn(1, 3, 256, 256)
# TensorFlow: Channels Last (B, H, W, C)
tf_image = tf.random.normal([1, 256, 256, 3])
# Umordnen ins TensorFlow-Layout (bleibt ein PyTorch-Tensor)
tf_image = pytorch_image.permute(0, 2, 3, 1)
# (1, 3, 256, 256) → (1, 256, 256, 3)Beide sind n-dimensionale Arrays mit einer Form. Der Unterschied: Tensoren können auf der GPU laufen und unterstützen automatische Differentiation (Autograd). NumPy-Arrays laufen nur auf der CPU und haben keine Gradientenverfolgung. In der Praxis wandelst du oft hin und her: NumPy für Daten-Vorbereitung, Tensor für Training.
import numpy as np
import torch
# NumPy → Tensor (auf GPU)
np_array = np.array([[1.0, 2.0], [3.0, 4.0]])
tensor = torch.from_numpy(np_array).cuda()
# Tensor → NumPy (zurück auf CPU)
np_back = tensor.cpu().numpy()
# Tensor hat Gradientenverfolgung
w = torch.tensor([2.0], requires_grad=True)
loss = (w * 3 - 6) ** 2
loss.backward() # Gradient automatisch berechnet
print(w.grad) # tensor([0.])Batching: Die GPU füttern
GPUs haben Tausende von Kernen, die alle dieselbe Operation auf verschiedenen Daten gleichzeitig ausführen (SIMD — Single Instruction, Multiple Data). Ein einzelnes Bild zu verarbeiten verschwendet die meisten Kerne. Deshalb wird die Batch-Dimension vorangestellt.
1 RGB-Bild (256x256): 3 x 256 x 256 x 4 Bytes
786 KB
Batch von 32 Bildern: 32 x 786 KB
~25 MB
RTX 4090 VRAM: Hunderte Bilder gleichzeitig (samt Modell und Zwischenergebnissen)
24 GB
Drei Gründe für Batching
GPU-Auslastung: Alle Kerne gleichzeitig beschäftigt. Ein einzelnes Bild nutzt nur einen Bruchteil der verfügbaren Rechenleistung.
Statistische Stabilität: Der Gradient, gemittelt über einen Batch, ist weniger verrauscht als der Gradient eines einzelnen Beispiels. Das Training konvergiert gleichmäßiger.
Trade-off: Größerer Batch = bessere GPU-Nutzung, aber mehr Speicherverbrauch. Batch-Größe ist ein kritischer Hyperparameter.
Shape-Progression
import torch
# Einzelnes Bild: Form (3, 256, 256)
img = torch.randn(3, 256, 256)
# Batch von 32 Bildern: Form (32, 3, 256, 256)
batch = torch.stack([torch.randn(3, 256, 256) for _ in range(32)])
print(batch.shape) # torch.Size([32, 3, 256, 256])
# Speicher: 32 * 3 * 256 * 256 * 4 Bytes = ~25 MBAchtung
Missverständnis: Größerer Batch = immer besser
Mehr ist nicht immer besser. Batch-Größe 1 verschwendet GPU-Kapazität — aber zu große Batches sprengen den Speicher (Out-of-Memory-Fehler). Zudem können sehr große Batches die Generalisierung verschlechtern: Das Modell konvergiert zwar schneller, landet aber häufiger in scharfen Minima, die sich schlechter auf neue Daten übertragen lassen.
Merke
Kernaussagen
- Ein Tensor ist ein n-dimensionales Array mit fester Form. Skalar = 0D, Vektor = 1D, Matrix = 2D und darüber hinaus. Das Shape-Tupel sagt dir exakt, wie groß jede Dimension ist.
- Jeder KI-Input — Bild, Text, Audio — muss als Tensor mit fester Form kodiert werden, bevor eine GPU ihn verarbeiten kann. Shape-Fehler gehören zu den häufigsten Bugs im Deep Learning.
- GPUs verarbeiten Batches, nicht einzelne Beispiele. Die Batch-Dimension wird vorangestellt und macht aus einem 3D-Bild-Tensor einen 4D-Batch-Tensor — damit Tausende von Kernen parallel arbeiten.
Prüfen
Quiz: Tensoren
Was ist ein Tensor?
Wähle eine Antwort
1. Was ist ein Tensor?
2. Ein RGB-Bild hat 64x64 Pixel. Welche Form hat der Tensor (Channels First)?
3. Du verarbeitest einen Batch von 8 RGB-Bildern mit 128x128 Pixeln. Welche Form hat der Tensor?
4. Warum verarbeitet eine GPU Daten als Batch statt einzeln?
Prüfen
Lernziele
Kannst du das in eigenen Worten erklären? Hake ab, was sitzt.
0 von 3 sitzen