Bau dein eigenes PyTorch

Ein Framework wie PyTorch fühlt sich an wie ein Ort, an dem etwas passiert, das man nicht sehen kann. Man ruft loss.backward() auf, und plötzlich stehen Gradienten in den Gewichten. Solange dieser Aufruf Magie bleibt, bleibt jedes Trainingsproblem eine Sache des Ausprobierens.

Der Ausweg ist derselbe wie überall auf dieser Plattform: einmal selbst bauen. Du legst ein Verzeichnis meintorch/ an und füllst es in acht Schritten mit genau den Bauteilen, die ein Deep-Learning-Framework ausmachen: Tensor, Autograd, Schichten, Loss, Optimizer, Trainingsschleife, DataLoader. Am Ende trennt dein eigenes Framework einen Datensatz, den du ebenfalls selbst erzeugt hast, mit über 90 Prozent Genauigkeit. Kein import torch in der ganzen Strecke.

Das Vorbild ist Harvards TinyTorch aus dem mlsysbook. Übernommen ist davon allein die Methode, nicht der Stoff: Don't import it, build it.

Die Regel: Zero Magic

Eine einzige Regel hält den Kurs zusammen, und sie gilt in jedem Schritt.

Erlaubt ist NumPy. Array-Arithmetik, Matrixmultiplikation, Zufallszahlen. NumPy nimmt dir das Rechnen auf Zahlenfeldern ab, und genau das ist nicht der Punkt dieses Kurses.

Verboten sind torch, jax, tinygrad und autograd. Das sind die Bibliotheken, die dir die Bauteile abnehmen würden, um die es hier geht. Wer Autograd importiert, statt es zu schreiben, hat die eine Einsicht des Kurses umgangen.

Der Beweisschritt am Ende geht noch einen Schritt weiter: Auch der Datensatz kommt nicht aus einer Bibliothek. Die verschränkten Halbmonde, an denen sich dein Netz beweisen muss, erzeugst du in etwa zehn Zeilen NumPy selbst. Zero Magic gilt damit auch für die Daten.

Jeder Schritt endet mit einem Meilenstein-Test. Er ist keine Formalie, sondern die Abnahme: Solange er rot ist, geht es nicht weiter. Und weil jedes Bauteil auf dem vorigen steht, zeigt ein roter Test in Schritt 05 fast immer auf einen Denkfehler in Schritt 02.

Forward und Backward: die eine Dualität

Wer die acht Schritte in einem Satz zusammenfassen will, landet bei dieser Dualität. Jedes Bauteil, das du baust, kann zwei Dinge:

Vorwärts rechnet es aus Eingaben eine Ausgabe. Eine Schicht multipliziert mit ihren Gewichten, ReLU schneidet negative Werte ab, der Loss macht aus einem ganzen Vorhersagevektor eine einzige Zahl. Das ist der Teil, den man leicht hinschreibt.

Rückwärts rechnet dasselbe Bauteil aus einem eingehenden Gradienten die Gradienten seiner Eingaben. Es gibt die Frage „wie sehr bist du schuld?“ an seine Vorgänger weiter. Das ist der Teil, den man normalerweise nie sieht.

Autograd ist nichts anderes als die Buchführung darüber, in welcher Reihenfolge die Vorwärtsrechnungen passiert sind, damit man sie rückwärts wieder ablaufen kann. Deshalb steht Autograd im Fahrplan schon an zweiter Stelle, obwohl du es erst ab Schritt 05 wirklich benutzt: Alles, was danach kommt, steht darauf.

Zwei Modi: Coach und Goal

Dieselbe Strecke, zwei völlig verschiedene Arten, sie zu gehen. Beide bauen dasselbe Ziel-Repo und laufen gegen dieselben Meilenstein-Tests. Du kannst mittendrin wechseln, aber vermischen solltest du sie nicht.

Coach. Du schreibst den Kern selbst. Der Kurs stellt dir das Gerüst hin, in dem an den entscheidenden Stellen # TODO(du) steht, und einen Test, der noch rot ist. Ein Hinweis kommt auf Nachfrage, die Lösung nur auf ausdrücklichen Zuruf. Das Tempo bestimmst du. Das ist der Modus, für den dieser Kurs geschrieben wurde.

Goal. Der autonome Durchlauf. Ein Agent implementiert jedes Kapitel vollständig, schreibt und prüft den Test, verifiziert grün und zieht durch. Ein Befehl fährt die ganze Strecke am Stück. Nützlich als Referenzlösung, als zweiter Durchgang oder wenn du sehen willst, wie ein Agent eine achtstufige Aufgabe abarbeitet, ohne dass jemand dazwischenfunkt.

Die Brücke: Framework-Schleife und Agenten-Schleife

Dieser Kurs steht nicht zufällig auf einer Plattform über Agenten. Was du in Schritt 06 baust, ist eine Schleife, und sie hat dieselbe Gestalt wie die Schleife, die einen Agenten ausmacht.

Die Trainingsschleife lautet: Vorhersage rechnen, Fehler messen, Gradienten holen, Gewichte anpassen, von vorn. Die Agenten-Schleife lautet: Modell fragen, Werkzeug aufrufen, Ergebnis zurückgeben, von vorn. In beiden Fällen ist der Fortschritt nicht in einem einzelnen genialen Schritt versteckt, sondern in der Wiederholung eines sehr einfachen Schritts, dessen Zustand zwischen den Runden weitergereicht wird. In beiden Fällen steckt die eigentliche Arbeit nicht im klugen Teil, sondern in der Klempnerei drumherum: Daten hinein, Zustand weiterreichen, Abbruchbedingung.

Und in beiden Fällen ist das, was von außen wie eine Blackbox aussieht, ein paar Dutzend Zeilen, die man an einem Nachmittag selbst tippen kann. Wenn du die Trainingsschleife einmal geschrieben hast, liest sich der Baustein Tools und Loop wie ein alter Bekannter.

Was du brauchst

Der Code läuft auf deinem Rechner, nicht hier. Die Plattform liefert Anleitung, Fahrplan und Meilensteine.

• Python 3.10 oder neuer und NumPy. Mehr nicht.
• Ein leeres Verzeichnis meintorch/, in dem dein Framework entsteht.
• Etwa zweieinhalb Stunden, verteilt auf acht Sitzungen. Die Schritte sind so geschnitten, dass jeder für sich an einem Stück durchgehalten werden kann.
• Optional Claude Code. Dann bekommst du die Skill-Packs für beide Modi als Slash-Befehle dazu.

So machst du's lokal in Claude Code

Für jeden der beiden Modi gibt es ein Skill-Pack zum Herunterladen: ein Archiv mit Slash-Befehlen, dem Fortschrittsprotokoll PROGRESS.md und allen acht Meilenstein-Tests. Die Tests im Pack sind Zeichen für Zeichen dieselben, die hier in den Kapiteln stehen - beide Modi laufen gegen dieselbe Abnahme, und die Zero-Magic-Regel gilt im Pack genauso wie hier, bis hin zum Beweisschritt ohne scikit-learn.

Entpacken, Claude Code im entpackten Verzeichnis starten, losgehen. Der Ordner .claude/commands/ liegt schon richtig; du brauchst nichts einzurichten.