Zum Inhalt springen
LLM Engineering Course
Deutsch
Esc
↑↓navigieren↵öffnen⌘Jvorschau
Auf dieser Seite

F02 — Tensoren und Shapes

← F01 — Python & NumPy · F03 — Wahrscheinlichkeit & Loss → · Glossar

Lernziel

Du sagst den Shape eines Arrays voraus, bevor der Code läuft, und schreibst eine kleine lineare Schicht, die ein falsches Gewicht oder einen falschen Bias mit einer klaren Meldung ablehnt. Unterwegs triffst du zwei Broadcasting-Fehler: einen, der mit einer Fehlermeldung stoppt, und einen, der still durchläuft.

Nutzt du NumPy schon, überfliege die Schritte und gehe zu „Bauen“: insgesamt etwa 30–45 Minuten. War F01 neu für dich, plane etwa 60–75 Minuten für die Schritte und weitere 45–75 Minuten für das Bauen ein, am besten in zwei Sitzungen. Die Zeiten sind Orientierung, keine Frist.

Shapes Schritt für Schritt

Jeder Schritt bittet dich, vorherzusagen, bevor du ausführst. Der Kommentar in jeder Zeile ist die Antwort, also decke ihn zuerst ab. Sammle die Blöcke aller fünf Schritte in einer Datei, artifacts/my-work/shapes.py, jeden unter dem vorigen, und führe nach jedem python artifacts/my-work/shapes.py aus. Soll ein Schritt eine Zeile ausprobieren, die scheitert, hänge sie ans Ende, führe die Datei aus, lies die letzte Zeile der Fehlermeldung und lösche die Zeile wieder, damit die Datei wieder läuft.

Shape und Broadcasting

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
row = np.array([10, 20, 30])
print(a.shape)              # (2, 3): 2 Zeilen, 3 Spalten
print(row.shape)            # (3,): eine Achse mit 3 Einträgen
print((a + row).tolist())   # [[11, 22, 33], [14, 25, 36]]

Eine Zahl ist ein Skalar, eine Zahlenreihe ein Vektor, eine Tabelle eine Matrix; Tensor ist das allgemeine Wort für ein Array mit beliebig vielen Achsen. shape nennt die Länge jeder Achse: (2, 3) sind zwei Zeilen mit je drei Einträgen. Das Komma in (3,) kennzeichnet ein Tupel mit einem Element, row hat also eine Achse. .tolist() macht aus einem Array eine gewöhnliche Python-Liste, die in einer Zeile ausgegeben wird.

a + row addiert row zu jeder Zeile von a. Das ist Broadcasting: NumPy legt die beiden Shapes von rechts übereinander, (2, 3) über (3,), und verwendet das kleinere Array entlang der fehlenden Achse mehrfach. Von rechts Achse für Achse verglichen, müssen zwei Größen gleich sein, oder eine davon ist 1; eine fehlende Achse zählt als 1.

Sage voraus, was print(a + np.array([10, 20])) tut, dann hänge es an und führe die Datei aus.

Prüfe deine Vorhersage

Es stoppt mit ValueError: operands could not be broadcast together with shapes (2,3) (2,). Von rechts trifft 3 auf 2: verschieden, und keine ist 1. Lösche die Zeile.

Eine konkrete Matrixmultiplikation

print((a * a).tolist())     # [[1, 4, 9], [16, 25, 36]]

* multipliziert Eintrag für Eintrag. @ ist die Matrixmultiplikation, die Zeilen mit Spalten verrechnet:

x = np.array([[1, 2, 3], [0, 1, -1]])
w = np.array([[1, 0], [0, 1], [1, 1]])
print((x @ w).shape)        # (2, 2)
print((x @ w).tolist())     # [[4, 5], [-1, 0]]

Die Regel: Eintrag (i, j) von x @ w ist Zeile i von x · Spalte j von w. Der Punkt · ist ein Skalarprodukt: passende Einträge multiplizieren, dann addieren. Links oben, Zeile 0 von x mit Spalte 0 von w: 1×1 + 2×0 + 3×1 = 4. Rechts oben, Zeile 0 mit Spalte 1: 1×0 + 2×1 + 3×1 = 5. Rechne die untere Zeile von Hand aus, bevor du die Datei ausführst.

Eine Zeile von x und eine Spalte von w müssen gleich lang sein. x ist (2, 3) und w ist (3, 2): Die inneren Größen passen (3 und 3) und werden wegsummiert; die äußeren bleiben, also ergibt (2, 3) @ (3, 2) den Shape (2, 2). Sage voraus, ob print(a @ a) funktioniert, dann probiere es.

Prüfe deine Vorhersage

Es scheitert: Bei (2, 3) @ (2, 3) steht innen 3 gegen 2. NumPys Meldung endet mit (size 2 is different from 3). Lösche die Zeile.

Bei quadratischen Arrays funktionieren * und @ beide und liefern denselben Shape, aber andere Zahlen. Eine Shape-Prüfung kann sie nicht unterscheiden:

s = np.array([[1, 2], [3, 4]])
print((s * s).tolist())     # [[1, 4], [9, 16]]
print((s @ s).tolist())     # [[7, 10], [15, 22]]

Reshape gegen Transpose

b = np.arange(6)
print(b.tolist())                   # [0, 1, 2, 3, 4, 5]
print(b.reshape(2, 3).tolist())     # [[0, 1, 2], [3, 4, 5]]

np.arange(6) zählt von 0 bis 5. reshape(2, 3) füllt dieselben sechs Werte in derselben Lesereihenfolge in 2 Zeilen zu 3. Sage beide Zeilen unten voraus, dann führe die Datei aus:

print(b.reshape(3, 2).tolist())     # [[0, 1], [2, 3], [4, 5]]
print(b.reshape(2, 3).T.tolist())   # [[0, 3], [1, 4], [2, 5]]

Beide Ergebnisse haben den Shape (3, 2), aber verschiedenen Inhalt. reshape behält die Lesereihenfolge; .T (Transpose) vertauscht Zeilen und Spalten, aus Zeile 0 [0, 1, 2] wird Spalte 0. Verwechselst du sie, stimmt der Shape und die Werte sind falsch, und keine Shape-Prüfung merkt es.

Drei Achsen: Batch, Zeit, Kanal

Ein Sprachmodell verarbeitet mehrere Texte zugleich, und jeder Text ist eine Folge von Tokenpositionen. Seine Arrays haben deshalb drei Achsen, geschrieben [B, T, C]: Batch (welches Beispiel), Time (welche Tokenposition) und Channel, also Kanal (die Zahlen, die ein Token beschreiben). Spätere Lektionen schreiben für die Kanalbreite auch D. Hier sind es 2 Beispiele, 3 Positionen und 4 Kanäle:

t = np.arange(24).reshape(2, 3, 4)
print(t.shape)              # (2, 3, 4)
print(t[0].shape)           # (3, 4): Beispiel 0, alle seine Positionen
print(t[:, 0].shape)        # (2, 4): Position 0 jedes Beispiels
print(t[0, 0].tolist())     # [0, 1, 2, 3]: die 4 Kanäle eines Tokens

Eine Zahl in den Klammern wählt einen Eintrag entlang dieser Achse und entfernt die Achse. : heißt „die ganze Achse“, wie bei den Slices in F01; t[:, 0] behält also beide Beispiele und wählt in jedem Position 0. Sage die Werte voraus, dann hänge print(t[:, 0].tolist()) an und führe die Datei aus.

Prüfe deine Vorhersage

[[0, 1, 2, 3], [12, 13, 14, 15]]. Beispiel 0 beginnt bei 0; Beispiel 1 beginnt nach 3 × 4 = 12 Werten.

Eine lineare Schicht: x @ W + b

Eine lineare Schicht ist der häufigste Schritt in einem neuronalen Netz. Sie macht aus den Kanälen jedes Tokens mit einer Gewichtsmatrix W neue Kanäle und addiert dann einen Bias b: eine zusätzliche Zahl pro Ausgabekanal, die wie die Gewichte gelernt wird. Als Formel: linear(x) = x @ W + b. Mit x und w aus der Matrixmultiplikation und dem Bias [10, 20]:

bias = np.array([10, 20])
print((x @ w + bias).tolist())   # [[14, 25], [9, 20]]

x @ w ist [[4, 5], [-1, 0]]; Broadcasting addiert 10 zur ersten Spalte und 20 zur zweiten. Dieselbe Zeile funktioniert mit [B, T, C]-Arrays: @ wendet W an jedem Beispiel und jeder Position an, und nur die letzte Achse ändert sich:

activations = np.zeros((4, 8, 32))
weight = np.zeros((32, 64))
bias = np.zeros(64)
print((activations @ weight).shape)          # (4, 8, 64)
print((activations @ weight + bias).shape)   # (4, 8, 64)

np.zeros(shape) erzeugt ein Array aus Nullen; hier zählen nur die Shapes. Der Bias (64,) liegt über der letzten Achse: eine Zahl pro Ausgabekanal, für jedes Beispiel und jede Position wiederverwendet.

Jetzt zwei falsche Biases. Hänge print((activations @ weight + np.zeros(8)).shape) an und führe die Datei aus: Es stoppt mit operands could not be broadcast together with shapes (4,8,64) (8,). Dieser Fehler ist laut. Ersetze np.zeros(8) durch np.zeros((8, 1)), sage voraus und führe die Datei erneut aus.

Prüfe deine Vorhersage

Es gibt (4, 8, 64) aus, ohne Fehler. Von rechts trifft 1 auf 64 (die 1 wird gestreckt) und 8 auf 8; NumPy addiert also eine Zahl pro Position zu allen 64 Kanälen. Das ist kein Bias, und nichts beschwert sich. Nur eine ausdrückliche Prüfung wie bias.shape == (weight.shape[1],) fängt das ab. Lösche die Zeile.

Bauen und brechen

Arbeite in einer Datei, artifacts/my-work/test_f02.py: oben die Imports, dann deine Funktion, dann die Tests. Schreibe linear(x, weight, bias), das x @ weight + bias zurückgibt, aber vorher drei Dinge prüft und einen ValueError mit einer Meldung auslöst, die die Shapes nennt:

  • weight hat zwei Achsen (weight.ndim == 2);
  • die letzte Achse von x ist so groß wie die erste Achse von weight;
  • bias hat den Shape (weight.shape[1],): eine Zahl pro Ausgabekanal.

Ergänze vier Tests: Das Beispiel der linearen Schicht ergibt [[14, 25], [9, 20]]; eine Eingabe (4, 8, 32) mit einem Gewicht (32, 64) ergibt den Shape (4, 8, 64); ein transponiertes Gewicht np.zeros((32, 64)).T wird abgelehnt; der Positions-Bias np.zeros((8, 1)) wird abgelehnt. Führe python -m pytest artifacts/my-work/test_f02.py aus.

Innerhalb von pytest.raises besteht der Test still, du siehst deine Meldung also nie. Um sie zu lesen, lösche im Test zum transponierten Gewicht kurz die Zeile with pytest.raises(...) und rücke den Aufruf darunter aus. pytest scheitert dann und zeigt deine Meldung in der Zeile, die mit E ValueError: beginnt. Sage, welche zwei Größen nicht mehr übereinstimmen, und setze die Zeile wieder ein.

Ein quadratisches Gewicht, etwa (64, 64), behält beim Transponieren seinen Shape; keine Shape-Prüfung findet diesen Fehler, nur ein Test mit bekannten Werten wie das Beispiel der linearen Schicht. Hängst du fest? Öffne unten den Hinweis.

Abschlussnachweis

  • du hast jeden Shape als Kommentar notiert, bevor du die Zeile ausgeführt hast, die ihn ausgibt;
  • du erklärst an je einem Beispiel, was Reshape, .T und Broadcasting tun;
  • das transponierte Gewicht scheitert in linear mit einer Meldung, die beide Shapes nennt, nicht tief im Training;
  • ruff check artifacts/my-work und python -m pytest artifacts/my-work bestehen.

Wie geht es weiter?

Weiter mit F03 — Wahrscheinlichkeit und Loss.

Hinweis

x.shape[-1] ist die letzte Achse von x, weight.shape[0] die erste Achse von weight. Vergleiche mit != („ungleich“) und löse aus, zum Beispiel raise ValueError(f"x {x.shape} does not fit weight {weight.shape}"). Jeder Ablehnungstest folgt F01s Vorlage aus vier Teilen: falsche Eingabe, pytest.raises, der Aufruf, die Prüfung der Meldung (siehe Testen, dass falsche Eingaben abgelehnt werden).

Referenzantwort
import numpy as np
import pytest


def linear(x, weight, bias):
    """Return x @ weight + bias after checking that the shapes fit."""
    if weight.ndim != 2:
        raise ValueError(f"weight must be 2D, got shape {weight.shape}")
    if x.shape[-1] != weight.shape[0]:
        raise ValueError(f"x {x.shape} does not fit weight {weight.shape}")
    if bias.shape != (weight.shape[1],):
        raise ValueError(f"bias {bias.shape} must be ({weight.shape[1]},)")
    return x @ weight + bias


def test_worked_example():
    x = np.array([[1, 2, 3], [0, 1, -1]])
    weight = np.array([[1, 0], [0, 1], [1, 1]])
    bias = np.array([10, 20])
    assert linear(x, weight, bias).tolist() == [[14, 25], [9, 20]]


def test_batch_time_channel():
    x = np.zeros((4, 8, 32))
    result = linear(x, np.zeros((32, 64)), np.zeros(64))
    assert result.shape == (4, 8, 64)


def test_rejects_transposed_weight():
    x = np.zeros((4, 8, 32))
    with pytest.raises(ValueError) as error:
        linear(x, np.zeros((32, 64)).T, np.zeros(64))
    assert "(64, 32)" in str(error.value)


def test_rejects_position_bias():
    x = np.zeros((4, 8, 32))
    with pytest.raises(ValueError) as error:
        linear(x, np.zeros((32, 64)), np.zeros((8, 1)))
    assert "(8, 1)" in str(error.value)

Das transponierte Gewicht ergibt x (4, 8, 32) does not fit weight (64, 32): Die 32 Kanäle von x treffen auf die 64 Zeilen des transponierten Gewichts.

← F01 — Python & NumPy · F03 — Wahrscheinlichkeit & Loss → · Glossar

War diese Seite hilfreich?