Tensoren: Die Sprache der GPUs

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

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 — lila.

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)

In einem 0D-Skalar steckt ein einziger Wert. Aber mit jeder neuen Dimension wächst die Informationsdichte: Ein 768-dimensionaler Vektor 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.

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.

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.

RuntimeError: mat1 and mat2 shapes cannot be multiplied
  (32x768 and 512x256)

# Erwartet: (32, 512) @ (512, 256) → (32, 256)
# Erhalten: (32, 768) @ (512, 256) → Fehler!

Warum feste Größe? GPUs müssen das Speicher-Layout im Voraus kennen. Inputs mit variabler Länge werden auf eine feste Maximallänge aufgefüllt (Padding) oder abgeschnitten (Truncation).

# 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)

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.

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 MB