Blog

ChatGPT trainieren: Eigene KI für 50 Euro erstellen

Ashley Innocent

Ashley Innocent

19 March 2026

ChatGPT trainieren: Eigene KI für 50 Euro erstellen

TL;DR

nanochat ist Andrej Karpathys Open-Source LLM-Trainings-Framework, mit dem Sie einen Chatbot auf GPT-2-Niveau für unter 50 US-Dollar in etwa 2 Stunden trainieren können. Das Projekt verwendet einen einzelnen 8xH100 GPU-Knoten, minimalen Code (~500 Zeilen für das Kernmodell) und einen Konfigurationsregler (--depth), um alle Hyperparameter automatisch zu optimieren. Aktuelle Aufzeichnungen zeigen den Abschluss des Trainings in 1,65 Stunden mit einem CORE-Wert von 0,2626, womit das GPT-2 von OpenAI aus dem Jahr 2019, das 43.000 US-Dollar kostete und 168 Stunden dauerte, übertroffen wird.

Einführung

Das Training eines großen Sprachmodells erforderte früher Millionen von Dollar und ein Team von promovierten Forschern. Diese Zeiten sind vorbei.

Andrej Karpathy hat kürzlich nanochat veröffentlicht, ein Open-Source-Projekt, das eine leistungsfähige konversationelle KI für weniger als die Kosten eines guten Abendessens trainiert. Die gesamte Pipeline läuft auf einem einzigen 8xH100 GPU-Knoten und ist in unter 2 Stunden abgeschlossen.

Warum dies jetzt wichtig ist

Die KI-Landschaft hat sich Anfang 2026 dramatisch verändert. Was OpenAI 2019 168 Stunden und 43.000 US-Dollar kostete, dauert jetzt 1,65 Stunden und 48 US-Dollar. Das ist eine 100-fache Beschleunigung, angetrieben durch algorithmische Verbesserungen, bessere Hardware und Community-Optimierung.

Für API-Entwickler und Teams, die KI-gestützte Anwendungen erstellen, ändert dies alles. Sie können jetzt mit benutzerdefiniertem Modelltraining experimentieren, architektonische Änderungen testen und LLM-Interna verstehen, ohne massive Infrastrukturbudgets.

💡
Kombinieren Sie dies mit API-Entwicklungsplattformen wie Apidog zum Testen und Dokumentieren Ihrer KI-Dienste, und Sie haben einen kompletten Stack zum Erstellen von produktiven KI-Anwendungen.
Schaltfläche

Was Sie lernen werden

Am Ende dieses Artikels werden Sie verstehen:

Was ist nanochat?

nanochat ist ein minimales LLM-Trainings-Framework, das die gesamte Entwicklungspipeline abdeckt: Tokenisierung, Vortraining, Finetuning, Evaluierung, Inferenz und eine ChatGPT-ähnliche Weboberfläche.

nanochat-Übersicht

Die Codebasis passt in ein einziges Repository ohne Konfigurationsmonster oder Framework-Komplexität. Karpathy entwarf es als eine „starke Baseline“, die lesbar, hackbar und forkbar ist.

Die Kernbehauptung

Trainieren Sie ein GPT-2-fähiges Modell (1,6 Milliarden Parameter) für:

Zum Vergleich: Das ursprüngliche GPT-2-Training von OpenAI im Jahr 2019 kostete etwa 43.000 US-Dollar und dauerte 7 Tage auf 32 TPU v3-Chips.

Was nanochat abdeckt

Phase Skript Beschreibung
Tokenisierung scripts.tok_train BPE-Tokenizer trainieren (Vokabular 32.768)
Vortraining scripts.base_train Basales GPT-Modell trainieren
Finetuning scripts.chat_sft Überwachtes Finetuning für Chat
Evaluierung scripts.base_eval CORE-Metrik, Bits pro Byte
Inferenz scripts.chat_cli CLI-Chat-Oberfläche
Web-UI scripts.chat_web ChatGPT-ähnliche Weboberfläche

Die Philosophie: Ein Regler, um alles zu steuern

Die meisten LLM-Frameworks überfluten Sie mit Konfigurationsdateien. nanochat verfolgt den gegenteiligen Ansatz.

Das gesamte System dreht sich um einen Parameter: --depth (die Anzahl der Transformer-Schichten).

# GPT-1 großes Modell
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=12

# GPT-2 fähiges Modell
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=24

# Die Grenzen ausreizen
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26

Stellen Sie die Tiefe ein, und nanochat berechnet alles andere automatisch:

Diese „Ein-Regler“-Philosophie ermöglicht das, was Karpathy die nanochat-Miniserie nennt: eine Familie von rechenoptimierten Modellen unterschiedlicher Größe, die alle mit dem gleichen prinzipiellen Ansatz trainiert wurden.

Warum das funktioniert

Das Team maß Skalierungsgesetze über Dutzende von Trainingsläufen hinweg. Sie fanden vorhersagbare Beziehungen zwischen Tiefe, Breite, Batch-Größe und Trainingsdauer. Anstatt all diese Regler freizulegen, kodiert nanochat diese Beziehungen direkt in das Trainingsskript.

nanochat-Skalierungsgesetze

Sie erhalten ein rechenoptimales Training, ohne einen Doktortitel in Deep Learning zu benötigen.

Die Bestenliste: Wettlauf um GPT-2 zu schlagen

nanochat führt eine öffentliche Bestenliste, die die „Zeit bis zur GPT-2-Fähigkeit“ verfolgt. Das Ziel ist es, den ursprünglichen CORE-Wert von OpenAI von 0,256525 bei 22 Bewertungsaufgaben (ARC, MMLU und andere aus der DCLM-Benchmark-Suite) zu übertreffen.

Aktuelle Rekorde

Lauf Modell Zeit CORE-Wert Schlüsselinnovation
Original GPT-2 1.6B 168 Stunden 0.2565 OpenAI 2019 Baseline
Lauf 1 d24 3.04 Stunden 0.2585 Anfängliche Baseline
Lauf 2 d26 2.91 Stunden 0.2578 FP8-Training
Lauf 3 d26 2.76 Stunden 0.2602 1M Token Batch-Größe
Lauf 4 d24 2.02 Stunden 0.2571 ClimbMix-Datensatz
Lauf 5 d24 1.80 Stunden 0.2690 KI-entdeckte Optimierungen
Lauf 6 d24 1.65 Stunden 0.2626 Verbesserte Smear/Backout

Wie KI Optimierungen entdeckte

Läufe 5 und 6 beinhalteten Änderungen aus Karpathys „Auto-Research“-System. Ein KI-Agent erforschte architektonische Modifikationen an kleinen d12-Modellen (5-minütige Trainingsläufe) und übertrug dann die erfolgreichen Änderungen auf das vollständige d24-Setup.

Das System fand Verbesserungen für:

Diese Änderungen reduzierten die Trainingszeit von 2,02 Stunden auf 1,65 Stunden, eine 19%ige Verbesserung, die durch autonome Experimente entdeckt wurde.

Wie nanochat funktioniert

Die Codebasis umfasst ungefähr 3.000 Zeilen in den Kernmodulen. Betrachten wir jede Komponente.

1. Das GPT-Modell (nanochat/gpt.py)

Der Transformer folgt modernen Best Practices mit mehreren Optimierungen:

Architekturmerkmale:

Wert-Embeddings (ResFormer):Abwechselnde Schichten enthalten lernbare Wert-Embeddings, die über eingabeabhängiges Gating gemischt werden:

# Wert-Residual: Mischen von Wert-Embeddings mit Gate pro Kopf
if ve is not None:
    ve = ve.view(B, T, self.n_kv_head, self.head_dim)
    gate = 3 * torch.sigmoid(self.ve_gate(x[..., :self.ve_gate_channels]))
    v = v + gate.unsqueeze(-1) * ve

Dies erhöht die Kapazität ohne nennenswerten Rechenaufwand.

Effizienztricks:

Das Modell enthält drei gelernte Mechanismen, die die Trainingsdynamik verbessern:

# 1. Residual-Skalierung pro Schicht
x = self.resid_lambdas[i] * x + self.x0_lambdas[i] * x0

# 2. Smear: Mischen des vorherigen Token-Embeddings für Bigram-Informationen
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear

# 3. Backout: Subtrahieren des Residuals in der mittleren Schicht
x = x - self.backout_lambda * x_backout

2. Der Muon-Optimierer (nanochat/optim.py)

nanochat verwendet eine gemischte Optimierungsstrategie:

Parametertyp Optimierer Zweck
Embeddings, lm_head AdamW Standard adaptive Optimierung
Skalare Parameter AdamW Gelernte Skalierungsfaktoren
2D-Matrizen Muon Orthogonalisierte Updates

Muon (Momentum Orthogonalized by Newton-Schulz):

Der Muon-Optimierer orthogonalisiert Gewichtsaktualisierungen mithilfe einer quintischen Newton-Schulz-Iteration namens „Polar Express“:

# Polar Express Koeffizienten (5 Iterationen)
polar_express_coeffs = [
    (8.156, -22.483, 15.879),
    (4.043, -2.809, 0.500),
    # ... weitere Koeffizienten
]

# Orthogonalisierungs-Schleife
for a, b, c in polar_express_coeffs[:ns_steps]:
    A = X.mT @ X
    B = b * A + c * (A @ A)
    X = a * X + X @ B

NorMuon Varianzreduktion:

Nach der Orthogonalisierung werden die Updates pro Neuron normalisiert, um einen Skalierungszusammenbruch zu verhindern:

v_mean = g.float().square().mean(dim=red_dim, keepdim=True)
v_norm = v_mean.sum(dim=(-2, -1), keepdim=True).sqrt()
final_scale = step_size * (v_norm / v_norm_new.clamp_min(1e-10))
g = g * final_scale.to(g.dtype)

Verteiltes Training:

Für Multi-GPU-Setups implementiert der Optimierer Sharding im ZeRO-2-Stil mit dreiphasiger asynchroner Kommunikation:

Phase 1: Alle asynchronen reduce_scatter Operationen starten
Phase 2: Auf Reduktionen warten, Updates berechnen, all_gathers starten
Phase 3: Auf Gathers warten, aktualisierte Parameter zurückkopieren

Dies überlappt die Kommunikation mit der Berechnung und maximiert die GPU-Auslastung.

3. Präzisionsverwaltung (nanochat/common.py)

nanochat verwaltet die Präzision explizit, anstatt torch.amp.autocast zu verwenden:

Hardware Standard-Datentyp Grund
CUDA SM 80+ (A100, H100) bfloat16 Native BF16 Tensor Cores
CUDA SM < 80 (V100, T4) float32 Keine BF16-Unterstützung
CPU / MPS float32 Keine reduzierten Präzisionskerne

Die benutzerdefinierte Linear-Schicht wandelt Gewichte während des Forward-Passes um, um dem Berechnungs-Datentyp zu entsprechen:

class Linear(nn.Linear):
    def forward(self, x):
        return F.linear(x, self.weight.to(dtype=x.dtype))

Die Master-Gewichte bleiben für die Optimierungspräzision in FP32. Für H100- und Blackwell-GPUs ist FP8-Training über --fp8 verfügbar, wodurch die meisten Schichten in Float8Linear mit tensorweiser Skalierung konvertiert werden.

4. Datenladen (nanochat/dataloader.py)

Der DataLoader verwendet BOS-ausgerichtete Best-Fit-Packung:

Dies stellt sicher, dass jedes Token auf BOS zurückgreifen und den vollständigen Dokumentkontext sehen kann.

# Größtes Dokument finden, das vollständig passt
best_idx = -1
best_len = 0
for i, doc in enumerate(doc_buffer):
    doc_len = len(doc)
    if doc_len <= remaining and doc_len > best_len:
        best_idx = i
        best_len = doc_len

if best_idx >= 0:
    doc = doc_buffer.pop(best_idx)
    # Vollständiges Dokument hinzufügen
else:
    # Kürzestes Dokument zuschneiden, um den verbleibenden Platz zu füllen

5. Flash-Attention-Vereinheitlichung (nanochat/flash_attention.py)

Das Projekt bietet eine einheitliche Schnittstelle, die automatisch zwischen FA3 und PyTorch SDPA wechselt:

from nanochat.flash_attention import flash_attn

# Funktioniert auf jeder Hardware – wählt automatisch das beste Backend aus
y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)

Auf Hopper-GPUs mit bfloat16 wird Flash Attention 3 verwendet. Überall sonst wird auf PyTorchs skalierte Dot-Product-Attention zurückgegriffen.

6. Inferenz-Engine (nanochat/engine.py)

Die Engine-Klasse verwaltet die effiziente Generierung mit:

Die Engine koordiniert den Konversationsfluss, einschließlich des Erzwingens von Tool-Output-Tokens, wenn das Modell den Rechner aufruft.

Schritt-für-Schritt: Trainieren Sie Ihr eigenes Modell

Die gesamte Pipeline befindet sich in runs/speedrun.sh. So führen Sie sie aus.

Voraussetzungen

Schritt 1: Umgebung einrichten

# uv installieren
curl -LsSf https://astral.sh/uv/install.sh | sh

# Virtuelle Umgebung erstellen und aktivieren
uv venv
source .venv/bin/activate

# Abhängigkeiten installieren
uv sync --extra gpu

Schritt 2: Trainingsdaten herunterladen

# ~2B Zeichen vom ClimbMix-Datensatz herunterladen
python -m nanochat.dataset -n 170

# Dies lädt ~170 Shards mit je ~100MB herunter
# Gesamt: ~17 GB komprimiert

Das Skript lädt Vortrainingsdaten-Shards mit Dateisperren herunter, um die Koordination mehrerer Ränge zu handhaben.

Schritt 3: Den Tokenizer trainieren

# BPE-Tokenizer mit 32.768 Vokabular trainieren
python -m scripts.tok_train

# Komprimierungsverhältnis evaluieren
python -m scripts.tok_eval

Der Tokenizer verwendet ein Aufteilungsmuster im GPT-4-Stil mit Byte-Fallback BPE. Das Training dauert etwa 10 Minuten bei 2 Milliarden Zeichen.

Schritt 4: Das Basismodell vortrainieren

# d24 Modell trainieren (GPT-2-Fähigkeit)
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
    --depth=24 \
    --target-param-data-ratio=8 \
    --device-batch-size=16 \
    --fp8 \
    --run=my-first-model

Schlüsselparameter:

Erwartete Laufzeit: ~2 Stunden.

Schritt 5: Überwachtes Finetuning

# Identitätsgespräche herunterladen
curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
    https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl

# SFT für Chat-Fähigkeit ausführen
torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft

Dies lehrt das Modell das Konversationsformat, spezielle Token und die Tool-Nutzung.

Schritt 6: Mit Ihrem Modell chatten

# CLI-Chat
python -m scripts.chat_cli -p "Warum ist der Himmel blau?"

# Oder Web-UI starten
python -m scripts.chat_web

Die Web-UI läuft auf Port 8000 und bietet eine ChatGPT-ähnliche Oberfläche.

Forschungs-Workflow: Schnelle Experimente

Verwenden Sie für das Testen neuer Ideen kleinere Modelle für eine schnellere Iteration.

Schnelle Experimente (~5 Minuten)

OMP_NUM_THREADS=1 torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- \
    --depth=12 \
    --run="d12-test" \
    --core-metric-every=999999 \
    --sample-every=-1 \
    --save-every=-1

Dies trainiert ein d12-Modell (GPT-1-Größe) mit minimaler Protokollierung. Perfekt zum Testen architektonischer Änderungen.

Zu überwachende Metriken

Verfolgen Sie diese in Weights & Biases:

  1. val_bpb: Validierungs-Bits pro Byte (vokabulargrößenunabhängiger Verlust)
  2. core_metric: DCLM CORE Bewertungs-Score
  3. train/mfu: Modell-FLOPS-Auslastung (Hardware-Effizienz)
  4. train/tok_per_sec: Trainingsdurchsatz

Testanforderungen

Jede Verbesserung muss über alle Tiefen (d12 bis d26) funktionieren. Dies verhindert ein Overfitting an eine einzelne Modellgröße und gewährleistet prinzipielle Fortschritte.

Warum nanochat wichtig ist

Kostenzugänglichkeit

Ansatz Kosten Zeit Hardware
OpenAI GPT-2 (2019) 43.000 $ 168 Stunden 32 TPU v3
nanochat (2026) 48 $ 2 Stunden 8xH100
nanochat Spot ~15 $ 2 Stunden 8xH100 Spot

Dies macht LLM-Training erreichbar für:

Bildungswert

Die Codebasis dient als Lernressource:

Studenten können eine vollständige LLM-Pipeline lesen, ändern und damit experimentieren.

Forschungsgeschwindigkeit

Die Reduzierung der Trainingszeit von Tagen auf Stunden ermöglicht:

Transparenz

Jede Designentscheidung ist dokumentiert:

Einschränkungen und Realitätscheck

nanochat ist beeindruckend, hat aber klare Grenzen.

Hardware-Anforderungen

Die 48-Dollar-Angabe setzt den Zugang zu einem 8xH100-Knoten voraus. Die Mietkosten in der Cloud variieren:

Für einen vollständigen Lauf benötigen Sie je nach Anbieter ~50-100 US-Dollar.

Fähigkeitsobergrenze

nanochat erreicht GPT-2-Leistungsniveau (Technologie von 2019). Das bedeutet:

Was es kann:

Was es nicht kann:

Stellen Sie es sich wie einen Kindergartenkind vor: fähig zu grundlegender Konversation, aber nicht zu Expertenarbeit.

Datenanforderungen

Der vollständige Speedrun lädt herunter:

Sie benötigen ausreichend Speicherplatz und Bandbreite.

Metrik-Einschränkungen

Der CORE-Score misst 22 Aufgaben, erfasst aber nicht:

Verschiedene zufällige Seeds erzeugen eine CORE-Varianz von ~0,016. Ihre Ergebnisse können abweichen.

FAQ

Wie viel kostet es, ein Modell mit nanochat zu trainieren?

Ungefähr 48 US-Dollar bei Bedarf (24 US-Dollar/Stunde × 2 Stunden) oder ~15 US-Dollar auf Spot-Instanzen. Dies deckt nur das Vortraining ab. Für SFT kommen etwa 30 Minuten hinzu.

Welche GPU benötige ich?

Minimum: Einzel-GPU (jede moderne Rechenzentrums-GPU). Optimal: 8xH100 oder 8xA100 für schnellstes Training. Der Code skaliert von 1 GPU auf 8 GPUs mit automatischer Gradientenakkumulation.

Wie lange dauert das Training?

1,65 bis 3 Stunden, abhängig von Konfiguration und Hardware. Der aktuelle Bestenlistenrekord liegt bei 1,65 Stunden für ein d24-Modell.

Was ist die CORE-Metrik?

Der DCLM CORE Score bewertet Modelle anhand von 22 Aufgaben, darunter ARC (Wissenschaftsfragen), MMLU (Multitask Language Understanding) und andere Benchmarks. GPT-2 erreichte 0,256525. nanochat überschreitet regelmäßig 0,26.

Kann ich auf einer einzelnen GPU trainieren?

Ja. Lassen Sie torchrun weg, und der Code verwendet automatisch die Gradientenakkumulation. Das Training dauert 8-mal länger, liefert aber nahezu identische Ergebnisse.

Welchen Datensatz verwendet nanochat?

Die derzeit beste Version verwendet ClimbMix (NVIDIAs kuratierter Web-Datensatz). Frühere Versionen verwendeten FineWeb-EDU. Der Tokenizer trainiert auf ~2 Milliarden Zeichen aus den ersten ~8 Shards.

Funktioniert nanochat auf Apple Silicon?

Ja. Der Code läuft auf MPS (Metal Performance Shaders) mit Float32-Genauigkeit. Das Training ist langsamer als CUDA, aber für Experimente funktionsfähig.

Kann ich das Training von einem Checkpoint fortsetzen?

Ja. Verwenden Sie --resume-from-step=<step>, um von einem gespeicherten Checkpoint fortzufahren. Der Zustand des Datenladers wird ebenfalls für eine exakte Fortsetzung gespeichert.

Was ist der Unterschied zwischen nanochat und nanoGPT?

nanoGPT deckte nur das Vortraining ab. nanochat erweitert dies auf die gesamte Pipeline: Tokenisierung, Vortraining, SFT, RLHF, Evaluierung, Inferenz und Web-UI.

Fazit

nanochat beweist, dass LLM-Training keine massiven Budgets oder spezialisierte Infrastruktur mehr erfordert. Was 2019 43.000 US-Dollar kostete, kostet heute unter 50 US-Dollar.

Der Einfluss des Projekts geht über die reine Kostenreduzierung hinaus. Durch die Bereitstellung einer minimalen, lesbaren Codebasis mit einer „Ein-Regler“-Oberfläche hat Karpathy sowohl ein Forschungswerkzeug als auch eine Bildungsressource geschaffen.

Wichtigste Erkenntnisse

Nächste Schritte

Bereit, Ihr eigenes Modell zu trainieren? Beginnen Sie mit dem nanochat-Repository und dem Skript runs/speedrun.sh.

Für API-Entwickler, die KI-gestützte Anwendungen erstellen, war das Verständnis der internen Abläufe des LLM-Trainings noch nie so zugänglich. Die Einstiegshürde ist von „Risikokapital-finanziertes Startup“ auf „Wochenendprojekt“ gesunken.

Schaltfläche

Praktizieren Sie API Design-First in Apidog

Entdecken Sie eine einfachere Möglichkeit, APIs zu erstellen und zu nutzen

Kostenlos registrierenDownload