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 TokensEine 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:
weighthat zwei Achsen (weight.ndim == 2);- die letzte Achse von
xist so groß wie die erste Achse vonweight; biashat 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,
.Tund Broadcasting tun; - das transponierte Gewicht scheitert in
linearmit einer Meldung, die beide Shapes nennt, nicht tief im Training; ruff check artifacts/my-workundpython -m pytest artifacts/my-workbestehen.
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