0.1. Was sind LLMs

Ein Large Language Model (LLM) ist ein statistisches Modell für Sprache. Es wurde mit sehr großen Mengen an Text (und oft auch Code) trainiert. Seine zentrale Fähigkeit ist nicht „Denken“ im menschlichen Sinn, sondern das Vorhersagen des jeweils nächsten Stücks Text.

Aus dieser einen Fähigkeit entsteht erstaunlich viel: Erklärungen, Zusammenfassungen, Übersetzungen, Programmcode, Entwürfe und Dialoge. Genau deshalb wirken LLMs intelligent – und genau deshalb machen sie auch charakteristische Fehler.

Large Language Model lässt sich in drei Teile zerlegen:

• Language: Das Modell arbeitet mit Sprache. Dazu gehören natürliche Sprache ebenso wie Quellcode, Markup, Konfigurationsdateien oder Tabellen in Textform.
• Model: Es handelt sich um ein gelerntes Modell, nicht um ein regelbasiertes Expertensystem. Niemand hat dem System Satz für Satz beigebracht, wie Java oder Deutsch „richtig“ geht. Stattdessen hat es aus Beispielen Wahrscheinlichkeiten gelernt.
• Large: Die Modelle sind groß – sowohl in der Menge der Trainingsdaten als auch in der Zahl der internen Parameter. Diese Größe ist ein wichtiger Grund dafür, dass heutige Systeme so vielseitig wirken.

Bekannte Beispiele sind ChatGPT, Claude, Gemini oder auch frei verfügbare Modelle wie Llama. Die Produkte unterscheiden sich in Qualität, Tempo, Kontextgröße und Ausstattung. Die grundlegende Arbeitsweise ist aber vergleichbar.

Ein LLM erzeugt Text schrittweise. Es bekommt eine Eingabe (den Prompt) und schätzt dann, welches nächste Textstück am wahrscheinlichsten folgt. Dieses Stück wird angehängt, danach kommt das nächste, und so weiter.

Das klingt simpel, reicht in der Praxis aber aus, um lange, zusammenhängende Antworten zu erzeugen. Wenn der bisherige Text wie eine Java-Klasse aussieht, wird als Nächstes eher eine Methode oder eine schließende Klammer folgen als ein Kochrezept. Wenn der Text wie eine Erklärung klingt, setzt das Modell die Erklärung fort.

Wichtig ist die Richtung: Das Modell setzt fort, was bereits da ist. Es sucht nicht in einer Wissensdatenbank nach der einen richtigen Antwort. Es erzeugt den Text, der in dieser Situation am plausibelsten wirkt.

Deshalb hängt die Qualität einer Antwort stark vom Prompt ab. Klare Aufgabe, sinnvoller Kontext und Beispiele verschieben, was „plausibel“ ist. Unklare oder widersprüchliche Vorgaben tun das ebenfalls – nur eben in die falsche Richtung.

Intern arbeitet ein LLM nicht mit Wörtern, sondern mit Tokens. Ein Token ist ein kurzes Textstück: ein Wort, ein Wortteil, ein Satzzeichen, ein Stück Quellcode.

Aus dem Satz int anzahl = 5; werden intern mehrere Tokens. Das Modell „sieht“ also keine Buchstabenkette so, wie ein Mensch sie liest, sondern eine Folge solcher Bausteine.

Das hat praktische Folgen:

• Es gibt eine Obergrenze, wie viele Tokens das Modell auf einmal berücksichtigen kann. Das ist das Kontextfenster.
• Längere Gespräche, große Dateien oder viele angehängte Dokumente füllen dieses Fenster. Was nicht mehr hineinpasst, fällt für die aktuelle Antwort faktisch weg.
• Kosten und Geschwindigkeit hängen oft an der Tokenmenge, nicht an der Zahl der Wörter.

Für die Arbeit mit LLMs reicht es, Tokens als die interne Zähleinheit zu verstehen. Die genaue Zerlegung muss man nicht kennen.

Ein LLM wird nicht programmiert wie eine normale Anwendung. Es wird trainiert.

Zuerst kommt in der Regel ein Vortraining auf sehr großen Textmengen aus dem Internet, aus Büchern, Dokumentationen und oft auch öffentlichen Code-Repositories. Dabei lernt das Modell Muster: Grammatik, Fakten, die in den Daten häufig vorkommen, typische Programmierstile, gängige Erklärungen.

Danach folgen meist weitere Schritte, damit das Modell nützlich wird:

• Feinabstimmung auf Dialoge, Anweisungen und Aufgaben („Beantworte die Frage“, „Schreibe eine Funktion“, „Erkläre den Fehler“).
• Häufig auch eine Ausrichtung an gewünschtem Verhalten: hilfreich, höflich, vorsichtig bei gefährlichen Themen, eher strukturierte Antworten statt beliebig fortgesetzter Texte.

Was danach im Modell steckt, ist kein nachschlagbares Archiv. Es sind verdichtete statistische Zusammenhänge. Häufige, gut belegte Muster sitzen fest. Seltene Details, aktuelle Ereignisse nach dem Trainingsstichtag oder sehr spezielle Fachfragen sitzen unsicher oder fehlen ganz.

Viele Produkte ergänzen das Modell deshalb um Werkzeuge: Suche, Dateizugriff, Code-Ausführung, Anbindung an eine Wissensbasis. Das ändert die Nutzung erheblich. Das Kernmodell selbst bleibt trotzdem ein Textfortsetzer.

Wie diese Anpassung technisch läuft — neuronales Netz, Verlust, Backpropagation, Gradient Descent — steht weiter unten unter den technischen Hintergründen.

Ein LLM hat in der einzelnen Anfrage nur das, was im Kontext liegt:

• den Systemhinweis oder die Grundanweisung
• den bisherigen Gesprächsverlauf
• den aktuellen Prompt
• zusätzlich übergebene Dateien, Codeausschnitte oder Suchergebnisse

Es erinnert sich nicht von sich aus an gestern, an andere Projekte oder an „die ganze Codebasis“. Wenn ein Produkt das so wirkt, liegt das an gespeicherten Chats, Indexen, Regeln oder extra angebundenen Daten – nicht daran, dass das Modell ein dauerhaftes Gedächtnis hätte.

Deshalb ist es in der Praxis oft wichtiger, den richtigen Kontext zu liefern, als möglichst viele Einzelheiten der Syntax selbst zu kennen. Das Modell kann Boilerplate und API-Aufrufe oft selbst erzeugen. Es kann aber nicht wissen, welche Fachregel in diesem Projekt gilt, wenn niemand sie ihm gibt.

LLMs wirken klug, weil Sprache und Denken für uns eng zusammenhängen. Wer eine gute Erklärung, einen sinnvollen Plan oder lauffähigen Code formuliert, dem unterstellen wir Verständnis.

Ein LLM kann genau das: Muster aus unzähligen Erklärungen und Programmen so kombinieren, dass eine neue, oft brauchbare Formulierung entsteht. Es kann Zwischenschritte aufschreiben, Alternativen gegenüberstellen und Einwände vorwegnehmen. Manche Systeme sind zusätzlich darauf trainiert, länger „nachzudenken“, also erst eine interne Kette von Zwischenschritten zu erzeugen und dann die Antwort.

Das ist leistungsfähig. Es ist aber kein Garant für Wahrheit. Das Modell optimiert auf plausible Fortsetzung, nicht auf nachgewiesene Korrektheit. Ein selbstsicherer Ton sagt wenig darüber, ob die Aussage stimmt.

LLMs sind besonders gut, wenn Sprache, Muster und vorhandener Kontext reichen:

• Formulieren, Umformulieren, Zusammenfassen
• Code erzeugen, umbauen und erklären
• Boilerplate, Tests, Dokumentation und wiederkehrende Strukturen
• Ideen sammeln, Alternativen skizzieren, Checklisten erstellen
• Fremden Code oder fremde Texte schneller zugänglich machen

Genau das verschiebt in der Softwareentwicklung die Gewichte. Viele Details, die man früher nachschlagen oder auswendig kennen musste, kann das Modell übernehmen. Die Arbeit des Menschen verlagert sich stärker auf Ziel, Kontext, Architektur, Prüfung und Verantwortung.

Einige Grenzen folgen direkt aus der Arbeitsweise:

• Halluzinationen: Das Modell kann Dinge erfinden, die korrekt klingen: APIs, die es nicht gibt, Methoden mit falschen Parametern, Quellen, die nie existierten.
• Keine zuverlässige Weltprüfung: Ohne angebundene Werkzeuge führt das Modell den Code nicht wirklich aus und prüft Fakten nicht gegen die Realität.
• Kein belastbares Langzeitgedächtnis: Was nicht im Kontext steht, ist für die aktuelle Antwort nicht vorhanden.
• Trainingsstichtag: Reines Modellwissen endet irgendwann. Neuere Bibliotheken, geänderte APIs oder aktuelle Ereignisse fehlen, solange sie nicht über Tools oder den Prompt nachgeliefert werden.
• Unsicherheit bei Seltenem: Je spezieller, neuer oder widersprüchlicher ein Thema ist, desto eher rät das Modell.
• Kein eigenes Ziel: Das Modell will nichts erreichen. Es setzt den Prompt fort. Steuerung, Prioritäten und Verantwortung bleiben beim Menschen.

Für die Praxis heißt das: Ein LLM ist ein sehr starker Assistent, aber kein Ersatz für Verständnis und Kontrolle. Besonders bei Code gilt: Lesen, prüfen, testen. Die Nutzungsprobleme — Halluzinationen, Datenschutz, unsicherer Code, Tools — führe ich unter Probleme bei der Nutzung aus.

Wer mit LLMs arbeitet, braucht für die Nutzung kein vollständiges Bild der inneren Mathematik. Entscheidend sind ein paar Haltungen:

• Das Modell setzt Text fort. Gute Vorgaben erzeugen bessere Fortsetzungen.
• Kontext ist die eigentliche Steuerung: Ziel, Randbedingungen, vorhandener Code, gewünschtes Format.
• Details wie Syntax und Boilerplate werden unwichtiger, weil das Modell sie oft selbst liefert.
• Wichtiger werden die Fragen, die das Modell nicht allein klären kann: Was soll entstehen? Welche Architektur passt? Was darf es nicht tun? Wie erkenne ich, dass die Antwort falsch ist?

Diese Verschiebung ist der Grund, warum ich die Inhalte dieser Webseite umstrukturieren und stärker auf die Arbeit mit KI ausrichten möchte.

Wer trotzdem sehen will, was unter der Textfortsetzung liegt, findet das im nächsten Abschnitt.

Ein LLM ist ein künstliches neuronales Netz. Es rechnet nicht mit Wörtern, sondern mit Zahlenvektoren. Die Architektur, die diese Vektoren verknüpft, ist der Transformer: Er erzeugt für jedes Token Query, Key und Value und mischt über Attention, welche anderen Tokens gerade relevant sind. Die Gewichte dieses Netzes entstehen nicht durch Programmieren. Sie entstehen durch Training mit Backpropagation und Gradient Descent.

Die Kernoperation bleibt dieselbe wie oben: das nächste Token vorhersagen. Hier liegt die Maschine darunter.

Ein künstliches Neuron ist kein biologisches Vorbild, sondern ein kleiner Rechenschritt. Es nimmt Zahlen entgegen, multipliziert sie mit Gewichten, addiert und schickt das Ergebnis durch eine nichtlineare Funktion. Viele solche Schritte nebeneinander bilden eine Schicht. Viele Schichten hintereinander bilden ein tiefes Netz.

Was das Netz „kann“, steckt in diesen Gewichten — den Parametern. Bei heutigen LLMs sind das Milliarden bis Billionen Zahlen. Niemand setzt sie von Hand. Ein Forward-Pass ist dann: Tokens hinein, Schicht für Schicht durchs Netz, am Ende eine Wahrscheinlichkeitsverteilung über das nächste Token.

Ohne Nichtlinearität zwischen den Schichten wäre das ganze Netz nur eine große Matrixmultiplikation. Die Zwischenfunktionen machen es möglich, verschachtelte Muster zu lernen: Grammatik, Klammern im Code, „diese Variable wurde drei Sätze zuvor deklariert“.

Das Netz rechnet nur mit Zahlen. Wörter — genauer: Tokens — werden deshalb zuerst in einen Vektor übersetzt: eine Liste von Gleitkommazahlen fester Länge. Das ist das Embedding.

Diese Vektoren sind nicht beliebig. Im Training rücken Tokens, die in ähnlichen Kontexten vorkommen, im Raum näher zusammen. Deshalb können Richtungen im Raum semantische Beziehungen tragen. Das klassische Beispiel aus älteren Wortvektoren: König minus Mann plus Frau landet in der Nähe von Königin. Im Transformer sitzt dieselbe Idee als erste Schicht — eine Tabelle, die jeder Token-ID einen Vektor zuordnet.

Dazu kommt die Position. Attention allein sieht keine Reihenfolge. Deshalb erhält jedes Token zusätzlich eine Positionsinformation. Sonst wären „der Hund beißt den Mann“ und „der Mann beißt den Hund“ dieselbe Menge von Vektoren.

Aus int anzahl = 5; wird intern also nicht der Text, den ein Mensch liest, sondern eine Folge von Vektoren. Alles, was danach im Netz passiert, ist Rechnung mit diesen Vektoren.

Die Architektur hinter GPT, Claude, Llama und vergleichbaren Modellen ist der Transformer von 2017. Die Geschichte dieser Architektur steht unter Geschichte der LLMs. Hier geht es um die Operation darin: Self-Attention.

Für jedes Token erzeugt das Netz drei Vektoren:

• Query (Q): Wonach suche ich gerade?
• Key (K): Wofür stehe ich, wenn andere suchen?
• Value (V): Was gebe ich weiter, wenn ich getroffen werde?

Attention vergleicht die Query eines Tokens mit den Keys der anderen Tokens im Kontext. Hohe Übereinstimmung heißt: dieses andere Token ist jetzt relevant. Die Treffer werden in Gewichte zwischen 0 und 1 umgerechnet, die sich zu 1 addieren. Aus den Values entsteht dann ein gewichteter Mix.

Ein Satz wie „Die Datei, die der Server nicht finden konnte, lag …“ macht das konkret. Bei „finden“ kann das Netz stark auf „Datei“ achten — nicht nur auf das Wort daneben. Genau das war vor dem Transformer unbequem: rekurrente Netze mussten die relevante Information Schritt für Schritt mitschleifen. Attention springt.

Bei Decoder-only-Modellen (der GPT-Linie) darf jedes Token nur auf sich und die vorherigen Tokens schauen. Die Zukunft bleibt unsichtbar. Genau das erzwingt die Fortsetzung von links nach rechts.

Ein Transformer macht das nicht einmal und nicht mit einem Blick. Multi-Head Attention führt mehrere solche Vergleiche parallel: ein Kopf kann auf Syntax achten, ein anderer auf Namen, ein dritter auf die schließende Klammer. Danach folgt pro Position ein kleines Feed-Forward-Netz. Dieser Block wiederholt sich viele Male. Jede Schicht sieht denselben Kontext, aber auf einer abstrakteren Stufe.

Das Kontextfenster ist deshalb keine weiche Empfehlung. Attention läuft über die Tokens, die gerade im Fenster liegen. Was nicht darin ist, kann keine Query treffen.

Die Gewichte startet man zufällig. Ein untrainiertes Netz erzeugt Rauschen. Training ist wiederholte Korrektur derselben vier Schritte:

1. Das Netz sieht eine Tokenfolge und sagt das nächste Token voraus (Forward-Pass).
2. Die Vorhersage wird mit dem tatsächlich nächsten Token verglichen. Die Abweichung ist der Verlust (Loss).
3. Backpropagation rechnet rückwärts durchs Netz, wie stark jedes Gewicht am Verlust beteiligt war. Das liefert den Gradienten: die Richtung, in der der Fehler lokal am stärksten steigt.
4. Gradient Descent macht einen kleinen Schritt in die entgegengesetzte Richtung. Der Verlust soll sinken, nicht steigen.

Das wiederholt sich über kleine Batches, über Milliarden von Tokens. Niemand verdrahtet „so funktioniert eine for-Schleife“. Das Netz passt Gewichte so an, dass die nächste-Token-Vorhersage auf den Trainingsdaten besser wird. Grammatik, APIs, Erklärstile und häufige Fakten sind Nebenprodukte dieser einen Aufgabe.

Dieselbe Maschine trägt die späteren Stufen. Feinabstimmung und Ausrichtung ändern Daten und Ziel, nicht das Prinzip: Verlust messen, Gradient berechnen, Gewichte verschieben.

Was nach dem Training in den Gewichten steckt, bleibt verteilt. Es gibt keine Zelle „Java 21“. Es gibt Richtungen im Vektorraum und Schaltungen in Attention-Köpfen, die zusammen den nächsten Token so setzen, als wüsste das Netz Bescheid.

Die Aussagen oben sind bewusst an Originalarbeiten und Herstellerdokumentationen angelehnt, nicht an Blog-Zusammenfassungen. Die meisten Quellen sind Englisch – das sind die Dokumente, in denen die Labore selbst beschreiben, wie die Systeme funktionieren.

Formulierungen wie „nicht Denken“ sind eine didaktische Vereinfachung. Gemeint ist die technische Kernoperation: das Modell erzeugt das jeweils nächste Textstück. Ob man das philosophisch „Denken“ nennen will, ist eine andere Debatte.

Note

Wer nur eine Quelle lesen will: Shanahan erklärt die Kernidee am klarsten. Wer die Technik sehen will: den Transformer, ergänzt um GPT-2. Wer Grenzen braucht: den GPT-4-Bericht.

• Murray Shanahan: Talking About Large Language Models (2023) (extern)
  Die beste lesbare Primärquelle zur Kernaussage dieses Textes. Shanahan beschreibt LLMs als generative statistische Modelle über Tokens: Die eigentliche Frage an das Modell lautet nicht „Was ist wahr?“, sondern „Wie geht dieser Text wahrscheinlich weiter?“. Er erklärt auch, warum flüssige Sprache uns Verständnis unterstellen lässt.

• OpenAI: Better language models and their implications (2019) (extern)
  Zugängliche Darstellung von GPT-2. OpenAI formuliert die Lernaufgabe ausdrücklich als: das nächste Wort vorhersagen, gegeben die bisherigen Wörter. Derselbe Mechanismus zeigt ohne extra Aufgabentraining Ansätze von Übersetzung, Fragenbeantwortung, Leseverständnis und Zusammenfassung.

• Radford et al.: Language Models are Unsupervised Multitask Learners (GPT-2, 2019) (extern)
  Das zugehörige Paper. Es belegt, dass aus der einen Vorhersageaufgabe viele Sprachleistungen entstehen können, wenn Modell und Daten groß genug sind.

• Brown et al.: Language Models are Few-Shot Learners (GPT-3, 2020) (extern)
  Zeigt, was „Large“ konkret heißt: ein autoregressives Modell mit 175 Milliarden Parametern, trainiert auf sehr großen Textmengen. Aufgaben und Beispiele stehen im Prompt; die Gewichte werden dafür nicht extra angepasst. Das bestätigt sowohl die Skalierung als auch die starke Abhängigkeit vom Prompt.

• OpenAI Help: Understanding and counting tokens (extern)
  Offizielle Erklärung: Modelle verarbeiten Text als Tokens (Zeichen, Wortteile, ganze Wörter, Satzzeichen). Tokenzahl ist nicht Wortzahl. Darüber werden Nutzung und Abrechnung gezählt.

• OpenAI API: Key concepts (extern)
  Prompt und erzeugte Ausgabe müssen zusammen in die maximale Kontextlänge passen. Das ist genau das Kontextfenster aus dem Text.

• Anthropic: Context windows (extern)
  Herstellerdokumentation zum Kontextfenster: Was in der Anfrage liegt, zählt; bei langen Gesprächen füllt sich das Fenster; ältere Teile müssen gekürzt oder zusammengefasst werden, sonst fallen sie weg.

• OpenAI: Prompting (extern)
  „The quality of your output often depends on how well you’re able to prompt the model.“ Klare Aufgabe, Beispiele und Struktur im Prompt verschieben, was das Modell als plausible Fortsetzung behandelt.

• Chen et al.: Evaluating Large Language Models Trained on Code (Codex, 2021) (extern)
  Belegt, dass Modelle nicht nur auf natürlicher Sprache, sondern auf öffentlichem Code (hier: GitHub) trainiert werden. Codex ist ein GPT, das auf Code nachtrainiert wurde; eine Produktionsvariante trieb GitHub Copilot.

• Ouyang et al.: Training language models to follow instructions with human feedback (InstructGPT, 2022) (extern)
  Die klassische Pipeline nach dem Vortraining: zuerst Feinabstimmung auf gewünschte Antworten, danach Ausrichtung mit menschlichem Feedback (RLHF). Größer allein macht ein Modell nicht automatisch hilfreicher oder ehrlicher.

• Touvron et al.: Llama 2: Open Foundation and Fine-Tuned Chat Models (2023) (extern)
  Offenes Gegenstück zu den geschlossenen Chat-Produkten: Vortraining, Dialog-Feinabstimmung und Sicherheitsausrichtung. Die grundlegende Arbeitsweise bleibt vergleichbar, auch wenn Qualität und Ausstattung differieren.

• Lewis et al.: Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (RAG, 2020) (extern)
  Wichtige Präzisierung: In den Gewichten steckt Wissen, aber kein nachschlagbares Archiv, das man leicht aktualisieren könnte. RAG koppelt das generative Modell an einen externen Index. Das bestätigt sowohl „kein Lexikon im Modell“ als auch die spätere Produktidee, Suche und Wissensbasen anzubinden.

• OpenAI: Function calling (extern)
  Das Kernmodell führt Code nicht selbst aus und prüft die Welt nicht selbst. Es kann strukturierte Werkzeugaufrufe erzeugen; die Anwendung sucht, rechnet oder führt aus und gibt das Ergebnis zurück in den Kontext.

• Wei et al.: Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (2022) (extern)
  Zwischenschritte aufzuschreiben verbessert bei hinreichend großen Modellen Rechen-, Alltags- und Symbolaufgaben. Das ist immer noch Textfortsetzung – nur mit einer längeren Kette vor der Antwort.

• OpenAI: Learning to reason with LLMs (o1, 2024) (extern)
  Manche Systeme werden darauf trainiert, länger „nachzudenken“: erst eine interne Kette von Schritten, dann die sichtbare Antwort. OpenAI beschreibt das ausdrücklich als Chain of Thought, die per Verstärkungslernen verbessert wird.

• OpenAI: GPT-4 (2023) (extern)
  First-Party-Bestätigung der Grenzen: Das Modell halluziniert, ist nicht vollständig zuverlässig, kann selbstsicher falsch liegen, kennt Ereignisse nach dem Trainingsstichtag nicht zuverlässig und lernt nicht dauerhaft aus dem Gespräch. OpenAI rät bei wichtigen Einsätzen zu menschlicher Prüfung.

• Ji et al.: Survey of Hallucination in Natural Language Generation (2023) (extern)
  Fachüberblick: Generative Modelle erzeugen flüssigen Text, der unbeabsichtigt erfundene Inhalte enthalten kann. Genau das ist mit Halluzinationen gemeint – inklusive erfundener Fakten und Quellen.

• Kandpal et al.: Large Language Models Struggle to Learn Long-Tail Knowledge (2023) (extern)
  Empirischer Beleg für „Unsicherheit bei Seltenem“: Je seltener ein Fakt im Trainingsmaterial vorkommt, desto unsicherer sitzt er im Modell. Retrieval hilft – reines Modellwissen skaliert hier schlecht.

• Rumelhart, Hinton, Williams: Learning representations by back-propagating errors (1986) (extern)
  Die klassische Darstellung von Backpropagation: Der Fehler wird rückwärts durchs Netz geschickt, jedes Gewicht erhält einen Gradienten, die Gewichte werden entgegen diesem Gradienten angepasst. Genau die Trainingsmaschine unter den späteren LLMs.

• Bengio, Ducharme, Vincent, Jauvin: A Neural Probabilistic Language Model (2003) (extern)
  Wörter als verteilte Zahlenvektoren in einem Sprachmodell. Die Einbettung ist hier schon Teil der Vorhersage des nächsten Wortes, nicht nur eine separate Wortähnlichkeit.

• Mikolov et al.: Efficient Estimation of Word Representations in Vector Space (Word2Vec, 2013) (extern)
  Zugängliche, skalierbare Wortvektoren. Ähnliche Kontexte landen nahe beieinander. Die Idee sitzt in Transformern als Embedding-Schicht weiter.

• Mikolov, Yih, Zweig: Linguistic Regularities in Continuous Space Word Representations (2013) (extern)
  Der Beleg für Rechnen im Vektorraum: König − Mann + Frau landet nahe bei Königin. Das ist die Intuition hinter „Tokens werden Zahlenvektoren“.

• Vaswani et al.: Attention Is All You Need (2017) (extern)
  Der Transformer. Scaled Dot-Product Attention aus Query, Key und Value, Multi-Head Attention, Positionsinformation, gestapelte Blöcke. Die Architekturfamilie hinter den heutigen Decoder-only-LLMs.

Diese Texte gehen tiefer, als dieser Einführungsartikel muss:

• Kaplan et al.: Scaling Laws for Neural Language Models (2020) (extern) – warum Größe von Daten, Parametern und Rechenaufwand so stark wirkt.
• Bai et al.: Constitutional AI (Anthropic, 2022) (extern) – eine andere Ausrichtungsmethode neben RLHF: hilfreich und vorsichtig über Prinzipien statt nur über menschliche Bewertungen.
• Bender und Koller: Climbing towards NLU (2020) (extern) – die schärfere These, dass Form (Textstatistik) nicht automatisch Bedeutung ist. Shanahan baut darauf auf.