---
title: "F02 — Tensoren und Shapes"
sidebar:
  label: "F02 — Tensoren & Shapes"
---

<span id="f02-tensoren-und-shapes" />


[← F01 — Python & NumPy](/de/foundations-01-python-numpy) · [F03 — Wahrscheinlichkeit & Loss →](/de/foundations-03-probability) · [Glossar](/de/glossary)

## Lernziel [#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 [#shapes-schritt-fur-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 [#shape-und-broadcasting]

```python
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.

<details>
<summary>Prüfe deine Vorhersage</summary>

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.


</details>

### Eine konkrete Matrixmultiplikation [#eine-konkrete-matrixmultiplikation]

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

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

```python
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.

<details>
<summary>Prüfe deine Vorhersage</summary>

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.


</details>

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

```python
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 [#reshape-gegen-transpose]

```python
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:

```python
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 [#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]`: **B**atch (welches Beispiel), **T**ime (welche Tokenposition) und
**C**hannel, 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:

```python
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.

<details>
<summary>Prüfe deine Vorhersage</summary>

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


</details>

### Eine lineare Schicht: `x @ W + b` [#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]`:

```python
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:

```python
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.

<details>
<summary>Prüfe deine Vorhersage</summary>

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.


</details>

## Bauen und brechen [#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 [#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? [#wie-geht-es-weiter]

Weiter mit [F03 — Wahrscheinlichkeit und Loss](/de/foundations-03-probability).

<details>
<summary>Hinweis</summary>

`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](/de/foundations-01-python-numpy#testen-dass-falsche-eingaben-abgelehnt-werden)).


</details>

<details>
<summary>Referenzantwort</summary>

```python
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.


</details>

[← F01 — Python & NumPy](/de/foundations-01-python-numpy) · [F03 — Wahrscheinlichkeit & Loss →](/de/foundations-03-probability) · [Glossar](/de/glossary)
