Zurück zum Lernbereich

Datentabellen und Transformationen (Matrizen)

Das 2D-Zahlenraster, in dem jede ML-Bibliothek hauptsächlich denkt.

  • 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: Matrizen: Tabellen aus Zahlen

Was ist eine Matrix?

Eine Matrix ist ein Raster aus Zahlen. Stell dir eine Tabelle vor. Nur mit Zahlen. Jede Zeile ist ein Datenpunkt. Jede Spalte ist eine Eigenschaft. Zum Beispiel: 1000 Häuser mit je 5 Eigenschaften ergeben eine 1000-Zeilen-Tabelle.

Matrizen in neuronalen Netzen

Neuronale Netze nutzen Matrizen als Gewichte. Gewichte sind Zahlen im Netz. Sie bestimmen die Umwandlung der Eingaben. Eine Gewichtsmatrix verwandelt Eingaben in andere Zahlen. So lernt das Netz Schritt für Schritt.

Matrizenmultiplikation

Matrizen kann man miteinander multiplizieren. Matrizenmultiplikation bedeutet: Zwei Matrizen zusammenführen. Das Ergebnis ist eine neue Matrix. Diese Operation ist wichtig in der KI. Jede Netz-Schicht nutzt diese Rechenoperation.

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 Zahlentabelle, 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?

Definition

Matrix

Analogie

Stell dir eine Tabellenkalkulation vor, die nur Zahlen enthält: Zeilen sind Einträge (Häuser), Spalten sind Eigenschaften (Fläche, Zimmer, Baujahr). Das IST eine Matrix. Jede Zeile ist ein Vektor, und alle Vektoren zusammen bilden das Raster.

Beispiel

Echte Tabellenkalkulationen können Text, Formeln und leere Zellen enthalten. Eine mathematische Matrix enthält ausschließlich Zahlen, hat eine feste Größe und unterstützt algebraische Operationen wie Multiplikation.
Matrix als Datentabelle

Zeilen = Datenpunkte, Spalten = Merkmale. Eine 1000×5-Matrix speichert 1000 Häuser mit je 5 Eigenschaften.

Matrix als Transformation

Die Matrix definiert, WIE ein Eingabevektor in einen Ausgabevektor umgewandelt wird. Gewichtsmatrizen in neuronalen Netzen sind Transformationen.

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

Achtung

Irrtum: Matrizen sind nur Tabellen

Matrizen sind weit mehr als Datenspeicher. Ihre eigentliche Stärke liegt darin, Transformationen darzustellen. Eine Gewichtsmatrix in einem neuronalen Netz speichert keine Daten — sie definiert, WIE Eingaben in Ausgaben umgewandelt werden.

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.

  1. 1. Nimm Zeile i der Matrix A.
  2. 2. Nimm Spalte j der Matrix B.
  3. 3. Berechne das Skalarprodukt (Punkt für Punkt multiplizieren und aufaddieren).
  4. 4. Das Ergebnis steht an Position (i, j) der Ergebnismatrix C.
c_ij = a_i1·b_1j + a_i2·b_2j + … + a_in·b_nj
Matrizenmultiplikation

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.

(m × n) · (n × p) = (m × p)
Dimensionsregel

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

Achtung

Irrtum: A × B = B × A

Matrizenmultiplikation ist NICHT kommutativ. A × B ergibt in der Regel ein anderes Ergebnis als B × A. Oft ist sogar nur eine der beiden Multiplikationen definiert, weil die Dimensionen nicht passen. Reihenfolge zählt!

In NumPy ist * das elementweise Produkt (Hadamard) und @ die Matrizenmultiplikation. Beide liefern völlig unterschiedliche Ergebnisse! Der häufigste Anfängerfehler: * verwenden, wenn @ gemeint ist.

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. Danach wendet die Schicht meist noch eine Aktivierungsfunktion Zahl für Zahl auf das Ergebnis an; die schwere Rechenarbeit bleibt aber die Matrizenmultiplikation. Training bedeutet: die Einträge der Gewichtsmatrix so verändern, dass der Fehler kleiner wird.

output = W × input + bias
Neuronale Netzwerk-Schicht

Shape-Kette durch ein Mini-Netzwerk

Eingabe (5 Datenpunkte) 5 × 3
Gewichte W1 3 × 4
Verborgene Schicht 5 × 4
Gewichte W2 4 × 2
Ausgabe 5 × 2

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

A100 GPU (FP16, Tensor-Kerne)

312 TFLOPS

CPU (Größenordnung)

~1–5 TFLOPS

Speedup (Spitzenleistung)

~60–300 ×

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 (die A100 z. B. 6.912, dazu 432 Tensor-Kerne, die je Takt einen kleinen Matrixblock multiplizieren). 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. Die A100 kam 2020 heraus; die neuere NVIDIA B200 aus der Blackwell-Generation schafft im selben Zahlenformat rund 2.250 TFLOPS.

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}')

Die innere Dimension verschwindet bei jeder Multiplikation — wie beim Bruchkürzen. (5×3) @ (3×4) = (5×4): Die 3 kürzt sich weg. Dann (5×4) @ (4×2) = (5×2): Die 4 kürzt sich weg. So fließen die Daten Schicht für Schicht durch das Netzwerk, und die Dimensionen verändern sich kontrolliert.

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

Merke

Das Wichtigste

  • Eine Matrix ist ein rechteckiges Zahlenschema — sie kann einen Datensatz (Zeilen = Beispiele) oder eine Transformation (Eingabe → Ausgabe) darstellen.
  • Die Matrizenmultiplikation besteht aus Skalarprodukten zwischen Zeilen und Spalten. Sie ist so definiert, weil sie die Hintereinanderausführung linearer Transformationen beschreibt — das ist keine willkürliche Konvention.
  • Jede vollverbundene Schicht eines neuronalen Netzes berechnet output = W × input + bias — eine Matrizenmultiplikation. GPUs sind dafür ideal, weil jedes Ausgabeelement unabhängig berechnet werden kann.

Prüfen

Quiz: Matrizen

Noch offen

Ein Datensatz hat 500 Bilder mit je 3 Merkmalen. Welche Form hat die zugehörige Matrix?

Wähle eine Antwort

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

Prüfen

Checkpoint: Matrizen

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

0 von 3 sitzen