Zurück zum Lernbereich

Tensoren: Die Sprache der GPUs

Tensoren: der Begriff, der einschüchternder klingt, als die Sache ist.

  • Grundlagen
  • 12 min
  • Fortgeschritten

Einfache Sprache

Diese Vorschau ist in Einfacher Sprache. Das ganze Portal gibt es auch in Einfacher Sprache. Du kannst oben die Sprache wechseln. Oder nutze den Knopf unten. Unsere Texte in Einfacher Sprache entstehen KI-gestützt und werden redaktionell begleitet. Sie orientieren sich an den Grundprinzipien der Leichten Sprache, sind aber keine geprüfte Leichte Sprache: Eine Prüfgruppe von Menschen mit Lernschwierigkeiten prüft sie nicht.

Vorschau: Wie Computer Daten verarbeiten

Was ist ein Tensor?

Eine einzelne Zahl nennt man Skalar. Skalar bedeutet: ein einziger Wert. Viele Zahlen in einer Reihe nennt man Vektor. Ein Gitter aus Zahlen ist eine Matrix. Viele Matrizen übereinander nennt man Tensor.

Alles muss ein Tensor sein

Eine GPU ist ein schneller Rechenchip. GPU bedeutet: Grafikprozessor. Eine GPU führt viele Berechnungen gleichzeitig aus. Sie versteht nur Tensoren. Der Computer wandelt Bilder in Tensoren um. Er wandelt Text in Tensoren um.

Batches: Viele auf einmal

Eine GPU hat Tausende von Rechenkernen. Rechenkerne sind kleine Rechner im Chip. Ein einzelnes Bild lässt die meisten Kerne leer. Deshalb schickt man viele Bilder auf einmal. Das nennt man Batch. Batch bedeutet: viele Beispiele zusammen.

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

Stell dir eine Excel-Arbeitsmappe vor. Ein Skalar ist eine einzelne Zelle (A1 = 42). Ein Vektor ist eine Spalte (A1:A10). Eine Matrix ist ein Arbeitsblatt. Ein 3D-Tensor ist die gesamte Arbeitsmappe mit mehreren gestapelten Blättern — wie R-, G-, B-Farbkanäle. Ein 4D-Tensor? Ein Ordner voller Arbeitsmappen.

Beispiel

Excel-Blätter können unterschiedlich groß sein — in einem Tensor muss jedes "Blatt" exakt dieselbe Größe haben. Und Excel rechnet über mehrere Blätter nur mit Sonderformeln — Tensoren sind genau dafür gemacht.
  1. 1. SkalarEin einzelner Wert. Keine Indizes nötig. Form: () — z.B. Temperatur = 23.5
  2. 2. VektorEine Reihe von Werten. Ein Index nötig. Form: (n) — z.B. Gewichte = [0.3, 0.7, 0.1]
  3. 3. MatrixEin Raster von Werten. Zwei Indizes. Form: (m, n) — z.B. Graustufen-Bild (4, 4) = 16 Werte
  4. 4. 3D-TensorGestapelte Matrizen. Drei Indizes. Form: (k, m, n) — z.B. RGB-Bild (3, 4, 4) = 48 Werte
  5. 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.

Skalar (Rang 0): 42
Vektor (Rang 1): [3, 7, 1, 9]
Matrix (Rang 2): [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
Tensor (Rang 3): [[[1,2],[3,4]],
[[5,6],[7,8]]]
= 2 Schichten x 2 Zeilen x 2 Spalten
Konkretes Beispiel

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].

Stärke dieser Analogie

Macht die Struktur greifbar: Wie viele Dimensionen hat der Tensor? Welche Form hat er?

Grenze dieser Analogie

Erklärt nicht, warum Tensoren für Berechnungen nützlich sind — nur wie sie Daten speichern.

Tensor-Dimensionen im Vergleich

RangMathematikDatenwürfelKI-Beispiel
0SkalarEinzelner PunktLernrate: 0.001
1VektorLinie von ZahlenWord Embedding: [768]
2MatrixBlatt mit Zeilen + SpaltenGewichtsmatrix: [768, 512]
33D-TensorWürfel von ZahlenFarbbild: [3, 256, 256]
44D-TensorRegal voller WürfelBild-Batch: [32, 3, 256, 256]
Aktive Analogie:1 / 3Alle Perspektiven erkunden hilft beim Verständnis

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

Image (3, 256, 256) → Batch (32, 3, 256, 256) → Video-Batch (32, 30, 3, 256, 256)
Jede neue Dimension hat klare Bedeutung
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

Achtung

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

Noch offen

Was ist ein Tensor?

Wähle eine Antwort

Auflösung: 1) B · 2) C · 3) D · 4) B

Prüfen

Lernziele

Kannst du das in eigenen Worten erklären? Hake ab, was sitzt.

0 von 3 sitzen