Der vollständige technische Leitfaden zu großen Sprachmodellen — von der Umwandlung von Rohtext in Zahlen über die Transformer-Architektur und den Attention-Mechanismus bis hin zu Training, Alignment, Inferenz, RAG und Produktionsbereitstellung. Kein Drumherumreden; echte Gleichungen und echter Code.
Ein großes Sprachmodell (LLM) ist ein neuronales Netz, das darauf trainiert wird, das nächste Token in einer Textsequenz vorherzusagen. Dieses einzige Ziel — die Vorhersage des nächsten Tokens — erweist sich als außerordentlich mächtig: Um gut vorherzusagen, muss das Modell Grammatik, Fakten, Denkmuster, Code-Syntax und vieles mehr lernen.
Das „groß“ bezieht sich auf die Anzahl der Parameter (Milliarden bis Billionen gelernter Gewichte) und den Umfang der Trainingsdaten (Billionen Tokens aus dem Web, Büchern und Code). Bei ausreichender Skalierung zeigen Modelle emergente Fähigkeiten — Fähigkeiten, die in kleineren Modellen nicht vorhanden und nicht explizit trainiert sind, etwa mehrstufige Arithmetik, analoges Schließen und In-Context-Learning aus einer Handvoll Beispiele.
Architektonisch ist jedes große LLM heute ein decoder-only Transformer (GPT-Familie, Llama, Mistral, Claude, Gemini). Das Modell nimmt eine Sequenz von Token-IDs als Eingabe und erzeugt eine Wahrscheinlichkeitsverteilung über das Vokabular für das nächste Token. Die Generierung ist autoregressiv: Das Modell sampelt ein Token, hängt es an die Sequenz an und wiederholt den Vorgang.
graph LR A[Input Text] --> B[Tokenizer] B --> C[Token IDs] C --> D[Embedding Layer] D --> E[Transformer Blocks xN] E --> F[LM Head] F --> G[Logits over Vocabulary] G --> H[Softmax + Sampling] H --> I[Next Token] I -->|Autoregressive loop| C
Fähigkeiten, die erst oberhalb bestimmter Skalierungsschwellen auftauchen — Few-Shot-Learning, Chain-of-Thought-Reasoning, Befolgen von Anweisungen — und die nicht explizit trainiert wurden.
Das Modell passt sein Verhalten anhand von Beispielen im Prompt (Few-Shot) an, ohne jegliche Gewichtsaktualisierungen. Das Kontextfenster ist während der Inferenz der einzige „Speicher“.
Die Modellgewichte kodieren eine verlustbehaftete Kompression des Trainingskorpus. Fakten werden nicht wortwörtlich gespeichert — sie sind über Milliarden von Gewichten verteilt, weshalb es zu Halluzinationen kommt.
LLMs operieren nicht auf Zeichen oder Wörtern — sie operieren auf Tokens, Teilworteinheiten, die von einem auf demselben Korpus trainierten Tokenizer erzeugt werden. Das Verständnis der Tokenization erklärt Kosten, Kontextlänge und viele Eigenheiten des Modellverhaltens.
GPT-2, GPT-3, GPT-4o, Llama 4, Mistral Large 3
Verschmilzt iterativ das häufigste benachbarte Byte- oder Zeichenpaar. Beginnt bei einzelnen Bytes und verarbeitet daher jeden Unicode-Text ohne unbekannte Tokens.
BERT, DistilBERT, ALBERT
Ähnlich wie BPE, aber die Verschmelzungen werden so gewählt, dass die Likelihood der Trainingsdaten unter einem Sprachmodell maximiert wird, statt der reinen Häufigkeit.
T5, Gemma, Qwen
Behandelt Tokenization als probabilistisches Segmentierungsproblem. Sprachunabhängig — funktioniert auf Rohtext ohne Vor-Tokenization (Leerzeichen werden als normale Zeichen behandelt).
| Wort | GPT-4o-Tokens | Token-Anzahl |
|---|---|---|
| transformer | transformer | 2 |
| tokenization | tokenization | 2 |
| def calculate_loss(logits): | def calculate_loss(logits): | 6 |
| Üniversität | Üniversität | 4 |
| hello | hello | 1 |
| (3 spaces) | 1 |
| Modell | Tokenizer | Vokabulargröße | Hinweis |
|---|---|---|---|
| GPT-2 | BPE | 50,257 | Byte-Level-BPE |
| GPT-3 / GPT-3.5 | BPE (cl100k) | 100,277 | Identisch mit GPT-4 |
| GPT-4 / GPT-4o | BPE (o200k) | 200,019 | Besser mehrsprachig |
| Llama 3.x / 4.x | BPE (tiktoken) | 128,256 | Verbessert gegenüber den 32k von Llama 2 |
| Mistral v0.x | BPE (SentencePiece) | 32,768 | Klein, aber effizient |
| Gemma 2 | SentencePiece | 256,000 | Sehr großes mehrsprachiges Vokabular |
import tiktoken
# GPT-4o uses the o200k_base encoding
enc = tiktoken.get_encoding("o200k_base")
text = "Tokenization is the first step in every LLM pipeline."
tokens = enc.encode(text)
print(f"Token IDs: {tokens}")
# Token IDs: [5808, 2065, 374, 279, 1176, 3094, 304, 1475, 445, 11237, 15598, 13]
print(f"Token count: {len(tokens)}") # 12
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")
# ['Token', 'ization', ' is', ' the', ' first', ' step', ' in', ' every', ' L', 'LM', ' pipeline', '.']
# Cost estimation: GPT-4o input = $2.50 / 1M tokens
cost_per_token = 2.50 / 1_000_000
print(f"Cost for this sentence: ${cost_per_token * len(tokens):.8f}")Eingeführt in „Attention Is All You Need“ (Vaswani et al., 2017), ersetzte der Transformer rekurrente Netze durch eine vollständig auf Attention basierende Architektur. Jedes große LLM heute baut auf diesem Fundament auf.
graph TD A[Input Tokens] --> B[Token Embeddings] B --> C[+ Positional Encoding] C --> D[Multi-Head Self-Attention] D --> E[Add and Layer Norm] E --> F[Feed-Forward Network] F --> G[Add and Layer Norm] G --> H[Next Block or Output]
Die Kernidee des Transformers: Jedes Token kann gleichzeitig auf jedes andere Token in der Sequenz achten. Aus einer Eingabematrix X erzeugen drei gelernte Projektionen Queries (Q), Keys (K) und Values (V):
Multi-Head-Attention führt H unabhängige Attention-Operationen parallel aus, jede mit anderen gelernten Projektionen. Dadurch kann das Modell gemeinsam auf Informationen aus verschiedenen Repräsentations-Unterräumen achten. GPT-3 nutzt 96 Attention-Heads; Llama 4 Maverick nutzt Grouped-Query-Attention (GQA) für effizientes Serving.
import torch
import torch.nn.functional as F
def scaled_dot_product_attention(Q, K, V, mask=None):
"""
Q, K, V: (batch, heads, seq_len, head_dim)
Returns: (batch, heads, seq_len, head_dim)
"""
d_k = Q.size(-1)
# Compute attention scores
scores = torch.matmul(Q, K.transpose(-2, -1)) / (d_k ** 0.5) # (batch, heads, seq, seq)
# Apply causal mask (decoder: attend only to past tokens)
if mask is not None:
scores = scores.masked_fill(mask == 0, float('-inf'))
# Softmax over key dimension
attn_weights = F.softmax(scores, dim=-1)
# Weighted sum of values
return torch.matmul(attn_weights, V), attn_weightsJeder Transformer-Block enthält ein zweischichtiges MLP, das unabhängig auf jede Token-Position angewendet wird. Die versteckte Dimension beträgt typischerweise das 4-Fache der Modelldimension (z. B. d_model=4096, d_ff=16384 für ein typisches Modell der 8B-Klasse). Moderne LLMs nutzen die SwiGLU-Aktivierung (eine gegatete Variante von SiLU), die ReLU und GELU empirisch übertrifft.
FFN-Schichten speichern den Großteil des Faktenwissens eines Modells — Forschung zeigt, dass im FFN konzentrierte „Wissensneuronen“ lokalisiert und chirurgisch editiert werden können (siehe ROME/MEMIT). Attention übernimmt Routing und Komposition; FFN-Schichten übernehmen die Speicherung.
Jede Teilschicht (Attention, FFN) nutzt eine Residualverbindung (output = x + sublayer(x)) und Layer-Normalisierung. Moderne LLMs nutzen Pre-Norm (Normalisierung vor der Teilschicht) statt Post-Norm für die Trainingsstabilität sowie RMSNorm (Root-Mean-Square-Norm, ohne Mittelwertzentrierung) für die Effizienz.
| Typ | Beispiele | Attention | Am besten für |
|---|---|---|---|
| Encoder-only | BERT, RoBERTa, DeBERTa | Bidirektional (volle Attention) | Klassifikation, NER, Embeddings |
| Decoder-only | GPT-4o, Llama 4, Mistral Large 3, Claude Sonnet 4.6 | Kausal (von links nach rechts) | Textgenerierung, Chat, Reasoning |
| Encoder-Decoder | T5, FLAN-T5, BART | Voller Encoder + Cross-Attention | Übersetzung, Zusammenfassung, seq2seq |
Pretraining ist die teuerste Phase — typischerweise über 95 % der gesamten Rechenleistung. Das Modell sieht Billionen von Tokens und lernt, das nächste vorherzusagen. Dieses einfache Ziel erzeugt bei ausreichender Skalierung die meisten Fähigkeiten, die wir mit LLMs verbinden.
Gegeben eine Sequenz von Tokens [t₁, t₂, ..., tₙ], wird das Modell darauf trainiert, die Log-Likelihood jedes Tokens bedingt auf alle vorhergehenden Tokens zu maximieren:
Jeder Vorwärtsdurchlauf verarbeitet eine vollständige Sequenz und erzeugt parallel an jeder Position einen Loss (Teacher Forcing). Bei der Inferenz werden Tokens autoregressiv erzeugt, eines nach dem anderen.
Hoffmann et al. (2022) zeigten, dass frühere große Modelle (GPT-3, Gopher) untertrainiert waren — zu viele Parameter für zu wenige Tokens. Das optimale Chinchilla-Verhältnis lautet:
Optimale Tokens ≈ 20× Parameter
Ein Modell mit 7B Parametern sollte für rechenoptimales Training auf ~140B Tokens trainiert werden. In der Praxis trainieren Modelle auf weit mehr (Llama 3.1 8B: 15T Tokens; Llama-4-Modelle: ~40T gesch.), weil die Inferenzkosten ins Gewicht fallen — ein kleineres, aber stärker trainiertes Modell ist günstiger im Betrieb.
| Modell | Parameter | Trainings-Tokens | Jahr |
|---|---|---|---|
| GPT-2 | 117M – 1.5B | ~10B | 2019 |
| GPT-3 | 175B | ~300B | 2020 |
| Chinchilla | 70B | 1.4T | 2022 |
| Llama 2 (historical) | 7B – 70B | 2T | 2023 |
| Mistral 7B | 7.3B | ~8T (est.) | 2023 |
| Llama 3.1 8B | 8B | 15T | 2024 |
| Llama 3.1 405B | 405B | 15T | 2024 |
| Llama 4 Scout | ~17B active (MoE) | ~40T (est.) | 2025 |
| Llama 4 Maverick | ~17B active (MoE) | ~40T (est.) | 2025 |
Web-Crawl im Petabyte-Maßstab, roh und gefiltert. Bildet den Großteil der meisten Pretraining-Korpora. Erfordert umfangreiche Qualitätsfilterung (Deduplizierung, Spracherkennung, Toxizitätsentfernung).
Kuratierter 825-GB-Datensatz aus 22 Quellen, darunter GitHub, ArXiv, PubMed, FreeLaw, DM Mathematics. Offen und reproduzierbar.
Offene Reproduktionen der LLaMA-Trainingsdaten. DCLM (DataComp-LM, 2024) konzentriert sich auf rigorose Datenqualitäts-Ablationen, um optimale Filter-Pipelines zu finden.
Books3, Gutenberg, ArXiv, S2ORC. Hohes Signal-Rausch-Verhältnis; entscheidend für langformiges Reasoning und faktische Tiefe.
Jede GPU hält eine Modellreplik; Batches werden über GPUs aufgeteilt. Gradienten werden nach jedem Rückwärtsdurchlauf gemittelt (AllReduce). Standard für alle Größen.
Einzelne Gewichtsmatrizen werden über GPUs aufgeteilt. Erfordert eine Verbindung mit hoher Bandbreite (NVLink). Wird für Modelle genutzt, die den VRAM einer einzelnen GPU übersteigen.
Verschiedene Schichten werden verschiedenen GPUs zugewiesen. Mikro-Batches durchlaufen die Pipeline. Effizient für sehr tiefe Modelle; erfordert sorgfältige Planung, um Blasen zu minimieren.
Ein vortrainiertes Basismodell ist ein mächtiger, aber unvorhersehbarer Vorhersager des nächsten Tokens — es setzt jeden Text fort, auch schädliche Inhalte. Das Alignment-Training verwandelt es in einen hilfreichen, harmlosen und ehrlichen Assistenten.
Das Basismodell wird auf einem Datensatz aus (Anweisung, ideale Antwort)-Paaren feinabgestimmt, die von menschlichen Annotatoren verfasst oder kuratiert wurden. Dies bringt dem Modell das Format des Befolgens von Anweisungen bei. Das Trainingsziel ist identisch zum Pretraining (Cross-Entropy), aber der Datensatz ist klein (Zehntausende Beispiele) und von hoher Qualität. Nach dem SFT kann das Modell Anweisungen befolgen, kann aber noch unwahr oder schädlich sein.
graph LR A[Pretrained LLM] --> B[SFT on Instruction Data] B --> C[SFT Model] C --> D[Generate Completions] D --> E[Human Preference Labels] E --> F[Train Reward Model] F --> G[RLHF with PPO] G --> H[Aligned LLM]
Reward-Modell: Menschliche Annotatoren vergleichen Paare von Modellantworten und kennzeichnen ihre Präferenz. Ein separates Modell wird darauf trainiert, die von Menschen bevorzugte Antwort zu einem gegebenen Prompt vorherzusagen. Dieses skalare Reward-Signal erfasst nuancierte Qualitätsurteile, die sich schwer als Verlustfunktion spezifizieren lassen.
PPO (Proximal Policy Optimisation): Das SFT-Modell (die „Policy“) wird optimiert, um den Score des Reward-Modells zu maximieren, während eine KL-Divergenz-Strafe verhindert, dass es zu weit von der SFT-Baseline abdriftet (was zu Reward-Hacking führen würde). PPO ist rechenintensiv: Es benötigt vier Modelle gleichzeitig im Speicher.
Rafailov et al. (2023) zeigten, dass das RLHF-Ziel direkt am Policy-Modell ohne separates Reward-Modell oder RL-Schleife optimiert werden kann. Aus Paaren bevorzugter und abgelehnter Antworten reparametrisiert DPO den Reward als Funktion der Log-Wahrscheinlichkeiten von Policy- und Referenzmodell:
DPO ist einfacher, stabiler und günstiger als RLHF mit PPO. Die meisten quelloffenen, alignten Modelle (Llama 4 Instruct, Mistral Instruct) nutzen DPO oder eine Variante (SimPO, IPO) für die Präferenz-Alignment-Stufe.
| Methode | Reward-Modell | RL-Schleife | Stabilität | Verwendet von |
|---|---|---|---|---|
| RLHF (PPO) | Ja | Ja (PPO) | Mäßig | InstructGPT, early ChatGPT |
| DPO | Nein | Nein | Hoch | Llama 4, Mistral, Zephyr |
| Constitutional AI (CAI) | Selbstkritik | Ja (RLAIF) | Hoch | Claude (Anthropic) |
| GRPO / DAPO | Regelbasiert | Gruppenrelativ | Hoch | DeepSeek-R1, Qwen |
Bei jedem Generierungsschritt gibt das Modell einen Logit-Vektor der Größe |vocabulary| aus. Die Sampling-Strategie bestimmt, wie ein einzelnes Token aus dieser Verteilung gewählt wird — und hat enormen Einfluss auf Qualität, Vielfalt und Kohärenz der Ausgabe.
| Temperatur | Effekt | Anwendungsfall |
|---|---|---|
| 0.0 (Greedy) | Immer das Token mit der höchsten Wahrscheinlichkeit wählen. Deterministisch. | Klassifikation, strukturierte Extraktion, faktische Q&A |
| 0.2 – 0.4 | Schärfere Verteilung, folgt meist dem wahrscheinlichsten Pfad, lässt aber kleine Variationen zu. | Codegenerierung, Zusammenfassung |
| 0.6 – 0.8 | Ausgewogen. Gute Mischung aus Kohärenz und Vielfalt. | Allgemeiner Chat, Befolgen von Anweisungen (Standard für die meisten Modelle) |
| 1.0 | Sampelt direkt aus der Modellverteilung. Vielfältiger. | Kreatives Schreiben, Brainstorming |
| > 1.0 | Flacht die Verteilung ab. Erhöht Zufälligkeit und Wiederholung. Erzeugt oft inkohärente Ausgabe. | In der Produktion selten nützlich |
Tokens nach Wahrscheinlichkeit sortieren, die kleinste Menge nehmen, deren kumulierte Wahrscheinlichkeit ≥ p ist, dann aus dieser Menge sampeln. Bei p=0,9 berücksichtigt das Modell nur Tokens, die zusammen 90 % der Wahrscheinlichkeitsmasse ausmachen. Passt die Größe der Kandidatenmenge dynamisch an: bei Sicherheit ist der Nucleus klein, bei Unsicherheit breiter.
Die Verteilung auf die k wahrscheinlichsten Tokens beschränken, dann aus diesen sampeln. Einfacher als Top-p, nutzt aber ein festes k unabhängig von der Form der Verteilung. Top-p wird im Allgemeinen bevorzugt; Top-k ist nützlich, wenn strikte Kontrolle über die Größe der Kandidatenmenge nötig ist.
from openai import OpenAI
client = OpenAI()
# Factual / structured output: low temperature, no top-p
factual = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "What is the capital of France?"}],
temperature=0.0,
max_tokens=50,
)
# Creative writing: higher temperature + nucleus sampling
creative = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a haiku about neural networks."}],
temperature=0.9,
top_p=0.95,
max_tokens=100,
)
# Code generation: low temp, deterministic
code = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a Python quicksort function."}],
temperature=0.2,
max_tokens=300,
)Ein Transformer hat keine inhärente Vorstellung von Token-Reihenfolge — Attention ist permutationsinvariant. Die Positionskodierung injiziert Ordnungsinformation. Die Wahl der Kodierungsmethode bestimmt, wie gut das Modell auf Sequenzen verallgemeinert, die länger sind als seine Trainingslänge.
Ein gelernter oder fester (sinusförmiger) Vektor wird jedem Token-Embedding an Position i hinzugefügt. GPT-2 und BERT nutzen gelernte absolute Embeddings. Harte Grenze: Das Modell kann nicht auf Positionen verallgemeinern, die es im Training nie gesehen hat.
Kodiert die Position, indem die Q- und K-Vektoren im komplexen Raum um einen zur Position proportionalen Winkel rotiert werden. Der Attention-Score hängt natürlicherweise vom relativen Abstand zwischen Tokens ab. Verwendet von Llama 4, Mistral Large 3, Qwen und den meisten modernen Open-Weight-Modellen. Ermöglicht Techniken zur Kontexterweiterung wie YaRN und LongRoPE.
Während der autoregressiven Generierung berechnet das Modell bei jedem Schritt die Attention für jedes Token neu — naiv O(n²) pro Schritt. Der KV-Cache speichert die Key- und Value-Tensoren aller vorhergehenden Tokens. Bei jedem neuen Schritt werden nur die Q, K, V des neuen Tokens berechnet und die zwischengespeicherten K, V angehängt. Das reduziert die Generierung von O(n²) auf O(n) pro neuem Token.
| Modell | Kontextfenster | Positionskodierung | Effektive Länge* |
|---|---|---|---|
| GPT-4o | 128K | Gelernt + RoPE (gesch.) | 128K |
| Claude Sonnet 4.6 | 200K | Nicht offengelegt | ~150K (praktisch) |
| Gemini 2.5 Pro | 1M | Nicht offengelegt | ~500K (praktisch) |
| Llama 4 Maverick | 1M | RoPE | 1M |
| Mistral Large 3 | 128K | Sliding Window + RoPE | 128K |
| DeepSeek-R1 | 128K | RoPE | 128K |
*Effektive Länge: das Fenster, über das das Modell Informationen zuverlässig abruft. Die „Lost in the middle“-Forschung zeigt, dass die Leistung bei Inhalten in der Mitte sehr langer Kontexte nachlässt.
RAG begegnet zwei grundlegenden Beschränkungen von LLMs: ihrem Wissensstichtag und ihrer Neigung zu halluzinieren. Statt sich auf das zu verlassen, was das Modell im Training auswendig gelernt hat, ruft RAG zur Inferenzzeit relevante Dokumente ab und injiziert sie in den Prompt.
graph LR A[User Query] --> B[Embed Query] B --> C[Vector Search] C --> D[Top-k Chunks] D --> E[Inject into Prompt] A --> E E --> F[LLM Generation] F --> G[Grounded Answer]
Query einbetten → Top-k-Ähnlichkeitssuche → Chunks an den Prompt anhängen → generieren. Einfach, aber anfällig für irrelevante Treffer und Kontextüberlastung.
Ergänzt Query-Umschreibung, Re-Ranking (Cross-Encoder), hypothetische Dokument-Embeddings (HyDE), rekursives Retrieval und Kontextkompression.
Entkoppelte Pipeline: Routing, Query-Transformation, Retrieval, Scoring, Filterung und Fusion können jeweils unabhängig ausgetauscht werden. Maximale Flexibilität.
Alle N Tokens mit M-Token-Überlappung teilen. Schnell, kann aber mitten im Satz schneiden. Gute Ausgangsbasis.
An Satz- oder Absatzgrenzen teilen. Bewahrt semantische Einheiten, aber die Chunks variieren in der Größe.
Sätze mit hoher Embedding-Ähnlichkeit zu kohärenten Chunks gruppieren. Beste Retrieval-Qualität; höchste Rechenkosten zur Indexierungszeit.
Auf mehreren Granularitäten indexieren (Dokument → Abschnitt → Absatz). Auf der Ebene abrufen, die der Spezifität der Query entspricht.
| Datenbank | Bereitstellung | Skalierung | Am besten für |
|---|---|---|---|
| pgvector | Selbst gehostet (Postgres-Erw.) | Millionen | Bestehende Postgres-Nutzer; einfacherer Stack |
| Qdrant | Selbst gehostet / Cloud | Milliarden | Hohe Leistung, reichhaltige Filterung, Open Source |
| Weaviate | Selbst gehostet / Cloud | Milliarden | Multimodal, hybrid aus Semantik + Schlüsselwort |
| Pinecone | Vollständig verwaltete Cloud | Milliarden | Verwaltetes SaaS, minimaler Betrieb |
| Chroma | Lokal / selbst gehostet | Millionen | Prototyping, lokale Entwicklung |
Die Kluft zwischen Open-Weight- und proprietären Spitzenmodellen hat sich dramatisch verringert. Llama 4 Maverick erreicht GPT-4o in vielen Benchmarks; DeepSeek-R1 übertrifft o1 in Mathematik und Coding zu einem Bruchteil der Trainingskosten. Die Wahl dreht sich zunehmend um das Bereitstellungsmodell, den Datenschutz und die Gesamtbetriebskosten.
| Modell | Parameter | Kontext | Lizenz | MMLU | Bester Anwendungsfall |
|---|---|---|---|---|---|
| Open Weight | |||||
| Llama 4 Scout | ~17B active (MoE) | 1M | Llama 4 Community License | 79.6 | Schnell, langer Kontext, On-Device |
| Llama 4 Maverick | ~17B active (MoE) | 1M | Llama 4 Community License | 85.5 | Ausgewogen bei Leistung/Kosten, langer Kontext |
| Llama 4 Behemoth | ~288B active (MoE) | 128K | Llama 4 Community License | ~92 (est.) | Spitzen-Open-Weight-Aufgaben |
| Mistral Large 3 | ~123B | 128K | Mistral Research License | 84.0 | Mehrsprachiges Unternehmen |
| Qwen2.5 72B | 72B | 128K | Apache 2.0 | 86.0 | Code, Mathematik, mehrsprachig |
| DeepSeek-R1 | 671B MoE | 128K | MIT | 90.8 | Reasoning, Mathematik, Wissenschaft |
| Gemma 2 27B | 27B | 8K | Gemma License | 75.2 | Forschung, Feinabstimmung |
| Phi-4 | 14B | 16K | MIT | 84.8 | |
| Proprietär | |||||
| GPT-4o | ~200B est. | 128K | Proprietary | 88.7 | Allgemeine Spitze, multimodal |
| Claude Sonnet 4.6 | Undisclosed | 200K | Proprietary | 88.7 | Langer Kontext, Coding, Sicherheit |
| Gemini 2.5 Pro | Undisclosed | 1M | Proprietary | 85.9 | Sehr langer Kontext, multimodal, Reasoning |
| o3 / o1 | Undisclosed | 200K | Proprietary | ~91+ | Komplexes Reasoning, Spitzenforschung |
Das Serving von LLMs im großen Maßstab erfordert die Lösung von Speicher (VRAM ist knapp), Durchsatz (viele gleichzeitige Nutzer) und Latenz (Nutzer wollen schnelle erste Tokens). Das Ökosystem hat für jede Herausforderung leistungsstarke Lösungen entwickelt.
Die Reduzierung der numerischen Präzision der Modellgewichte verringert den VRAM und beschleunigt die Berechnung. Moderne Techniken (GPTQ, AWQ, GGUF) wenden Quantisierung ungleichmäßig an und schützen die empfindlichsten Gewichte.
| Format | Bits/Gewicht | Relative Größe | Qualitätserhalt | Tooling |
|---|---|---|---|---|
| FP32 | 32 | 100% | 100 % (Referenz) | PyTorch default |
| FP16 / BF16 | 16 | 50% | ~100 % | Standard training/inference |
| INT8 | 8 | 25% | ~99 % | bitsandbytes, TensorRT-LLM |
| INT4 (GPTQ/AWQ) | 4 | 12.5% | ~95–98 % | AutoGPTQ, AutoAWQ, llama.cpp |
| GGUF Q4_K_M | ~4.5 | ~14% | ~96 % | llama.cpp, Ollama |
| GGUF Q2_K | ~2.6 | ~8% | ~88 % | llama.cpp (CPU focus) |
PagedAttention für effizientes KV-Cache-Management, kontinuierliches Batching, Tensorparallelität. Der Goldstandard für GPU-Serving mit hohem Durchsatz. OpenAI-kompatible API.
Der Produktionsserver von Hugging Face. Flash Attention 2, kontinuierliches Batching, spekulatives Decoding. Treibt die Inference API an.
Kinderleichtes lokales Serving über GGUF-Modelle. Ein Befehl, um jedes Modell zu ziehen und auszuführen. Nicht für hohe Nebenläufigkeit ausgelegt, aber hervorragend für die Entwicklung.
Reine C++-Inferenz mit GGUF-Quantisierung. Läuft auf MacBook-M-Serie-CPUs und Consumer-GPUs. Treibt Ollama im Hintergrund an.
vLLMs PagedAttention (Kwon et al., 2023) verwaltet den KV-Cache-Speicher wie virtuellen Speicher in einem Betriebssystem — indem es ihn in nicht zusammenhängend zugewiesene Seiten fester Größe aufteilt. Das beseitigt Fragmentierung und verschwendete Reservierung und ermöglicht 2–24× mehr Durchsatz als HuggingFace Transformers bei gleichem GPU-Speicher.
Kontinuierliches Batching erlaubt es neuen Anfragen, einem laufenden Batch beizutreten, sobald eine Sequenz fertig ist, anstatt auf den gesamten Batch zu warten. Das verbessert die GPU-Auslastung bei Workloads variabler Länge erheblich.
# Start a vLLM server for Llama 4 Scout Instruct
# Requires: pip install vllm, CUDA GPU with ≥16GB VRAM
python -m vllm.entrypoints.openai.api_server \
--model meta-llama/Llama-4-Scout-17B-16E-Instruct \
--tensor-parallel-size 1 \
--max-model-len 32768 \
--dtype bfloat16 \
--port 8000
# The server exposes an OpenAI-compatible API:
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "meta-llama/Llama-4-Scout-17B-16E-Instruct",
"messages": [{"role": "user", "content": "Explain attention mechanisms."}],
"temperature": 0.7,
"max_tokens": 512
}'Die Evaluierung ist eines der schwierigsten offenen Probleme der LLM-Forschung. Standard-Benchmarks messen bestimmte Fähigkeiten, korrelieren aber unvollkommen mit der Nützlichkeit in der realen Welt. Eine umfassende Evaluierungsstrategie kombiniert automatisierte Benchmarks, menschliche Bewertung und LLM-as-Judge.
| Benchmark | Misst | Format | Einschränkung |
|---|---|---|---|
| MMLU | Breites Wissen (57 Fächer) | Multiple-Choice mit 4 Optionen | MC-Format; Kontaminationsrisiko |
| HumanEval | Python-Codegenerierung | Funktionsvervollständigung + Unit-Tests | Nur Python; enge Aufgabenverteilung |
| GSM8K | Mathe-Textaufgaben der Grundschule | Freiform-Arithmetik | Von Spitzenmodellen gesättigt (>95 %) |
| HellaSwag | Alltagswissen-NLI | Satzvervollständigung mit 4 Optionen | Gesättigt; adversarial, aber veraltet |
| MT-Bench | Befolgen von Anweisungen (mehrstufig) | LLM-as-Judge (GPT-4) | Der GPT-4-Richter hat eigene Verzerrungen |
| GPQA Diamond | Wissenschaft auf Graduiertenniveau | Multiple-Choice mit 4 Optionen von Fachexperten | Kleiner Datensatz; schwer skalierbar |
| MATH-500 | Wettbewerbsmathematik | Exakter Antwortabgleich | Formatsensibel; Lösungen können auswendig gelernt sein |
| Modell | MMLU | HumanEval | GSM8K | MATH |
|---|---|---|---|---|
| GPT-4o | 88.7 | 90.2 | 96.0 | 76.6 |
| Claude Sonnet 4.6 | 88.7 | 92.0 | 96.0 | 78.3 |
| Gemini 2.5 Pro | 85.9 | 84.1 | 91.7 | 67.7 |
| DeepSeek-R1 | 90.8 | 92.3 | 97.3 | 97.3 |
| Llama 4 Maverick | 85.5 | 85.4 | 95.0 | 72.0 |
| Llama 4 Scout | 79.6 | 77.0 | 89.0 | 58.0 |
| Mistral Large 3 | 84.0 | 92.0 | 93.0 | 69.0 |
| Llama 3.1 8B (2024) | 73.0 | 72.6 | 84.5 | 51.9 |
Für offene Aufgaben ohne Referenzantworten kann ein leistungsstarkes LLM Antworten anhand eines strukturierten Bewertungsrasters bewerten. MT-Bench und Chatbot Arena nutzen diesen Ansatz. Das Hauptrisiko sind Positionsverzerrung (der Richter bevorzugt zuerst erscheinende Antworten) und Ausführlichkeitsverzerrung (längere Antworten erhalten unabhängig von der Qualität höhere Bewertungen).
from openai import OpenAI
client = OpenAI()
def llm_judge(question: str, answer: str, rubric: str) -> dict:
prompt = f"""You are an expert evaluator. Score the following answer on a 1-10 scale.
Question: {question}
Answer: {answer}
Rubric: {rubric}
Respond with JSON: {{"score": <int>, "reasoning": "<str>", "strengths": ["..."], "weaknesses": ["..."]}}"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
response_format={"type": "json_object"},
temperature=0.0,
)
import json
return json.loads(response.choices[0].message.content)
result = llm_judge(
question="Explain the attention mechanism in transformers.",
answer="Attention computes a weighted sum of values...",
rubric="Accuracy (4pt), Clarity (3pt), Completeness (3pt)",
)
print(f"Score: {result['score']}/10 — {result['reasoning']}")Zu verstehen, wie LLMs funktionieren, ist das Fundament — aber das richtige Modell, die richtige Bereitstellungsarchitektur und die richtige Evaluierungsstrategie für Ihren spezifischen Anwendungsfall zu wählen, erfordert praktische Erfahrung. Unser Team hat produktive LLM-Systeme über RAG, Agenten, Feinabstimmung und Unternehmensbereitstellung hinweg gebaut. Buchen Sie eine Beratung, um Ihr Projekt zu besprechen.