ChatGPT

Begriffe

GPT

GPT steht für Generative Pre-trained Transformer.

• Generative: Das Modell kann Text erzeugen.
• Pre-trained: Es wurde vorab auf grossen Textmengen trainiert, bevor es für konkrete Aufgaben eingesetzt wird.
• Transformer: Das ist die Architektur des neuronalen Netzes, das hinter GPT steckt. Eine Transformer-Architektur arbeitet vor allem mit Self-Attention, um Wörter im Kontext zueinander zu verstehen.

LLM

Das Large Language Model bezeichnet ein neuronales Netz, das

• auf sehr grosse Textmengen trainiert wurde,
• viele Parameter besitzt (Millionen bis Billionen),
• und darauf spezialisiert ist, Text zu verstehen und zu erzeugen.

Typische Vertreter: GPT, Claude, PaLM, Llama usw.

„Large“ bezieht sich dabei sowohl auf die Modellgrösse (Parameteranzahl) als auch auf die Datenmenge, mit der trainiert wurde.

Von der Frage zur Antwort

Prompt

In der Fachsprache der KI (künstlichen Intelligenz) hat sich für die Frage der Begriff Prompt eingebürgert, der ursprünglich in Kommandozeilen und Programmiersprachen als Aufforderungszeichen diente:

C:\>

Der Benutzer gibt hier eine Aufforderung ein.

Antwort: Wahrscheinlichste Wörter

Die Antwort auf einen Prompt besteht aus den wahrscheinlichsten Wörtern, mit denen der Prompt weitergeführt werden sollte. Das tönt einfach und unglaublich zugleich. Natürlich erlaubt nur die clevere Berechnung von Wahrscheinlichkeiten ein sinnvolles Resultat.

Autoregressive Generierung

Das Resultat wird Wort für Wort generiert. Jedes neue Wort hängt von der Frage (Prompt) und den bereits generierten Wörtern ab, was man autoregressiv nennt.

Tokens

Effektiv werden nicht Wörter, sondern Tokens generiert. Generell arbeitet das LLM (large language model) mit Tokens. Der Tokenizer zerlegt sämtlichen Text, der an das Modell übergeben werden soll, in kleine Einheiten:

• Ein Token kann ein ganzes Wort, ein Wortteil oder sogar nur ein Zeichen sein.
• Zum Beispiel könnte „Hausaufgaben“ in Tokens wie ["Haus", "##aufgaben"] zerlegt werden (bei Subword-Tokenizern, wie sie in GPT-Modellen üblich sind).
• Ein Text wird greedy in Tokens zerlegt, d. h. der Tokenizer sucht die längsten zu einem Textfragment passenden Tokens.

Tokenliste/Vokabular

Die Tokens stammen aus einer vorgängig erzeugten Tokenliste (Token Set). Sie wird als Vokabular für Training und Normalbetrieb benutzt. Das Modell arbeitet somit mit einer festen Menge von Tokens und nicht mit fast unendlich vielen Wörtern.

Satzzeichen (Komma, Punkt usw.), Leerzeichen und andere Zeichen, bei denen es sich nicht um Buchstaben handelt, werden nicht besonders behandelt. Sie fliessen gleichberechtigt in den Trainingsprozess ein, mit dem die Tokenliste zusammengestellt wird.

Die Texte werden in UTF-8 codiert. Effektiv wird nur dieser Datenstrom verarbeitet. Beim Training werden zuerst die 256 einzelnen Bytes in die Tokenliste aufgenommen, womit sich später beliebige Texte in Tokens zerlegen lassen.

Es gibt verschiedene Verfahren, eine Tokenliste zu erstellen. Bei GPT-3 wurde das Byte-Pair Encoding (BPE) verwendet:

• Starte mit einem Textkorpus.

• Zerlege jedes Wort in einzelne Zeichen plus ein Endsymbol (z. B. </w>), damit Wortenden erkannt werden.

  • Beispiel: low lower lowest
  • Wörter zerlegt:

    low -> l o w </w>
    lower -> l o w e r </w>
    lowest -> l o w e s t </w>

• Zähle alle benachbarten Zeichenpaare im Korpus.

  • Paare in low = l o, o w, w </w>

  • Paare in lower = l o, o w, w e, e r, r </w>

  • Häufigstes Paar im gesamten Korpus wird ausgewählt.

• Das häufigste Paar wird als neues Symbol zusammengeführt.

• Häufigstes Paar l o → zusammengeführt zu lo

• Neue Darstellung:

  low -> lo w </w>
  lower -> lo w e r </w>
  lowest -> lo w e s t </w>

• Wiederhole die Zusammenführung, bis die gewünschte Vokabulargrösse erreicht ist.

Token-ID

Die Token-ID entspricht der Position eines Tokens in der Tokenliste.

Embedding-Vektor

Für jedes Token in der Tokenliste gibt es einen Embedding-Vektor. Dieser Vektor codiert die Bedeutung und Beziehung des Tokens. Er heisst so, weil das Konzept, Daten in ein Vektorformat zu konvertieren, oft als Embedding bezeichnet wird.

Beispiele Bedeutung:

• Hund: Tier, vier Beine, Haustier, bellen
• Apfel: Obst, essbar, rund, rot/grün

Beispiele Beziehung:

• Semantische Beziehungen: „König“ – „Mann“ oder „Frau“ ≈ „Königin“
• Synonyme: „Auto“ ≈ „Fahrzeug“
• Antonyme: „heiss“ vs. „kalt“
• Typische Kontextmuster: „Essen“ kommt oft mit „kochen“, „essen“, „Mahlzeit“ vor

Interessanterweise muss für die Beziehungscodierung das andere Token nicht bekannt sein.

Zwei Wörter mit ähnlicher Bedeutung („Hund“ und „Hundewelpe“) und/oder einer wahrscheinlichen Beziehung haben ähnliche Vektoren (d. h. sie spannen nur kleine Winkel auf).

Die Tokens mit ihren zugehörigen Embedding-Vektoren bilden die Embedding-Tabelle. Sie hat die Dimension

(\text{Anzahl Tokens}) \times (\text{Vektor-Dimension})

Beispiel: 50’000 Tokens × 1024 Parameter in jedem Embedding-Vektor

Beispiel GPT-3: 50’000 Tokens × 12’288 Parameter, d. h. die Embedding-Matrix enthält über 614 Mio. float32-Parameter. Das ist ein kleiner Teil der total 175 Mia. Parameter für Gewichte in Embeddings, Attention, FFN etc. Die 12’288 Parameter ermöglichen 96 Heads (siehe weiter unten) mit je 128 Parametern.

Diese Embedding-Vektoren sind trainierbar: Während des Trainings lernt das Modell, welche Vektorwerte die Bedeutung des Tokens am besten repräsentieren. Weil beispielsweise „Katze” und „Hund” in ähnlichen Kontexten erscheinen, erhalten sie auch ähnliche Embedding-Vektoren.

Der Embedding-Vektor E ist der Input-Vektor für die erste Transformer-Schicht.

Model Dimension

Die Dimension des Embedding-Vektors nennt man Model Dimension oder Hidden Size. Wir verwenden dafür nachfolgend die Variable d_{model}​.

Nochmals für GPT-3: d_{model}=\text{12’288}​

Transformer

ChatGPT basiert auf der Transformer-Architektur. Der Hauptmechanismus des Transformers ist die Self-Attention, mit der das Modell Beziehungen zwischen Wörtern über weite Distanzen im Text erkennen kann.

Der Transformer besteht aus vielen Transformer-Layers (z. B. 96 bei GPT-3), die ein Vektor einen nach dem anderen durchläuft. Sie sind identisch aufgebaut, arbeiten aber mit unterschiedlichen Parametern, die im Lernprozess erarbeitet wurden.

Transformer-Layer

Jeder Transformer-Layer besteht aus den Komponenten Self-Attention, Feed-Forward Network (FFN) und Normalisierung. Das FFN enthält ein kleines neuronales Netz. Man kann also sagen: Das Transformer-Modell wird durch die Tiefe des Layer-Stacks tief, nicht durch ein einzelnes grosses durchgehendes Netz.

Self-Attention

Der in den ersten Transformer-Layer eingespeiste Embedding-Vektor E kodiert zunächst nur Eigenschaften seines zugrunde liegenden Tokens selbst: Seine Identität (Bedeutung), in welchem Kontext es üblicherweise auftritt (Beziehung), aber nicht, wie es mit den anderen Tokens in der aktuellen Textsequenz interagiert.

Die Self-Attention sorgt dafür, dass jeder Token-Vektor Informationen aus den anderen Tokens aufnimmt – gewichtet nach Relevanz – und so eine kontextabhängige Repräsentation entsteht.

Mit jeder Transformer-Schicht wird diese Kontextinformation weiter verdichtet und verfeinert, so dass höhere Layer komplexere Beziehungen zwischen Tokens erkennen können.

Der Vektor mit der Kontextinformation wird für einen Teil der folgenden Prozessschritte nochmals unterteilt, was sich Multi-Head Attention nennt. Damit reduziert sich für einen Moment die übliche Vektordimension d_{model}​ in die kleinere Dimension d_k = d_v​. Angenommen, wir haben wie bei GPT-3

h = 96 \text{ Heads}

Dann wählt man pro Head die Head Dimension:

d_k = d_v = \frac{d_{\text{model}}}h

d_k​ ist die Dimension für die nachfolgenden Vektoren Q und K, d_v​ für V. Man könnte deren Grösse unterschiedlich wählen, tut es aber nicht, weil das keine Vorteile bringt.

Beispiel:

d_k = d_v = \frac{12'288}{96} = 128

Jeder Head hat seine eigenen Gewichtsmatrizen (siehe weiter unten)

W_Q^{(head)},\; W_K^{(head)},\; W_V^{(head)}

Wir starten mit der ersten Operation im Transformer-Layer - der Embedding-Vektor wird mit einem Positionsvektor angereichert:

X = E + P

• E: Embedding-Vektor
• P: Positionsvektor

Der Positionsvektor ist nicht einfach eine fortlaufende Positionsnummer, sondern ein Vektor mit gleicher Dimension wie der Embedding-Vektor E und einem Inhalt, der die Position für die spätere Anreicherung von X mit Kontext geeignet codiert. Es haben sich verschiedene Verfahren etabliert, wie der Positionsvektor berechnet wird:

• Sinus-/Cosinus-Positional Encoding: Der Positionsvektor berechnet sich mit einer festen Formel
• Learned Positional Embeddings: Der Positionsvektor ist trainiert, d. h. man entnimmt ihn für die Self-Attention-Berechnung einer Tabelle. Dieses Verfahren verwendet beispielsweise GPT-3.
• Relative Position Representations: Hier wird nicht die absolute Position codiert, sondern der Abstand zwischen zwei Tokens. Damit wird der Transformer bei langen Sequenzen robuster.

Der resultierende positionsangereicherte Embedding-Vektor X (Dimension d_{model}​) wird nun verwendet, um Q, K und V zu berechnen:

• Q: Query Der Query-Vektor beschreibt, wonach ein Token „fragt“. Er legt fest, welche Art von Information dieses Token im Kontext sucht. Dimension d_k​
• K: Key Der Key-Vektor beschreibt, welche Information ein Token „anbietet“. Er ist das Gegenstück zum Query: Anhand von Key und Query wird berechnet, wie gut zwei Tokens zueinander passen. Dimension d_k​
• V: Value Der Value-Vektor enthält die eigentlichen Informationen, die in der Self-Attention-Berechnung weitergegeben und gewichtet kombiniert werden. Dimension d_v​

Q = X \cdot W_Q \\ K = X \cdot W_K \\ V = X \cdot W_V

• W: Drei trainierte Gewichtsmatrizen für Q, K, und V

Aus Q und K werden die Attention Scores berechnet. Man fragt: Wie relevant ist das andere Token (repräsentiert durch K) für das aktuelle Token (repräsentiert durch Q)?

\text{Score}_{i,j} = \frac{Q_i \cdot K_j^\top}{\sqrt{d_k}}

• i: Aktuelles Token
• j: Alle Tokens in der Sequenz

Jeder einzelne Score ist ein Skalar, weshalb Q mit K-transponiert multipliziert wird. Der Wurzelausdruck unter dem Bruchstrich skaliert das Resultat passend.

Nun haben wir soviele Scores wie Tokens in der Eingangssequenz (Anzahl j). Diese Scores werden nun noch mit Softmax normalisiert. Softmax hat diese Eigenschaften:

• Alle Resultate liegen zwischen 0 und 1

• Summe = 1, d. h. kann als Verteilung interpretiert werden

• Relative Unterschiede werden betont. Grosse Scores werden stärker hervorgehoben, kleine Scores werden abgeschwächt.

Die Scores werden über alle Tokens normalisiert:

\alpha_{i,j} = \text{Softmax}(\text{Score}_{i,j})

• Attention \alpha_{i,j}​: Gibt an, wie relevant das andere Token j für das aktuelle Token i ist.

Der neue, kontextualisierte Vektor für Token i ist die gewichtete Summe der Value-Vektoren:

\text{Context}_i = \sum_j \alpha_{i,j} V_j

Dieser Vektor Context_i​ hat dieselbe Dimension d_v​ wie V, der soeben gewichtet wurde. Von diesem Vektor Context_i​ gibt es so viele Exemplare wie es Heads gibt (h). Die Vektoren fügen wir nun zusammen und multiplizieren mit einer letzten Matrix:

O = \text{Concat}(\text{Context}^{(1)},\ldots,\text{Context}^{(h)}) \cdot W_O

• O: Output
• W_O​: Output Projection Matrix

Die Concatenation erzeugt nur ein Aneinanderhängen der Head-Vektoren. W_O​ mischt die Informationen zwischen den Heads und bringt sie in eine einzige, saubere Repräsentation. W_O​ lernt

• welche Heads wichtiger sind
• wie ihre Informationen miteinander interagieren
• welche Features im Output verstärkt oder gedämpft werden

Ohne W_O​ wäre Multi-Head Attention nur ein „Haufen einzelner Köpfe“, aber keine integrierte Repräsentation.

Mit der Residual Connection wird der ursprüngliche positionsangereicherte Embedding-Vektor X dem Resultat hinzugefügt:

\tilde{X} = X + O

Warum macht man das?

• Erleichtert das Training tiefer Netzwerke Die Gradienten fliessen leichter durch viele Layer, da die Originalinformation direkt weitergegeben wird.
• Erhält die ursprüngliche Token-Information Das Modell kann entscheiden, wie stark es die neue Attention-Information einbezieht.
• Vermeidet Überanpassung Layers müssen nicht alles „von Grund auf“ lernen, sondern können auf bestehende Repräsentationen aufbauen.

Das Ergebnis wird noch normalisiert:

X' = \text{LayerNorm}(\tilde{X})

Feed-Forward Network (FFN)

Das Feed-Forward Network verarbeitet jedes Token unabhängig von den anderen, im Gegensatz zur Self-Attention, die Kontextinformationen zwischen Tokens integriert.

Y = \text{FFN}(X') \\

Bei diesem FFN handelt es sich um ein klassisches neuronales Netz mit zwei Dense-Layern und einer zwischengeschalteten nichtlinearen Projektion. Das Netz ist bei GPTs im Vergleich mit anderen Anwendung breit, zeigt aber mit zwei Layern nur wenig Tiefe.

Übrigens: Ein Dense-Layer (auch Fully Connected Layer) ist eine lineare Schicht in einem neuronalen Netz, bei der jeder Eingang mit jedem Ausgang verbunden ist. Allgemeine Formel:

y = W \cdot x + b

Das FFN führt intern diese zwei linearen Projektionen und die nichtlineare Aktivierung durch:

\text{FFN}(X') = W_2 \cdot \sigma(W_1 \cdot X' + b_1) + b_2

Erste lineare Projektion

H = W_1 \cdot X' + b_1

• X'​ hat die Dimension d_{\text{model}}​
• W_1​ hat die Dimension d_{\text{ff}} \times d_{\text{model}}​
• b_1​ hat die Dimension d_{\text{ff}}​
• H​ hat die Dimension d_{\text{ff}}​

d_{\text{ff}}​ ist typischerweise viermal so gross wie d_{\text{model}}​, d. h. bei GPT-3 gilt:

d_{\text{ff}}=4 \cdot d_{model}=49'152

Nichtlineare Aktivierung

H' = \sigma(H)

Typische Wahl bei GPT:

• GELU (Gaussian Error Linear Unit)

Dadurch kann das Modell nichtlineare Beziehungen modellieren. Ohne eine nichtlineare Aktivierungsfunktion (wie GELU, ReLU, SiLU usw.) wäre das FFN nur eine lineare Transformation. Zwei lineare Transformationen hintereinander sind aber immer noch linear, also mathematisch gleichbedeutend mit einer einzigen grossen Matrixmultiplikation.

Durch die Nichtlinearität wird das Netzwerk zu einem echten universellen Approximator, d. h. es kann praktisch beliebige Funktionen modellieren.

GELU sorgt also dafür, dass das Modell nichtlineare Muster erkennt – zum Beispiel:

• Wenn das Wort ‚nicht‘ im Satz vorkommt, invertiere die Bedeutung.
• Stärke die Relevanz dieses Tokens nur, wenn gleichzeitig etwas anderes zutrifft.
• Dieselbe Phrase kann in verschiedenen Sätzen etwas anderes bedeuten.

Zweite lineare Projektion

Y = W_2 \cdot H' + b_2

• W_2​ hat die Dimension d_{\text{model}} \times d_{\text{ff}}​
• b_2​ hat die Dimension d_{\text{model}}​
• Y​ ist wieder ein Vektor der Dimension d_{\text{model}}​

Das FFN bringt den Vektor auf die Dimension d_{\text{ff}}​ und anschliessend wieder zurück auf d_{model}​.

Residual Connection und LayerNorm

Ein FFN kann mit seinen Transformation durch zwei Dense-Layers + GELU die Werte stark verändern. Gleich wie in der Berechnung der Self-Attention und aus denselben Gründen braucht es auch hier eine Residual Connection und Normalisierung.

X_{\text{out}} = \text{LayerNorm}(X' + Y)

X_{\text{out}}​ wird nun auf den nächsten Transformer-Layer (Self-Attention usw.) geführt.

Logits

Wir rekapitulieren: Die Tokens der Eingangssequenz bzw. deren Embedding-Vektoren haben wir durch alle Transformer-Layers geschickt. Es liegt nun ein kontextualisierter Vektor vor, zu dem das statistisch am besten passenden Token, d. h. ein Wort oder Sub-Wort, aus dem Vokabular ausgewählt werden soll.

Abschliessende LayerNorm

X_{\text{out}}​ wird noch einmal normalisiert, um die Werte vor der Projektion auf das Vokabular zu stabilisieren:

H = \text{LayerNorm}(X_{\text{out}})

Projektion auf das Vokabular

Eine lineare Projektion wandelt die Vektor-Repräsentation jedes Tokens in einen Logits-Vektor über alle möglichen Tokens im Vokabular:

\text{logits} = H \cdot W_{\text{vocab}} + b_{\text{vocab}}

• W_{\text{vocab}} \in \mathbb{R}^{d_{\text{model}} \times |V|}​, wobei |V|​ die Grösse des Vokabulars ist.
• Oft wird weight tying verwendet: W_{\text{vocab}} = E^\top​, also die Transponierte der Eingabe-Embeddings.

Softmax

Die Logits werden durch Softmax geschickt, um Wahrscheinlichkeiten für das nächste Token zu erhalten:

P(\text{Token}) = \text{Softmax}(\text{logits})

• Jede Komponente des Vektors ist die Wahrscheinlichkeit, dass dieses Token als nächstes erscheint.

Sampling/Auswahl

Für jedes Token im Vokabular liegt nun eine Wahrscheinlichkeit vor. Nun gilt es, ein Token auszuwählen. Mögliche Algorithmen:

• Greedy (auch Argmax genannt): Wähle einfach das wahrscheinlichste Token bei jedem Schritt. Das ist schnell, kann aber in längeren Sequenzen zu lokal optimalen, aber global suboptimalen Texten führen (z. B. monotone oder repetitive Ausgaben).
• Temperature Sampling: Steuert die Kreativität über die Verteilungsskalierung
• Top-k sowie Top-p Sampling: Auswahl zufällig aus den wahrscheinlichsten Tokens

GPT arbeitet oft mit Temperature und Top-p Sampling.

Das Token wird nun als Teil der Antwort dem Benutzer angezeigt. Seine Frage und die bisherigen Antwort-Tokens werden nun wieder in den Transformer eingespeist, um das nächste Antwort-Token zu generieren. Dieser Prozess wird erst dann beendet, wenn als Antwort-Token ein Abschluss-Token <EOS> resultiert. Abschluss-Tokens gehören zu den Trainingssequenzen, die das Modell lernt. Deshalb werden sie später auch regelmässig generiert, d. h. die Antworten entsprechen im Umfang den Trainingssequenzen. Es gibt allerdings auch ein selten notwendiges Limit für die maximale Anzahl zu generierender Tokens.

Rollen und Tasks

ChatGPT nutzt intern Rollen- und Taskmarker, die für den Benutzer unsichtbar sind.

Rollen

Jeder Textblock im Dialog ist intern mit einer Rolle versehen. Beispiel:

System: Du bist ein neutraler, sachlicher Assistent.
Developer: Wenn möglich, verwende die Python-Umgebung zur Berechnung.
User: Bitte berechne 15% von 240 und erkläre den Vorgang.
Assistant: 15% von 240 sind 36. Berechnung: 240 * 0.15 = 36.

Der Dialog geht mit neuen Fragen (User) nahtlos weiter. In der ChatGPT-API wird der System-Prompt jedoch nur einmal am Anfang vor den User-Nachrichten eingefügt.

System

• Setzt die Rahmenbedingungen des gesamten Dialogs.
• Beispiele: Stil, Ton, Grenzen, Verhalten, Sicherheitsvorgaben.
• Wird vom Benutzer normalerweise nicht direkt gesetzt (z. B. in ChatGPT), technisch aber wäre es möglich.

Developer

• Optionaler Abschnitt in vielen API-Anwendungen.
• Wird genutzt, um dem Modell Funktionslogik oder interne Richtlinien zu geben.
• Hat höhere Priorität als die Nutzereingaben, aber unterhalb der Systemvorgaben.

User

• Der normale Benutzereingang.
• Enthält Fragen, Aufgaben, Texte zur Analyse usw.
• Die Rolle mit geringster Priorität im Konfliktfall.

Assistant

• Das Antwortfeld des Modells.
• Das Modell produziert hier seinen Output.

Tasks

ChatGPT erhält oft System-Prompts, die bestimmte Aufgaben definieren:

• „Erkläre Schritt für Schritt“
• „Antworte in einem bestimmten Stil“

Intern werden diese Aufgaben als Taskmarker oder strukturierte Tokens in der Prompt-Sequenz kodiert.

Rollenmarker und Taskmarker helfen dem Modell:

• den Kontext der Unterhaltung zu verstehen
• die Antwort konsistent mit Rolle und Aufgabe zu generieren
• längere Dialoge ohne Vermischung von Nutzer- und Modellanteilen zu handhaben

Training

Ein modernes LLM durchläuft mindestens drei Trainingsphasen.

Phase 1 – Pretraining

Die allgemeine Sprachkompetenz des LLM entsteht mit dem Pretraining. Es werden Datenquellen mit unterschiedlicher Gewichtung eingespeist:

Datenquelle	Gewichtung
Öffentliche Webtexte	niedrig
Lizenzierte Inhalte	mittel
Kuratierte Datensätze	hoch

Trainingstexte aufbereiten

Pretraining heisst nicht, dass da einfach „Webseiten eingeworfen“ werden. OpenAI (und andere) verwenden Webtexte nur in einer algorithmisch bereinigten und gefilterten (d. h. kuratierten) Form:

• Kopierte Inhalte werden entdupliziert (ca. 30 – 60 % aller Webtexte sind Duplikate)
• Boilerplate (Navigationsleisten, Werbung, Cookie-Texte, Footers) wird entfernt
• SPAM und SEO-Schrott wird gefiltert
• Seiten mit sehr schlechter Qualität werden verworfen
• Extrem lange Seiten werden gesplittet
• HTML wird bereinigt / Tokenisierung angewendet
• Personenbezogene Daten werden entfernt, wo möglich
• Texte mit rechtlichen Problemen werden ausgeschlossen

Sequenzen bilden

Für das Pretraining werden aus den zu lernenden Texten Sequenzen von 2000 bis 8000 Tokens gebildet. Warum nicht mehr?

• GPU-Speicher explodiert quadratisch mit der Länge
• Sehr lange Sequenzen bringen wenig zusätzlichen Nutzen
• Webtexte enthalten oft Rauschen am Ende (Kommentare, Footer usw.)
• Die optimale „Körnigkeit“ liegt erfahrungsgemäss in diesem Bereich

Darum werden lange Dokumente (z. B. 50’000-Token-Webseiten-PDFs) aufgeteilt.

Texte werden in fortlaufende Blöcke der angestrebten Sequenzlänge zerlegt, ohne auf deren Inhalt Rücksicht zu nehmen (ohne Berücksichtigung der Semantik). Eine Webseite mit 30’000 Tokens wird vielleicht in 12 Blöcke à 2’500 Tokens zerlegt.

Es wird nicht semantisch geschnitten, weil

• der Aufwand zu hoch wäre, Abschnitte zu erkennen (z. B. Sätze, Absätze, Überschriften, logische Blöcke) oder gute kontextabhängige Trennpunkte zu finden. Ausserdem wären die notwendigen Algorithmen nicht stabil genug.
• Modelle sich durch reine Tokenstatistik trotzdem sehr gut zurechtfinden
• semantisch sauberes Schneiden keinen messbaren Vorteil brachte (Erfahrung aus mehreren Veröffentlichungen)

Sequenzen einspeisen

Die Sequenzen aus vielen Büchern und Webseiten werden nun gemischt. Damit sieht das LLM zufällige Kombinationen. Das soll verhindern, dass es wegen der Reihenfolge eine Präferenz bekommt.

Im Normalbetrieb (von der Frage zur Antwort) liefert das LLM für eine Token-Sequenz das nächste Token mit der höchsten Wahrscheinlichkeit. Beim Training ist dieses nächste Token bereits bekannt, da die vorhandenen Sequenzen naturgemäss bereits vollständig sind. So gibt man im Training eine ganze Tokensequenz gleichzeitig in das LLM. Anstelle des Embedding-Vektors, der im Normalbetrieb zum Einsatz kommt, wird hier gleich eine Sequenz von Embedding-Vektoren als Matrix in das LLM eingespeist. Das LLM liefert für jedes Token einen Logits-Vektor, d. h. einen Vektor, der - sobald normalisiert - für das ganze Vokabular Wahrscheinlichkeiten enthält. Im Unterschied zum Normalbetrieb wird nun daraus nicht das wahrscheinlichste Token ausgewählt, sondern der Cross Entropy Loss bestimmt:

\text{Loss} = -\text{ln}(p_t)

• \text{Loss}​: Cross Entropy Loss
• p_t​: Wahrscheinlichkeit des Tokens, das tatsächlich gemäss Trainingssequenz auf das aktuelle Token folgt. Im Idealfall liegt diese Wahrscheinlichkeit bei 1 und damit der Loss bei 0. Normalerweise liegt die Wahrscheinlichkeit tiefer. Tiefere Wahrscheinlichkeiten erhöhen den Loss, d. h. den Fehler, den das LLM mit seiner aktuellen Parametrierung erzeugt.

Der Loss wird für alle Tokens bestimmt. Dann folgt:

\text{Loss}_{\text{gesamt}} = \frac{1}{n-1} \sum_{i=1}^{n-1} \text{Loss}_{i}

Mit Backpropagation und Optimierern werden nun die Parameter des LLM ausgehend vom Gesamt-Loss optimiert.

Masked Self-Attention

Die Self-Attention bestimmt für ein Token, wie stark es mit seinen Vorgängern in der Tokensequenz zusammenhängt. In Normalbetrieb enthält die Tokensequenz nur Vorgänger und das aktuelle Token. Im Trainingsbetrieb liegen zusätzlich auch die Nachfolger vor, die mit der ganzen Sequenz gleichzeitig in das LLM eingespeist werden. Es gilt zu verhindern, dass in der stark parallelisierten Verarbeitung ein Token mit seinen Nachfolge-Tokens in Zusammenhang gebracht wird. Es dürfen nur die Zusammenhänge mit den Vorgänger-Tokens berücksichtigt werden.

Wir notieren nochmals die Attention-Berechnung aus dem Abschnitt der Self-Attention:

\alpha_{i,j} = \text{Softmax}(\text{Score}_{i,j})

• Attention \alpha_{i,j}​: Gibt an, wie relevant das andere Token j für das aktuelle Token i ist.

Bei verbotenen Kombination von i und j wird für \text{Score}_{i,j}​ eine grosse negative Zahl eingesetzt (das ist die „Maske”). Dadurch wird

\text{Softmax}(\text{grosse negative Zahl}) \approx 0

Nun kann das LLM ohne Bedingungen mathematisch durchlaufen werden.

Batch-Verarbeitung

Tatsächlich wird ein einem Schritt nicht nur eine Sequenz in das LLM eingespeist. Vielmehr werden Batches von z. B. 32, 64 oder 128 Sequenzen angelegt. Die Sequenzen stammen aus unterschiedlichen Quellen. Deshalb verwendet man Batches:

• Moderne Hardware (GPU/TPU) ist auf grosse Matrixmultiplikationen optimiert. Wenn man nur eine Sequenz pro Durchlauf einspeist, wird die Hardware nicht ausgelastet.
• Backpropagation über sehr tiefe Netzwerke kann instabile Gradienten erzeugen. Durch Mittelung des Loss über alle Sequenzen im Batch erhält man stabilere Gradienten, was zu einem robusteren Training führt. Batches glätten die Schwankungen (einfacher Satz, komplizierter Satz u. ä.), so dass das Modell nicht übermässig auf einzelne Sequenzen reagiert.

Gewichte unterschiedlicher Datenquellen

Die unterschiedlichen Datenquellen haben unterschiedliche Gewichte – aber nicht durch explizite Zahlen, sondern durch:

• Datenauswahl (welche Texte kommen überhaupt ins Set): Hochwertige Quellen (z. B. kuratierte Datensätze, lizenzierte Inhalte) werden eher aufgenommen als minderwertige oder irrelevante Inhalte.
• Duplizieren („Oversampling“): Manche Textarten oder Quellen werden mehrfach in das Trainingsset aufgenommen. Wiederholungen erhöhen das Gewicht der entsprechenden Datenquelle implizit, ohne dass man numerische Gewichte direkt einsetzen muss.
• Filtern („Underweighting“ unerwünschter Inhalte): Unerwünschte Inhalte (z. B. beleidigende Texte, Spam, sehr fehlerhafte Texte) werden aus dem Set entfernt oder stark reduziert. Damit erscheinen sie seltener im Training.
• Spezielle Mischung („Data mixture recipes“): Man erstellt eine durchdachte Mischung verschiedener Quellen. Diese Mischung wird beim Erstellen der Trainingsbatches umgesetzt, z. B. durch Sampling mit unterschiedlichen Wahrscheinlichkeiten. So lässt sich das gewünschte Gleichgewicht zwischen Vielfalt und Qualität steuern, ohne dass man explizit Gewichtungsfaktoren in die Loss-Funktion einfügt. Beispiel:
  • 50 % öffentliche Webtexte
  • 30 % lizenzierte Texte
  • 15 % kuratierte Datensätze
  • 5 % menschliches Feedback, RLHF

Die Reihenfolge, in der Sequenzen in den Datenquellen stehen, spielt keine Rolle. Sie werden für das Training ohnehin zufällig durchmischt.

Phase 2 – Supervised Fine-Tuning (SFT)

Nach dem Pretraining folgt das Supervised Fine-Tuning. Damit soll das Modell lernen, wie ein Chat (Frage/Antwort) funktioniert. Ausserdem soll es auf höfliche Antworten und korrektes Verhalten geschult werden.

Bei den Textsequenzen handelt es sich um kuratierte Dialoge. Damit verfügen sie über hohe Qualität. Oft sind sie viel kürzer als Texte für das Pretraining. Das LLM lernt im SFT „wie sollte ein Assistent reagieren?” anstelle von „Wie sieht Text aus?”.

Mit dem SFT werden Rollen eingeführt. Trainiert wird beispielweise:

<System>
Du bist ein hilfsbereiter, sachlicher Assistent. Beantworte Fragen präzise und ohne unnötige Abschweifungen.
</System>
<User>
Kannst du mir erklären, warum der Himmel blau erscheint?
</User>
<Assistant>
Der Himmel wirkt blau, weil Moleküle in der Atmosphäre kurzwelliges Sonnenlicht – insbesondere den blauen Anteil – stärker streuen als langwelliges Licht. Unser Auge nimmt daher überwiegend gestreutes blaues Licht wahr.
</Assistant>

Die Rollen erscheinen einfach als Tokens im Prompt. Technisch gesehen sind das gewöhnliche Tokens. Für das SFT wird jedoch der Loss ohne die Tokens im User-Prompt berechnet. Es zählen nur die Tokens im System- und Assistant-Prompt. Damit ist der User-Teil nur Kontext, der nicht gelernt werden muss.

Die Reihenfolge System/User/Assistant ist wichtig, einerseits weil damit diese Struktur besser im Modell verankert wird und andererseits weil Tokens nur auf frühere Tokens zugreifen können. Damit ist sichergestellt, dass eine System-Anweisung für den ganzen Dialog gilt.

Im SFT geht es nicht um Fakten, sondern darum, gutes Antwortverhalten zu lernen.

Oversampling

SFT-Datenmengen sind klein, typischerweise 10’000 – 200’000 Dialoge, verglichen mit hunderten Milliarden Tokens im Pretraining. Damit SFT überhaupt Wirkung entfaltet, werden die SFT-Beispiele im Training viel häufiger wiederholt als Pretraining-Beispiele.

Beispiel:

• Pretraining-Daten: einmal durchlaufen
• SFT-Daten: vielleicht 50 – 200 Durchläufe (Epochs)

Eigene Trainingsphase

SFT läuft nach dem Pretraining als eigene Trainingsphase. Da diese Phase:

• auf kleiner Datenmenge basiert und
• oft mit relativ grossem Learning-Rate-Budget durchgeführt wird,

bekommen diese Beispiele sehr viel Gewicht – selbst ohne extremen Oversampling-Faktor. Eine einzige SFT-Epoche kann mehr Einfluss haben als Millionen Pretraining-Tokens.

Hohe Loss-Konzentration (nur auf Assistant-Output)

Beim SFT wird:

• kein Loss auf den User-Part berechnet
• nur der Modell-Output des Assistant-Parts trainiert

Das konzentriert den Lernimpuls und verstärkt die Wirkung jedes SFT-Beispiels erheblich.

Kleine, aber hochwertige Daten („value density“)

SFT-Daten sind:

• manuell geschrieben
• qualitativ hoch
• klar strukturiert
• perfekt formatiert

Das Modell lernt aus jedem Token sehr viel. Der Gradient ist präzise und konsistent. Er „überschreibt“ leicht Verhaltensmuster aus dem Pretraining.

Kleine Learning Rate, aber nicht winzig

Während das Pretraining wegen der grossen Datenmange oft eine sehr niedrige Learning Rate hat, kann SFT eine höhere effektive Lernrate haben. Dadurch hat jedes Beispiel überproportional viel Kraft, selbst ohne Oversampling.

Optionale Data-Mixing-Schemata

Manchmal werden Pretraining-Daten und SFT-Daten gemischt. Dort bekommt SFT typischerweise einen festgelegten Anteil – etwa:

• 90 % SFT
• 10 % Pretraining (Stabilisierung)

Phase 3 – RLHF

Man würde erwarten, dass mit dem SFT das Modell fertig trainiert ist. Schliesslich hat es im Pretraining das Wissen und im SFT die höfliche Dialogfähigkeit erlernt. Es hat sich jedoch gezeigt, dass das nicht genügt. Deshalb folgt nun das Reinforcement Learning from Human Feedback (RLHF):

• SFT macht ein Modell artig.
• RLHF macht es verlässlich, stabil und sicher.

Mit dem RLHF werden keine Texte mehr gelernt. Es geht vielmehr darum, aus verschiedenen Antworten die beste auszuwählen. Die Bewertung erfolgt durch Menschen.

Wie sehen die Unterschiede zwischen dem Trainingsstand nach SFT und RLHF aus?

SFT ahmt Musterbeispiele nach (Imitation Learning)

Das SFT-Modell sieht hochwertige Dialoge und lernt:

• höflich zu wirken
• hilfreich zu wirken
• strukturiert zu antworten
• korrekt zu antworten (wenn die Beispiele korrekt waren)
• Rollen zu respektieren

Aber: Das Modell tut nur das, was in diesen Beispielen direkt vorkommt. Es hat keine Intuition dafür, warum das gut ist.

Konsequenzen:

• Es kann höflich sein, aber inkonsistent.
• Es kann sehr gute Beispiele reproduzieren, aber nicht generalisieren, wenn Prompts von der Form der Trainingsbeispiele abweichen.
• Es kann „ausbrechen”, wenn der User komplizierte Formulierungen verwendet.
• Unerwünschte Muster aus dem Pretraining können wieder „durchschlagen”.

RLHF optimiert auf menschliche Präferenzen

• SFT erzeugt Antworten, die gut aussehen.
• RLHF erzeugt Antworten, die gut gefunden wurden.

Beim RLHF bewertet der Mensch mehrere mögliche Antworten: A1, A2, A3 … → „A2 war am besten.“

Damit lernt das Modell:

• welche Antwort sicherer wirkt
• welche verständlicher ist
• welche hilfreicher ist
• welche korrekt(er) ist
• welche weniger toxisch ist
• welche die gewünschte Rolle besser einhält

Diese menschliche Bewertung wirkt als Belohnungssignal, das das Modell in Situationen führt, die beim SFT nicht explizit abgedeckt sind.

SFT kollabiert schnell in extremen Situationen

SFT wirkt nur bei Textsequenzen, die ähnlich zu den Trainingsbeispielen sind. Sobald ein User:

• ungewöhnliche Formulierungen wählt
• sehr knappe Befehle gibt
• versuchen würde, das Modell auszutricksen
• etwas Gefährliches verlangt
• Rollen durcheinanderbringt

… kann SFT versagen.

RLHF trainiert genau diese schwierigen Situationen — weil Menschen die Modelle gezielt in solche Ecken treiben, um gute Daten für die Belohnungsmodelle zu erzeugen.

SFT fördert manchmal unerwünschte „Überanpassung“

Wenn man nur SFT nutzt, kann folgendes passieren:

• Das Modell kopiert den Stil der Trainingsdialoge zu stark.
• Das Modell wirkt „musterhaft“ oder „hölzern“.
• Es reagiert zu formelhaft oder zu lang.
• Kleine Fehler der Trainingsdaten werden extrem verstärkt.

RLHF glättet das und sorgt für natürlicheres, robusteres, flexibleres Verhalten.

RLHF erlaubt es, das Modell auf nicht-messbare Ziele zu trainieren

Einige Ziele sind nicht direkt über SFT lernbar:

• Ehrlichkeit
• Präzision
• Vermeiden von Halluzinationen
• Richtige Unsicherheiten ausdrücken
• Vermeiden von „Nein-sagen-Reflex“ und gleichzeitig Vermeiden gefährlicher Antworten

Diese Eigenschaften entstehen nur durch systematische menschliche Bewertung über viele Varianten.

RLHF macht die Modellantworten stabiler über lange Kontexte

SFT-Modelle driften oft im Verlauf einer längeren Interaktion:

• Nach 10 bis 20 Antworten verlieren sie die Höflichkeit.
• Oder sie geben zu selbstbewusste Antworten.
• Oder sie rutschen in „do-anything“-Modi.

RLHF reduziert diese Drift stark, weil:

• Menschen in RLHF-Daten auch lange Kontexte bewerten
• das Policy-Modell dafür belohnt wird, über Zeit konsistent zu bleiben.

RLHF dient der Sicherheit

Ohne RLHF wären LLMs:

• leichter manipulierbar
• gefährlicher
• weniger berechenbar
• politisch verzerrter
• weniger kontrolliert
• anfälliger für Jailbreaks
• unzuverlässiger bei medizinischen oder technischen Ratschlägen

SFT kann Sicherheit nicht gewährleisten, RLHF schon — weil es direkt Präferenzsignale von Menschen über gefährliche oder wertbezogene Themen enthält.

Ablauf RLHF

Menschen oder Expertenteams erstellen eine Liste von Prompts, die typische Anwendungsfälle abdeckt. Manchmal werden Prompts automatisch vom Modell selbst erzeugt. Menschen wählen daraus interessante, herausfordernde oder diverse Varianten aus, die bewertet werden sollen.

Zu den Prompts gehören:

• Alltägliche Fragen („Wie koche ich Pasta?“)
• Fachliche Fragen („Wie funktioniert ein Halbleiter?“)
• Ethisch heikle oder riskante Fragen („Wie könnte man…?“)
• Extrem kurze, unvollständige, mehrdeutige Prompts

Diese Prompts sorgen dafür, dass das Modell auf sowohl einfache als auch problematische Situationen vorbereitet wird.

Das LLM (nach SFT) erzeugt für einen Prompt mehrere alternative Antworten:

• Prompt: „Erkläre, warum der Himmel blau ist.“
• Antwort 1: „Weil blaue Lichtwellen stärker gestreut werden …“
• Antwort 2: „Das Sonnenlicht wird in der Atmosphäre …“
• Antwort 3: „Die Farbe Blau kommt durch Streuung …“

Die Alternativen entstehen wie im Normalbetrieb durch Temperature und Top-p Sampling, d. h. es wird eine gewisse Zufälligkeit in den Antwort-Prozess eingebracht. Die verschiedenen Antworten werden dem Menschen zur Beurteilung präsentiert. Daraus entstehen Ranglisten oder Punktzahlen, die das Reward Model trainieren. Ein mögliches Bewertungsprotokoll:

• Nützlichkeit, Hilfsbereitschaft
• Korrektheit
• Höflichkeit, Toxizität
• Klarheit, Verständlichkeit
• Konsistenz im Dialog

Das Reward Model ist ein eigenes neuronales Netz, meist dieselbe Architektur wie das LLM, aber mit anderem Kopf („reward head“). Es lernt mit menschlichen Vergleichspaaren Sätze mit höherem menschlichen Ranking höher zu bewerten.

Sobald das Reward Model genügend trainiert ist, kann es anstelle eines echten Menschen gut voraussagen, wie ein Mensch eine Antwort auf eine Frage bewerten würde. Damit geht es nun an die Optimierung des eigentlichen LLMs. Das geschieht mit Hilfe der Proximal Policy Optimization. Dieser Optimierungsalgorithmus aus dem Reinforcement Learning sorgt dafür, dass das LLM

• sein vorheriges Wissen nicht verliert,
• nicht instabil wird
• und nicht zu halluzinieren beginnt.

Theorie Reinforcement Learning

Reinforcement Learning ist ein Belohnungslernen bzw. Verstärkungslernen. Mit Reinforcement Learning lernt das Modell, seine zukünftigen Entscheidungen so zu treffen, dass die Belohnung (Reward) maximiert wird. Reinforcement heisst zwar Stärkung oder Verstärkung, aber gemeint ist hier die Wirkung von Belohnungen, d. h. dass gewünschtes Verhalten durch positives Feedback wahrscheinlicher wird.

Im Zusammenhang mit LLMs und RLHF findet man Begriffe wie Policy Model und Actions. Irgendwann findet man heraus, dass Policy Model mit dem LLM gleichzusetzen ist und dass eine Aktion der Wahl eines Antwort-Tokens entspricht. Warum so kompliziert?

RLHF ist ein Spezialfall von Reinforcement Learning (RL). OpenAI, Anthropic, DeepMind usw. wollten die Theorie wenn immer möglich nicht neu erfinden. Ein LLM kann man formal so behandeln:

• Zustand = bisheriger Text
• Aktion = nächstes Token
• Reward = menschliche Bewertung
• Policy = das Modell, das Token-Wahrscheinlichkeiten ausgibt

Damit passen LLMs sauber in die bereits bestehende RL-Forschung (Banditenprobleme, PPO, KL-Regularisierung, Exploration/Exploitation usw.). Das ist kompatibel mit vorhandenen RL-Algorithmen und Frameworks.

RLHF-artige Verfahren kommen inzwischen zum Einsatz bei:

• Bildmodellen (welches Bild generieren?)
• Multimodalen Agenten (welche Aktion ausführen?)
• Codeagenten (welchen nächsten Schritt im Programm ausführen?)
• Modellierten digitalen Assistenten (Button klicken? Maus bewegen?)
• Robotern (Greifen, Gehen etc.)

Dort ist „Token“ nicht mehr die richtige Beschreibung. Aber der Begriff „Aktion“ passt überall. Darum wurde der RL-Begriff generisch beibehalten.

Websuche

Das im LLM gespeicherte Wissen ist oft nicht ganz aktuell. Es kann durchaus zwei Jahre alt sein. Deshalb nutzt ChatGPT manchmal als Ergänzung auch eine konventionelle Websuche. Technisch gesehen ist das eine externe Informationsquelle, die temporär in den Antwortprozess eingebunden wird.

Beispiel:

• Prompt: „Wann wurde Albert Einstein geboren?“

• Das LLM generiert damit die Suchanfrage: Albert Einstein Geburtsdatum

• Die Suchmaschine (intern bei OpenAI oder über Partnerdienste) liefert eine Liste von Dokumenten oder Snippets.

• Meist werden nur kurze Textausschnitte aus Webseiten extrahiert, nicht die gesamte Seite.

• Die abgerufenen Inhalte werden temporär als Kontext in den Prompt eingefügt.

• Das LLM sieht sie quasi wie zusätzlichen Text am Anfang des Eingabefeldes. Beispiel:

  [Webinformationen: Albert Einstein wurde am 14. März 1879 in Ulm geboren …]
  Benutzerfrage: Wann wurde Albert Einstein geboren?

• Das LLM verarbeitet nun Webinformationen und Prompt gemeinsam.

• Die Wahrscheinlichkeit der nächsten Tokens wird durch die Inhalte der abgerufenen Snippets beeinflusst. Damit enthält die Antwort auch die Webinformation oder Teile davon.

Chatbot

Wie baut man einen Chatbox mit spezifischem Firmenwissen auf? Ein ganzes LLM dafür zu trainieren, ist in der Regel zu aufwendig.

Fine-Tuning

Man könnte theoretisch das LLM mit firmenspezifischen Texten nachtrainieren. In der Praxis ist das oft zu teuer und unnötig, da LLMs schon sehr gute Sprachfähigkeiten haben. Fine-Tuning macht nur Sinn, wenn sehr spezifische Tonalität oder Unternehmensrichtlinien erlernt werden sollen.

RAG – Retrieval-Augmented Generation

Häufig ergänzt man das Wissen des LLM, indem es auf externe Datenbanken zugreift, statt alles intern im Modell zu speichern. Typischer Ablauf:

• Dokumente aufbereiten: Firmen-Wikis, Produktinfos, Handbücher usw. werden in kleine Abschnitte zerlegt.
• Vektor-Index erstellen: Jedes Dokument-Segment wird in einen Embedding-Vektor umgewandelt. Die Vektoren werden in einer Suchstruktur wie FAISS, Milvus oder Pinecone gespeichert.
• Querying: Der Benutzer stellt eine Frage, die ebenfalls in einen Embedding-Vektor umgewandelt wird. Eine ähnlichkeitsbasierte Suche liefert die relevantesten Dokumente.
• Kombinieren mit LLM: Die gefundenen Dokumente werden dem LLM als zusätzlicher Kontext in den Prompt eingefügt. Das LLM generiert die Antwort auf Basis von Firmenwissen + Sprachmodell-Kenntnissen.

Interne Websuche

Natürlich lässt sich auch eine interne Websuche o. ä. wie eine externe Websuche integrieren. Vergleichen mit RAG gibt es Vor- und Nachteile:

• Für moderne Chatbots, die auf natürliche Sprache reagieren sollen, wird RAG häufiger eingesetzt, weil es flexibler bei ungenauen oder paraphrasierten Fragen ist.

• Interne Suchdienste kommen oft als schnelle, pragmatische Lösung zum Einsatz, gerade in Unternehmen, die schon eine etablierte Suche haben.

Geschichte

Grundlagenforschung

• Neuronale Netze gibt es seit den 1980er Jahren, aber frühe Modelle hatten zu wenig Rechenleistung und Daten.
• Word Embeddings (z. B. Word2Vec, GloVe) gaben erstmals numerische Repräsentationen für Wörter, die semantische Ähnlichkeiten erfassen.
• Diese Grundlagen machten die spätere Arbeit an grösseren Modellen möglich.

Innovation Transformer

• 2017 stellte Google den Transformer vor („Attention is All You Need“).
• Kerninnovation: Self-Attention, wodurch das Modell kontextabhängig für jedes Wort gewichtet, ohne Rekurrenz oder Convolution.
• Vorteile:
  • Parallelisierbar → Training auf sehr grossen Datensätzen möglich
  • Kontextualisierung über lange Textstrecken

Grosse Trainingsdaten

• Modelle werden auf hunderten Milliarden Tokens trainiert: Bücher, Webseiten, Kuratierte Datensätze.
• Massive Datenmengen sind entscheidend für die Fähigkeit, Sprache zu verstehen und zu generieren.

Feintuning und RLHF

• Rein statistische Modelle alleine würden viele Fehler machen und nicht freundlich oder hilfreich antworten.
• Reinforcement Learning from Human Feedback (RLHF) leitet das Verhalten:
  • Freundlichkeit, Konsistenz, Vermeidung problematischer Inhalte
  • Verstärkt gewünschte Antwortmuster, die im Rohtraining nur schwach gelernt wurden

Optimierung der Infrastruktur

• Hardware: GPUs, TPUs, spezielle Speicheroptimierungen
• Software: verteiltes Training, Mixed Precision, effiziente Transformer-Implementierungen
• Sampling-Strategien, Filter, Moderation
• Alles zusammen ermöglicht die schnelle, kohärente Generierung von Texten in Echtzeit