DEV Community

Cover image for ChatGPT trainieren: Eigene KI für 50 Euro erstellen
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

ChatGPT trainieren: Eigene KI für 50 Euro erstellen

TL;DR

nanochat ist Andrej Karpathys Open-Source LLM-Trainings-Framework, mit dem du für unter 50 US-Dollar in ca. 2 Stunden einen Chatbot auf GPT-2-Niveau trainierst. Das Projekt nutzt einen 8xH100 GPU-Knoten, minimalen Code (~500 Zeilen für das Kernmodell) und einen einzigen Regler (--depth), um alle Hyperparameter automatisch zu setzen. Aktuelle Aufzeichnungen: 1,65 Stunden Training, CORE-Wert 0,2626 – besser als GPT-2 von OpenAI, das 2019 43.000 $ und 168 Stunden kostete.

Probiere Apidog noch heute aus

Einführung

Das Training großer Sprachmodelle war früher Millionenprojekten und Forschungsteams vorbehalten. Diese Zeiten sind vorbei.

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

Warum das jetzt relevant ist

2026 hat sich das KI-Ökosystem radikal verändert. Was OpenAI 2019 168 Stunden und 43.000 $ gekostet hat, dauert nun 1,65 Stunden und 48 $. Verantwortlich: Algorithmische Verbesserungen, bessere Hardware, Community-Optimierung.

Für API-Entwickler und Teams, die KI-gestützte Anwendungen bauen, ist individuelles Modelltraining jetzt realistisch. Du kannst eigene Modelle trainieren, Architektur-Änderungen testen und LLM-Interna verstehen – ohne Enterprise-Budget.

💡 Kombiniere nanochat mit API-Entwicklungsplattformen wie Apidog zum Testen und Dokumentieren deiner KI-Dienste: So bekommst du einen vollständigen Stack für produktive KI-Anwendungen.

Was du aus diesem Artikel mitnimmst

  • Wie nanochat 100-fache Kostenreduktion beim LLM-Training erreicht
  • Die Architektur: GPT-Modell, Muon-Optimierer, Datenladen
  • Schritt-für-Schritt-Anleitung zum eigenen Modelltraining
  • Nutzung für schnelle KI-Experimente
  • Reale Einschränkungen und was "GPT-2-Fähigkeit" wirklich bedeutet

Was ist nanochat?

nanochat ist ein minimales LLM-Trainings-Framework mit vollständiger Pipeline: Tokenisierung, Vortraining, Finetuning, Evaluierung, Inferenz und ChatGPT-ähnliche Weboberfläche.

nanochat-Übersicht

Die Codebasis ist schlank, ein einziges Repository, kein Konfigurationswust oder Framework-Overhead. Ziel: Lesbar, hackbar, forkbar – eine starke, nachvollziehbare Baseline.

Die Kernidee

Trainiere ein GPT-2-ähnliches Modell (1,6B Parameter) für:

  • 48 $ On-Demand (2 Stunden × ~24$/h für 8xH100)
  • ~15 $ auf Spot-Instanzen

Zum Vergleich: GPT-2 (OpenAI, 2019) kostete 43.000 $ und brauchte 7 Tage auf 32 TPU v3-Chips.

nanochat deckt ab:

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 für alles

nanochat kommt ohne Konfigurations-Flut. Alles läuft über einen Parameter: --depth (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

# Noch größere Modelle
torchrun --standalone --nproc_per_node=8 -m scripts.base_train -- --depth=26
Enter fullscreen mode Exit fullscreen mode

Du stellst die Tiefe ein, nanochat berechnet:

  • Transformer-Breite (Embedding-Dimension)
  • Anzahl der Attention-Köpfe
  • Lernraten (pro Parametergruppe)
  • Trainingshorizont (Gesamtschritte)
  • Weight Decay
  • Batch-Größen

Diese "Ein-Regler"-Philosophie erzeugt eine ganze Modellfamilie, alle trainiert mit demselben Ansatz.

Warum das funktioniert

Das Team hat Skalierungsgesetze empirisch vermessen. Beziehungen zwischen Tiefe, Breite, Batchgröße und Trainingsdauer sind vorhersagbar; nanochat kodiert diese direkt ins Trainingsskript.

nanochat-Skalierungsgesetze

So bekommst du rechenoptimales Training ohne Deep-Learning-PhD.

Die Bestenliste: GPT-2 schlagen

nanochat führt eine öffentliche Bestenliste, die "Zeit bis GPT-2-Fähigkeit" trackt. Ziel: CORE-Wert von 0,256525 (OpenAI, 2019) auf 22 Aufgaben (ARC, MMLU, etc.) schlagen.

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 Initiale Baseline
Lauf 2 d26 2.91 Stunden 0.2578 FP8-Training
Lauf 3 d26 2.76 Stunden 0.2602 1M Token Batchgröß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 findet

Läufe 5 und 6 nutzen Karpathys "Auto-Research"-System: Ein KI-Agent erforscht Architekturänderungen an kleinen d12-Modellen (5-Minuten-Läufe) und überträgt erfolgreiche Änderungen aufs große Modell.

Optimiert wurden z.B.:

  • Backout-Mechanismus: Bessere Residualsubtraktion
  • Smear: Effizienteres Bigram-Mischen

Ergebnis: 19% schnellere Trainingszeit.

Wie funktioniert nanochat? – Die Komponenten

Die Kernmodule umfassen ca. 3.000 Zeilen. Hier die wichtigsten Bestandteile:

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

Architekturfeatures:

  • RoPE: Relative Positionskodierung
  • QK-Normalisierung: Training-Stabilität
  • Unverbundene Gewichte: Separate Token- und Output-Embeddings
  • ReLU²: Quadratisches ReLU statt GeLU
  • GQA: Grouped Query Attention (schnellere Inferenz)
  • Sliding Window Attention: Konfigurierbares Kontextmuster
  • Flash Attention 3: Optimiert für moderne GPUs

Wert-Embeddings (ResFormer):

# 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
Enter fullscreen mode Exit fullscreen mode

Weitere Effizienztricks:

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

# 2. Smear: Bigram-Gate
gate = self.smear_lambda * torch.sigmoid(self.smear_gate(x[:, :, :24]))
x = x + gate * x_pre_smear

# 3. Backout: Residual-Subtraktion
x = x - self.backout_lambda * x_backout
Enter fullscreen mode Exit fullscreen mode

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

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

Muon (Momentum Orthogonalized by Newton-Schulz):

# Polar Express Koeffizienten (5 Iterationen)
polar_express_coeffs = [
    (8.156, -22.483, 15.879),
    (4.043, -2.809, 0.500),
    # ...
]
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
Enter fullscreen mode Exit fullscreen mode

NorMuon Varianzreduktion:

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)
Enter fullscreen mode Exit fullscreen mode

Verteiltes Training: Sharding im ZeRO-2-Stil, dreiphasige Kommunikation:

Phase 1: reduce_scatter starten
Phase 2: Updates berechnen, all_gather starten
Phase 3: Gathers abwarten, Parameter zurückkopieren
Enter fullscreen mode Exit fullscreen mode

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

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

Die benutzerdefinierte Linear-Schicht erzwingt den Datentyp:

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

FP8-Training für H100+/Blackwell per --fp8 aktivierbar.

4. Datenladen (nanochat/dataloader.py)

  • BOS-ausgerichtete Best-Fit-Packung
  • Jedes Dokument beginnt mit BOS
  • Best-Fit-Algorithmus minimiert Padding
  • Notfalls Zuschneiden des kürzesten Dokuments
  • 100% Auslastung, ~35% Zuschneidung bei 2048 Tokens 
# Bestes passendes Dokument finden
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)
    # Komplette Hinzufügung
else:
    # Kürzestes Dokument zuschneiden
Enter fullscreen mode Exit fullscreen mode

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

Automatische Auswahl von FA3 oder PyTorch SDPA:

from nanochat.flash_attention import flash_attn

y = flash_attn.flash_attn_func(q, k, v, causal=True, window_size=window_size)
Enter fullscreen mode Exit fullscreen mode

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

  • KV-Cache: Prompt-Caching mit FA3
  • Tool Use: Python-Rechner via Token-Auslösung (eval())
  • Batch Generation: Parallele Stichproben möglich

Steuert Konversationsfluss und Tool-Outputs.

Schritt-für-Schritt: Eigenes Modell trainieren

Die komplette Pipeline ist in runs/speedrun.sh beschrieben. So geht's praktisch:

Voraussetzungen

  • 8xH100 GPU-Knoten (oder vergleichbar)
  • ~20 GB Speicherplatz für Daten
  • Python 3.10+
  • uv Paketmanager

Schritt 1: Umgebung einrichten 

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

# Virtuelle Umgebung
uv venv
source .venv/bin/activate

# Abhängigkeiten installieren
uv sync --extra gpu
Enter fullscreen mode Exit fullscreen mode

Schritt 2: Trainingsdaten herunterladen 

# ~2B Zeichen ClimbMix-Datensatz laden
python -m nanochat.dataset -n 170
# Lädt ~170 Shards à ~100MB = ~17GB
Enter fullscreen mode Exit fullscreen mode

Schritt 3: Tokenizer trainieren 

python -m scripts.tok_train
python -m scripts.tok_eval
Enter fullscreen mode Exit fullscreen mode

Tokenizer nutzt GPT-4-ähnliches Muster mit Byte-Fallback BPE. Training: ca. 10 Minuten.

Schritt 4: Basismodell vortrainieren 

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
Enter fullscreen mode Exit fullscreen mode

Parameter:

  • --depth=24: GPT-2-Size
  • --target-param-data-ratio=8: Schnelles Training
  • --device-batch-size=16: Batch pro GPU
  • --fp8: FP8-Training (nur H100+)

Erwarte ~2 Stunden Laufzeit.

Schritt 5: Überwachtes Finetuning 

curl -L -o ~/.cache/nanochat/identity_conversations.jsonl \
    https://karpathy-public.s3.us-west-2.amazonaws.com/identity_conversations.jsonl

torchrun --standalone --nproc_per_node=8 -m scripts.chat_sft -- \
    --device-batch-size=16 \
    --run=my-sft
Enter fullscreen mode Exit fullscreen mode

SFT bringt dem Modell Chat-Format, Spezial-Tokens und Tool-Nutzung bei.

Schritt 6: Mit dem Modell chatten 

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

# Web-UI starten
python -m scripts.chat_web
Enter fullscreen mode Exit fullscreen mode

Die Web-UI läuft auf Port 8000.

Forschungs-Workflow: Schnelle Experimente

Für Architekturtests kleine Modelle nutzen (d12, ~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
Enter fullscreen mode Exit fullscreen mode

Zu überwachende Metriken

In Weights & Biases:

  1. val_bpb: Validierungs-Bits pro Byte
  2. core_metric: DCLM CORE Score
  3. train/mfu: FLOPS-Auslastung
  4. train/tok_per_sec: Trainingsdurchsatz

Testanforderung

Jede Verbesserung muss auf allen Tiefen (d12–d26) funktionieren: Kein Overfitting!

Warum nanochat wichtig ist

Kostenzugänglichkeit

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

LLM-Training ist jetzt realistisch für:

  • Einzelentwickler
  • Startups
  • Hochschulkurse
  • Hobbyisten

Bildungswert

  • ~500 Zeilen: GPT-Modell
  • ~530 Zeilen: Optimierer
  • Kommentare zu Designentscheidungen
  • Keine versteckten Konfigurationen

Perfekt zum Lernen und Modifizieren.

Forschungsgeschwindigkeit

  • Hypothesen in Stunden statt Tagen testen
  • Mehr Iterationen pro Woche
  • Geringe Kosten auch bei Fehlschlägen
  • Community-Verbesserungen via Bestenliste

Transparenz

  • Skalierungsgesetze: dev/LOG.md
  • Ablationsstudien: GitHub Discussions
  • Volle Reproduzierbarkeit der Ergebnisse
  • Offenlegung von KI-Entdeckungen

Einschränkungen & Realitätscheck

Hardware

  • 48$-Preis setzt 8xH100-Zugang voraus
  • Lambda Labs: ~25$/h, RunPod: ~15$/h (Spot)
  • Gesamt: 2 Stunden Training + SFT = ~50–100 $

Fähigkeitsgrenze

nanochat erreicht GPT-2-Niveau (2019):

Was geht:

  • Grundlegende Konversation
  • Einfache Argumentation
  • Elementare Mathematik
  • Faktengedächtnis (begrenzt)

Was nicht geht:

  • Komplexe Reasoning-Aufgaben
  • Komplizierte Code-Generierung
  • Nuancierte Anweisungsbefolgung
  • Konkurrenz zu GPT-4, Claude, Gemini

Denke an "KI-Kindergartenkind".

Datenanforderungen

  • ~170 Daten-Shards
  • ~17 GB komprimiert (~2B Zeichen)
  • Ausreichend Speicherplatz/Bandbreite nötig

Metrik-Limitierung

CORE-Score misst 22 Aufgaben, aber nicht:

  • Reale Konversationsqualität
  • Domänenwissen
  • Nuancierte Instruktionen
  • Sicherheit/Ausrichtung

CORE-Varianz (Seed): ~0,016

FAQ

Wie viel kostet das Training?

Ca. 48 $ On-Demand (24 $/h × 2 h); Spot: ca. 15 $. SFT dauert ca. 30 Minuten zusätzlich.

Welche GPU brauche ich?

Mindestens eine moderne Datacenter-GPU (Einzel-GPU möglich, dauert 8× länger). Optimal: 8xH100/A100.

Wie lange dauert das Training?

1,65–3 Stunden (je nach Hardware/Konfiguration). Aktueller Rekord: 1,65 h für d24.

Was ist die CORE-Metrik?

CORE bewertet Modelle auf 22 Aufgaben (ARC, MMLU, etc.). GPT-2: 0,2565; nanochat: regelmäßig >0,26.

Geht das Training auf Einzel-GPU?

Ja, torchrun weglassen. Dauert 8× länger, gleiche Ergebnisse.

Welcher Datensatz wird genutzt?

ClimbMix (NVIDIA Web-Datensatz). Tokenizer trainiert auf ~2B Zeichen (erste ~8 Shards).

Läuft nanochat auf Apple Silicon?

Ja, via MPS (Float32). Training ist langsamer als CUDA, aber möglich.

Kann ich von Checkpoints weitermachen?

Ja, mit --resume-from-step=<step>. DataLoader-Zustand wird gespeichert.

Unterschied nanochat vs. nanoGPT?

nanoGPT: Nur Vortraining. nanochat: Tokenisierung, Vortraining, SFT, RLHF, Evaluation, Inferenz, Web-UI.

Fazit

nanochat beweist: LLM-Training geht heute ohne Großbudget oder Spezial-Infrastruktur. 2019: 43.000 $. Heute: < 50 $.

Der Wert geht über Kostenersparnis hinaus – die minimalistische, verständliche Codebasis und das "Ein-Regler"-Interface machen nanochat zu einem echten Forschungs- und Lernwerkzeug.

Wichtigste Erkenntnisse

  • 100× günstiger: 43.000 $ → 48 $ (GPT-2-Fähigkeit)
  • 100× schneller: 168 h → 1,65 h
  • Einziger Regler: --depth steuert alles
  • Komplette Pipeline: Tokenisierung bis Web-UI
  • Community-Driven: Öffentliche Bestenliste, ständige Verbesserungen

Nächste Schritte

Bereit, dein eigenes Modell zu trainieren? Starte mit dem nanochat-Repository und runs/speedrun.sh.

Für API-Entwickler: Das Verstehen und Anwenden moderner LLM-Trainings ist so zugänglich wie nie – die Einstiegshürde liegt jetzt auf Wochenendprojekt-Niveau.

Top comments (0)