Datentabellen und Transformationen (Matrizen)

Du kennst bereits Vektoren — geordnete Listen von Zahlen, die Datenpunkte repräsentieren. Aber was passiert, wenn du viele Vektoren übereinander stapelst? Du bekommst eine Matrix — ein rechteckiges Raster aus Zahlen. Jede Tabellenkalkulation, jeder Datensatz, jede Schicht eines neuronalen Netzes basiert auf Matrizen.

In diesem Artikel lernst du, was Matrizen sind, wie man sie multipliziert (und warum die Definition nicht willkürlich ist) und warum diese eine Operation das rechnerische Herzstück moderner KI ist.

Was ist eine Matrix?

Drei Häuser mit den Merkmalen Fläche, Zimmer und Baujahr bilden eine 3×3-Matrix. Jede Zeile ist ein Haus, jede Spalte ein Merkmal.

import numpy as np

# Drei Häuser als 3x3-Matrix
haeuser = np.array([
    [120, 4, 1990],
    [85,  3, 2005],
    [200, 6, 1975]
])
print(haeuser.shape)    # (3, 3)
print(haeuser[1, 2])    # 2005 — Baujahr von Haus 2

Jeder tabellarische Datensatz im maschinellen Lernen ist eine Matrix: Zeilen sind Beispiele, Spalten sind Features. Und jede vollverbundene Netzwerk-Schicht ist eine Matrixtransformation.

Matrizenmultiplikation — Warum genau so?

Die Matrizenmultiplikation sieht auf den ersten Blick kompliziert aus — aber sie hat einen tiefen Grund: Sie beschreibt exakt die Hintereinanderausführung zweier Transformationen. Erst Matrix B, dann Matrix A anwenden, ergibt die Matrix AB.

Jedes Element c_ij des Ergebnisses ist das Skalarprodukt der i-ten Zeile von A mit der j-ten Spalte von B. Die Verbindung zum Vektoren-Artikel: Matrizenmultiplikation besteht aus vielen Skalarprodukten.

Die inneren Dimensionen müssen übereinstimmen. Eine (m×n)-Matrix mal eine (n×p)-Matrix ergibt eine (m×p)-Matrix. Stimmen die inneren Dimensionen nicht überein, ist die Multiplikation nicht definiert.

import numpy as np

# Gewichtsmatrix W (2x3) mal Eingabevektor x (Shape (3,))
W = np.array([[0.5, -0.3, 0.8],
              [0.1,  0.7, -0.2]])
x = np.array([1, 2, 3])

print(W @ x)          # [2.3, 0.9]
print(W.shape, '@', x.shape, '→', (W @ x).shape)
# (2, 3) @ (3,) → (2,)

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

print(A * B)   # [[ 5, 12], [21, 32]] — elementweise
print(A @ B)   # [[19, 22], [43, 50]] — Matrizenmultiplikation

Interaktiv: Zeile mal Spalte

Die Startwerte sind A und B aus dem Deep Dive zum Hadamard-Produkt: A @ B = [[19, 22], [43, 50]]. Ändere eine Zahl in A oder B (ganze Zahlen von −10 bis 10), und das Produkt rechnet sofort neu. Wähle eine Zelle des Ergebnisses: Die Box markiert die Zeile von A und die Spalte von B, aus denen sie entsteht. Die Grafik zeigt eine der Matrizen als Transformation: Sie verformt das Einheitsquadrat.

Matrizen in neuronalen Netzen — Warum GPUs rechnen

Jede vollverbundene Schicht (fully connected layer) eines neuronalen Netzes berechnet genau eine Matrizenmultiplikation: Gewichtsmatrix mal Eingabe plus Bias. Training bedeutet: die Einträge der Gewichtsmatrix so verändern, dass der Fehler kleiner wird.

Statt einen Vektor nach dem anderen zu verarbeiten, stapelt man viele Eingaben zu einer Matrix. So wird ein ganzer Batch (z.B. 32 Bilder) in EINER Matrizenmultiplikation verarbeitet. Das ist dramatisch schneller. Die Eingaben stehen dann als Zeilen links: X @ W statt W × x, wie im Code unten; die Gewichtsmatrix hat die Form (Merkmale ein × Merkmale aus).

Warum sind GPUs dabei so schnell? Weil bei der Matrizenmultiplikation jedes Skalarprodukt völlig unabhängig von den anderen berechnet wird. Eine CPU hat wenige, sehr schnelle Kerne (z. B. 16). Eine GPU hat Tausende langsamere Kerne (z. B. 10.000). Für Matrizen, wo Tausende einfache Rechnungen gleichzeitig anfallen, ist die GPU dramatisch überlegen. Die 312 TFLOPS nennt NVIDIA im Datenblatt der A100 für 16-Bit-Zahlen (FP16/BF16) auf den Tensor-Kernen; die CPU-Zahl ist nur eine Größenordnung.

import numpy as np

# Mini-Netzwerk (ohne Bias und Aktivierung): 5 Datenpunkte, 3 Features
X = np.random.randn(5, 3)       # Eingabe: (5, 3)
W1 = np.random.randn(3, 4)      # Schicht 1: (3, 4)
W2 = np.random.randn(4, 2)      # Schicht 2: (4, 2)

hidden = X @ W1                  # (5, 3) @ (3, 4) = (5, 4)
output = hidden @ W2             # (5, 4) @ (4, 2) = (5, 2)
print(f'Eingabe: {X.shape} → Verborgen: {hidden.shape} → Ausgabe: {output.shape}')

# Shape-Kette visualisiert:
# (batch × features_in) @ (features_in × features_out) = (batch × features_out)
#   5 × 3               @          3 × 4              =       5 × 4
#   5 × 4               @          4 × 2              =       5 × 2
# Die innere Dimension muss immer übereinstimmen!