Teil 2: Large Language Model Training - Ein praktischer Leitfaden

Einleitung

Dieser Artikel ist der zweite Teil einer dreiteiligen Serie über die Transformer-Architektur. Nachdem wir im ersten Teil die theoretischen Grundlagen der Transformer-Architektur gelegt haben, zeige ich dir hier, wie du ein eigenes Large Language Model (LLM) trainieren kannst. Während der erste Teil die Konzepte wie Attention-Mechanismen und Multi-Head Attention erklärt hat, fokussieren wir uns hier auf die praktische Umsetzung. Im dritten Teil werden wir dann tief in die Code-Details eintauchen und jede Zeile der Implementierung verstehen.

Der gesamte Quellcode zu dieser Serie ist verfügbar unter: https://github.com/ChristophKind/LargeLanguageModelsPublic

In diesem Artikel werde ich nicht auf die Implementierungsdetails eingehen - diese werden im dritten Teil ausführlich behandelt. Stattdessen konzentriere ich mich darauf, dir einen praktischen Weg zu zeigen: Wie du die Daten vorbereitest, das Modell trainierst und schließlich Text generierst.

Der gesamte Prozess ist in drei übersichtliche Shell-Skripte aufgeteilt, die du sequenziell ausführen kannst. Diese Struktur macht es einfach, den Workflow zu verstehen und bei Bedarf einzelne Schritte zu wiederholen oder anzupassen.

Wichtige Vorbemerkungen

Hardwareanforderungen

Das Training macht nur Sinn, wenn du über eine leistungsfähige Grafikkarte verfügst. Selbst mit einer RTX 4090 kann das vollständige Training über einen Tag dauern. Für erste Experimente kannst du die Trainingszeit verkürzen, indem du die Anzahl der Iterationen reduzierst, aber bedenke, dass dies die Qualität des Modells erheblich beeinträchtigt.

Als Mindestanforderung solltest du eine GPU mit mindestens 12GB VRAM haben. Mit weniger Speicher wirst du die Batch-Größe und möglicherweise die Modellgröße reduzieren müssen, was sowohl die Trainingszeit verlängert als auch die finale Qualität verschlechtert.

Realistische Erwartungen

Erwarte keine Wunder! Die großen Modelle wie GPT-4 oder GPT-5 werden auf riesigen GPU-Clustern über mehrere Wochen trainiert. Diese Systeme verwenden Tausende von High-End-GPUs, haben Zugang zu Terabytes an sorgfältig kuratierten Trainingsdaten und wurden von Teams von Experten über Monate hinweg optimiert. Unser Ziel ist es lediglich zu demonstrieren, dass die implementierte Transformer-Architektur funktioniert.

Was du von dem trainierten Modell erwarten kannst:

• Grammatikalisch einigermaßen korrekte Sätze
• Grundlegende Sprachstruktur und Syntax
• Einfache Wortassoziationen und Phrasen
• Erkennung grundlegender Satzmuster

Was du nicht erwarten solltest:

• Sinnvolle, kohärente Textfortsetzungen über mehrere Sätze
• Faktenwissen oder logisches Denken
• Mit ChatGPT vergleichbare Qualität
• Verlässliche Antworten auf Fragen
• Kreative oder originelle Texte

Das Training mit einer einzelnen Grafikkarte reicht gerade aus, um eine grobe Grammatik in das Sprachmodell einzuprogrammieren. Das Modell wird lernen, wie englische Sätze typischerweise aufgebaut sind, welche Wörter oft zusammen auftreten und wie man grundlegende grammatikalische Strukturen bildet. Alles darüber hinaus ist mit handelsüblicher Hardware nicht zu erreichen, ohne massiv in Grafikkarten und Zeit zu investieren.

Voraussetzungen

Software-Anforderungen

Bevor du beginnst, musst du die Python-Abhängigkeiten installieren. Ich empfehle dringend, ein Virtual Environment zu verwenden, um Konflikte mit anderen Python-Projekten zu vermeiden:

# Python Virtual Environment erstellen (optional aber empfohlen)
python3 -m venv venv
source venv/bin/activate  # Linux/Mac
# oder
venv\Scripts\activate  # Windows

# Requirements installieren
pip install -r requirements.txt

Die wichtigsten Pakete, die installiert werden:

• PyTorch: Das Deep Learning Framework für das Training
• NumPy: Für numerische Operationen
• Transformers: Hugging Face Bibliothek für Tokenisierung
• Datasets: Zum Laden und Verarbeiten der Trainingsdaten
• tqdm: Für Fortschrittsanzeigen
• wandb (optional): Für Experiment-Tracking

System-Voraussetzungen

Stelle sicher, dass du:

• Python 3.8 oder höher installiert hast
• Eine NVIDIA GPU mit CUDA-Unterstützung besitzt (CUDA 11.7 oder höher empfohlen)
• Mindestens 50GB freien Speicherplatz hast (für Daten und Checkpoints)
• 16GB RAM oder mehr für die Datenverarbeitung
• Eine stabile Internetverbindung für den Datendownload

Der Trainingsprozess in drei Schritten

Um den Prozess übersichtlich zu gestalten, habe ich die einzelnen Schritte in drei Shell-Skripte ausgelagert, die du einfach nacheinander aufrufen kannst. Jedes Skript hat eine klar definierte Aufgabe und kann unabhängig ausgeführt werden, sobald die Voraussetzungen erfüllt sind.

Schritt 1: Datenvorbereitung (prepare_data.sh)

Das erste Skript lädt den WikiText-103 Datensatz herunter und bereitet ihn für das Training vor. WikiText-103 ist ein standardisierter Benchmark-Datensatz, der aus hochwertigen Wikipedia-Artikeln besteht und speziell für das Training von Sprachmodellen entwickelt wurde.

./prepare_data.sh

Was passiert hier im Detail:

• Download des WikiText-103 Datensatzes (ca. 500MB komprimiert, 1.8GB entpackt)
• Automatische Extraktion und Verarbeitung der Textdateien
• Tokenisierung der Textdaten mit einem GPT-2 kompatiblen Tokenizer
• Aufteilung in Trainings- und Validierungsdaten
• Konvertierung in binäres Format für effizientes Training
• Erstellung von train.bin und val.bin im data/ Verzeichnis
• Speicherung von Metadaten über den Datensatz

Erwartete Ausgabe:

• Fortschrittsanzeige während des Downloads
• Tokenisierungsstatistiken (Anzahl der Tokens, Vokabulargröße)
• Information über die Größe der generierten Dateien
• Bestätigung der erfolgreichen Verarbeitung
• Dauer: 10-30 Minuten je nach Internetverbindung und CPU

Wichtige Parameter im Skript:

• Das Skript wählt automatisch WikiText-103 als Datensatz
• Block-Größe von 1024 Token für Kontextfenster
• GPT-2 Tokenizer mit 50257 Token Vokabular
• 90/10 Split für Training/Validierung

Falls die Daten bereits existieren, fragt das Skript, ob du sie neu generieren möchtest. Dies ist nützlich, wenn du mit verschiedenen Tokenisierungseinstellungen experimentieren möchtest.

Schritt 2: Modelltraining (start_train.sh)

Das zweite Skript startet das eigentliche Training des Modells. Hier passiert die eigentliche "Magie" - das neuronale Netzwerk lernt aus den vorbereiteten Daten, Sprachmuster zu erkennen und zu reproduzieren.

./start_train.sh

Was passiert hier im Detail:

• Überprüfung der GPU-Verfügbarkeit und VRAM
• Initialisierung eines GPT-2 Medium Modells (~350M Parameter) von Grund auf
• Laden der vorbereiteten Trainingsdaten in den Speicher
• Konfiguration des Optimizers (AdamW) und Learning Rate Schedulers
• Training mit regelmäßigen Checkpoints
• Regelmäßige Evaluierung auf dem Validierungsdatensatz
• Checkpoint-Speicherung bei Verbesserungen
• Logging von Metriken für spätere Analyse

Erwartete Ausgabe:

• GPU-Information und Speichernutzung zu Beginn
• Modellarchitektur-Zusammenfassung
• Trainingsfortschritt mit Loss-Werten (sollte von ~10 auf ~3-4 fallen)
• Evaluierungsergebnisse alle 100 Schritte
• Geschätzte verbleibende Zeit
• Checkpoint wird in out/my_own_llm.pt gespeichert

Wichtige Parameter erklärt:

• batch_size=8: Anzahl der Beispiele pro GPU-Durchlauf (bei OOM reduzieren)
• gradient_accumulation_steps=16: Simuliert größere Batches (effektiv 128)
• n_layer=24, n_head=16, n_embd=1024: GPT-2 Medium Architektur
• max_iters=50000: Maximale Trainingsschritte (für Tests auf 5000 reduzieren)
• learning_rate=6e-4: Startlernrate mit Cosine-Annealing
• warmup_iters=2000: Sanfter Start für stabiles Training
• dtype=bfloat16: Reduzierte Präzision für 2x Speichereinsparung
• compile=True: PyTorch 2.0 Kompilierung für 30% Speedup

Zeitaufwand:

• RTX 4090: 20-30 Stunden für 50000 Iterationen
• RTX 3090: 30-40 Stunden
• RTX 3070: 40-50 Stunden (mit reduzierter Batch-Größe)

Das Training kann jederzeit unterbrochen und vom letzten Checkpoint fortgesetzt werden.

Schritt 3: Textgenerierung (generate_text.sh)

Das letzte Skript verwendet das trainierte Modell zur Textgenerierung. Hier siehst du die Früchte deiner Arbeit - das Modell generiert eigenständig Text basierend auf einem Eingabe-Prompt.

./generate_text.sh

Was passiert hier im Detail:

• Laden des trainierten Modells aus dem Checkpoint
• Initialisierung des Tokenizers
• Verarbeitung des Eingabe-Prompts
• Autoregressieve Textgenerierung Token für Token
• Sampling mit Temperature und Top-K Filterung
• Dekodierung der generierten Token zurück in Text
• Formatierte Ausgabe des generierten Texts

Erwartete Ausgabe:

• Bestätigung des geladenen Modells
• Generierter Text beginnend mit "Bill Clinton was ..."
• 300 neue Token (etwa 200-250 Wörter)
• Generierungsgeschwindigkeit (Token/Sekunde)

Wichtige Parameter für die Generierung:

• start="Bill Clinton was ": Der Eingabe-Prompt (kannst du anpassen)
• max_new_tokens=300: Länge der generierten Ausgabe
• temperature=0.8: Balance zwischen Kreativität und Kohärenz (0.5-1.0)
• top_k=40: Begrenzt Auswahl auf wahrscheinlichste Token
• seed=42: Für reproduzierbare Ergebnisse

Du kannst das Skript beliebig oft mit verschiedenen Prompts und Parametern ausführen, um die Fähigkeiten und Grenzen deines Modells zu erkunden.

Typische Probleme und Lösungen

Out of Memory (OOM) Fehler

• Reduziere batch_size im Training-Skript (z.B. auf 4 oder 2)
• Verwende dtype=float16 statt bfloat16
• Reduziere die Modellgröße (weniger Layer oder Hidden Dimensions)
• Aktiviere Gradient Checkpointing für Speichereinsparung

Training dauert zu lange

• Reduziere max_iters für schnellere Tests (z.B. 5000)
• Verwende ein kleineres Modell (GPT-2 Small statt Medium)
• Aktiviere compile=True für PyTorch 2.0 Optimierungen
• Nutze Mixed Precision Training

Schlechte Textqualität

• Das ist normal! Siehe "Realistische Erwartungen" oben
• Trainiere länger (aber erwarte keine Wunder)
• Experimentiere mit Temperature (0.7-0.9) und Top-K (20-50)
• Verwende bessere/längere Prompts als Startpunkt
• Prüfe, ob der Loss während des Trainings gefallen ist

Training stagniert (Loss sinkt nicht)

• Überprüfe die Learning Rate (evtl. zu hoch oder zu niedrig)
• Stelle sicher, dass die Daten korrekt geladen werden
• Erhöhe die Batch-Größe für stabileres Training
• Prüfe auf Gradient Explosion oder Vanishing

Weiterführende Experimente

Sobald du das Basis-Setup zum Laufen gebracht hast, gibt es viele interessante Experimente:

• Andere Datensätze: Probiere OpenWebText oder BookCorpus
• Modellgrößen: Teste kleinere/größere Architekturen
• Fine-Tuning: Trainiere auf spezifischen Textarten
• Prompt Engineering: Experimentiere mit verschiedenen Eingaben
• Hyperparameter-Tuning: Optimiere Learning Rate, Batch Size, etc.

Fazit

Diese drei Skripte demonstrieren den vollständigen Workflow vom rohen Text bis zur Textgenerierung mit einem selbst trainierten Transformer-Modell. Auch wenn die Ergebnisse nicht mit kommerziellen Modellen mithalten können, zeigen sie doch, dass die grundlegende Architektur funktioniert und das Modell tatsächlich Sprachmuster lernt.

Denk daran: Dies ist ein Lernprojekt, kein Produktivsystem. Die wahre Leistung moderner LLMs entsteht durch:

• Milliarden statt Millionen von Parametern
• Wochen statt Tage Training
• Tausende statt einer GPU
• Terabytes statt Gigabytes an Trainingsdaten
• Teams von Experten statt Einzelpersonen

Trotzdem ist es faszinierend zu sehen, wie selbst mit begrenzten Ressourcen die Grundprinzipien der Sprachmodellierung funktionieren. Du hast nun ein funktionierendes Sprachmodell selbst trainiert und verstehst die grundlegenden Abläufe, die auch hinter ChatGPT und anderen kommerziellen Systemen stehen!