<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
  <title>Paweł Dubiel Tech Blog: Glossar</title>
  <link>https://paweldubiel.com/de</link>
  <atom:link href="https://paweldubiel.com/de/glossary.xml" rel="self" type="application/rss+xml" />
  <description>Notizen über KI, Sprachmodelle und Softwareentwicklung.</description>
  <language>de</language>
  <lastBuildDate>Mon, 12 Oct 2026 00:00:00 GMT</lastBuildDate>
<item>
  <title>Validation Set</title>
  <link>https://paweldubiel.com/de/glossary/validation-set</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/validation-set</guid>
  <pubDate>Mon, 12 Oct 2026 07:17:31 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du betreibst einen Eisstand und möchtest den täglichen Absatz anhand der Temperatur vorhersagen. Du hast drei Tage notiert: Bei 20°C wurden 20 Portionen verkauft, bei 22°C waren es 30 und bei 24°C…</description>
  <content:encoded><![CDATA[<p>Du betreibst einen Eisstand und möchtest den täglichen Absatz anhand der Temperatur vorhersagen. Du hast drei Tage notiert: Bei 20°C wurden 20 Portionen verkauft, bei 22°C waren es 30 und bei 24°C waren es 28. Du vergleichst drei Regeln: immer 24 Portionen, eine Gerade und eine Kurve, die genau durch alle drei Ergebnisse verläuft. Die letzte Regel macht im Notizbuch keinen einzigen Fehler. Sollte sie den Vorrat für morgen planen?</p>
<p>Eine erneute Prüfung derselben Tage beantwortet diese Frage nicht. Die flexible Regel könnte sich auch an Zufälle angepasst haben, etwa an eine ungewöhnlich große Reisegruppe bei 22°C. Bevor du eine Regel auswählst, legst du andere Tage zum Vergleich der Kandidaten beiseite. <strong>Validation Set</strong> ist ein gesonderter Teil der Daten, der zur Auswahl eines Modells oder seiner Einstellungen dient, statt dessen gelernte Zahlen anzupassen. Diese Trennung beschreiben <a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio und Courville, <em>Deep Learning</em>, §5.3</a>.</p>
<p><img src="https://paweldubiel.com/assets/validation-set-tasting-tray-and-sealed-sample.webp" alt="Drei Eisproben zum Vergleichen und ein gesonderter Behälter mit unversehrtem Siegel: eine Metapher für Auswahldaten und eine getrennte abschließende Bewertung." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="ein-notizbuch-zum-lernen-andere-tage-zur-auswahl">Ein Notizbuch zum Lernen, andere Tage zur Auswahl</h2>
<p>Die Regeln und ihre Zahlen legen wir ausschließlich anhand der Trainingsdaten fest. Die Gerade sagt das Doppelte der Temperatur minus 20 voraus. Die Kurve ist ein Bogen, der an die drei Punkte im Notizbuch angepasst wurde. Mittlerer absoluter Fehler bedeutet hier: Berechne für jeden Tag, um wie viele Portionen die Vorhersage danebenliegt, ignoriere das Vorzeichen und bilde den Durchschnitt.</p>
<p>An den beiseitegelegten Tagen mit 21°C, 23°C und 25°C wurden 23, 25 beziehungsweise 31 Portionen verkauft. Die Kurve sagt 26,5, 30,5 und 22,5 voraus; ihr mittlerer Fehler beträgt etwa 5,83 Portionen. Die Gerade sagt 22, 26 und 30 voraus: Ihr Fehler beträgt 1 Portion. Deshalb wählen wir die Gerade, obwohl sie im Notizbuch mit 2 zu 0 verlor. <strong>Das Validation Set hat keine Regel verbessert; es hat bei der Auswahl unter drei Regeln geholfen.</strong> Die Daten sind erfunden. Vorhersagen mit Bruchteilen meinen den erwarteten Absatz, nicht das Aufteilen einer Portion.</p>
<div id="validation-set-lab"></div>
<h2 id="nach-der-auswahl-braucht-es-noch-eine-abschließende-bewertung">Nach der Auswahl braucht es noch eine abschließende Bewertung</h2>
<p>Die zur Auswahl verwendeten Tage haben die Entscheidung bereits beeinflusst. Ein dritter, überschneidungsfreier Teil der Daten, das <em>test set</em>, dient deshalb erst zur Bewertung der festgelegten Lösung. Im Beispiel liegt die Gerade an zwei zuvor verdeckten Tagen im Durchschnitt um 1 Portion daneben. Änderst du nach diesem Ergebnis die Regel, dienen diese Tage ebenfalls der Auswahl; sie verlieren ihre Rolle als unabhängiger Test (§5.3).</p>
<p>Das ist eine wichtige Einschränkung: Nach vielen Versuchen kann sich die Auswahl an das Validation Set selbst anpassen und ein zu optimistisches Ergebnis liefern. Die drei beiseitegelegten Tage sind hier nur eine Lernhilfe, keine verlässliche Bewertung tatsächlicher Verkäufe. Kein festgelegter Prozentsatz für die Aufteilung garantiert eine gute Messung.</p>
<ul>
<li><a href="https://paweldubiel.com/de/glossary/overfitting">Overfitting</a> beschreibt eine übermäßige Anpassung an Trainingsbeispiele; gesonderte Daten helfen, die Wirkung zu erkennen.</li>
<li><a href="https://paweldubiel.com/de/glossary/fine-tuning">Fine-tuning</a> ist das weitere Training eines vorhandenen Modells; ein Validation Set kann zur Wahl der Einstellungen dienen.</li>
<li><a href="https://paweldubiel.com/de/glossary/kreuzentropie">Cross-entropy</a> ist eine andere Art der Fehlermessung, die häufig bei Textvorhersagen verwendet wird; die Trennung der Datenrollen bleibt gleich.</li>
</ul>
<p><em>Text und Illustration wurden mit KI-Unterstützung erstellt. Daten, Regeln und Demonstration sind ein eigenes vereinfachtes Beispiel; die Illustration ist eine Metapher für die Auswahl und das Aufbewahren einer gesonderten Probe.</em></p>]]></content:encoded>
</item>
<item>
  <title>Overfitting</title>
  <link>https://paweldubiel.com/de/glossary/overfitting</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/overfitting</guid>
  <pubDate>Sun, 11 Oct 2026 15:59:40 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du betreibst einen Eisstand. 10 Tage lang hast du in einem Heft die Temperatur am Mittag und die Zahl der verkauften Kugeln notiert.</description>
  <content:encoded><![CDATA[<p>Du betreibst einen Eisstand. 10 Tage lang hast du in einem Heft die Temperatur am Mittag und die Zahl der verkauften Kugeln notiert. Aus diesen Notizen möchtest du eine Regel machen: Morgen sollen es 24°C werden, wie viel Eis solltest du vorbereiten?</p>
<p>Die einfachste Regel ist eine gerade Linie: „Jedes Grad mehr bedeutet ein paar Kugeln mehr“. Im Beispiel aus dieser Notiz liegt sie an den notierten Tagen typischerweise um 27,5 Kugeln daneben, weil sie nicht sieht, dass der Verkauf bei der größten Hitze zurückgeht. Man kann der Regel also mehr Freiheit geben und der Kurve erlauben, sich zu biegen. Die flexibelste der ausprobierten Kurven geht genau durch alle 10 Punkte. Ihr Fehler an den Tagen aus dem Heft beträgt 0.</p>
<p>Das sieht nach einer perfekten Regel aus. Nur sind die Tage aus dem Heft schon vorbei, und die Regel soll morgen funktionieren. An 400 neuen Tagen desselben Eisstands liegt die „perfekte“ Kurve typischerweise um 236,5 Kugeln daneben. Eine mäßig flexible Kurve, die im Heft schlechter abschnitt (10,9), liegt an neuen Tagen um 16,8 daneben.</p>
<p><strong>Overfitting</strong> ist die Situation, in der ein Modell einen kleinen Fehler auf den Daten hat, mit denen es gelernt hat, und einen im Vergleich dazu zu großen Fehler auf neuen Daten derselben Art (<a href="https://www.deeplearningbook.org/contents/ml.html" rel="noopener noreferrer">Goodfellow, Bengio und Courville, <em>Deep Learning</em>, §5.2</a>). Das Modell hat sich an Eigenschaften seines Datensatzes angepasst, die sich außerhalb davon nicht wiederholen. Das umgekehrte Problem heißt <strong>underfitting</strong>: Die Regel ist zu einfach, um auch nur die Daten gut zu beschreiben, die sie gesehen hat. So verhält sich die gerade Linie aus unserem Beispiel.</p>
<p><img src="https://paweldubiel.com/assets/overfitting-smooth-rule-versus-tangled-line-through-every-point.webp" alt="Zwei Eisstände nebeneinander: Über dem ersten verläuft eine glatte Linie in sanftem Bogen zwischen den Punkten, über dem zweiten trifft eine verknotete Linie jeden Punkt und schießt weit über den Bildrand hinaus." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="woher-dieser-unterschied-kommt">Woher dieser Unterschied kommt</h2>
<p>Jeder Eintrag im Heft besteht aus zwei Dingen: aus einer Regelmäßigkeit (wärmer, also mehr Eis) und aus Zufall (gerade ist eine Reisegruppe angekommen). Die Regel soll das Erste erfassen und das Zweite weglassen. Das Modell weiß aber nicht, was was ist. Es sieht nur Punkte.</p>
<p>Wie viel Zufall das Modell aufnimmt, entscheidet seine Flexibilität, in der Fachliteratur <strong>capacity</strong> genannt: die Fähigkeit, sich an viele verschiedene Formen anzupassen. Die Kurve im Beispiel wird durch 2 bis 10 Zahlen beschrieben, die an die Daten angepasst werden; ihre Anzahl ist der Grad der Kurve plus eins. Eine Kurve vom Grad 9 hat 10 solche Zahlen für 10 Tage, sie kann also jeden Punkt treffen, mitsamt dem ganzen Zufall. Die Autoren des Lehrbuchs beschreiben es so: Ein sehr flexibles Modell kann den richtigen Zusammenhang darstellen, aber auch eine Menge anderer, die genauso gut zu den Trainingsdaten passen, und die Chance ist klein, dass es gerade den auswählt, der sich später bewährt (§5.2).</p>
<p>Der typische Verlauf ist folgender: Wenn die Flexibilität wächst, sinkt der Fehler auf den Trainingsdaten, und der Fehler auf neuen Daten sinkt zuerst und beginnt dann zu steigen (§5.2, Abbildung 5.3). Daraus folgt eine praktische Regel. Ein Modell bewertet man nicht auf den Daten, mit denen es gelernt hat, und die Flexibilität wählt man nicht nach dem Fehler auf diesen Daten, denn der zeigt immer auf die größte. Einen Teil der Daten legt man beiseite: Das <strong><a href="https://paweldubiel.com/de/glossary/validation-set">validation set</a></strong> dient zur Wahl der Einstellungen und ein eigenes <strong>test set</strong> zur abschließenden Bewertung (§5.3).</p>
<h2 id="probier-es-selbst-aus">Probier es selbst aus</h2>
<p>Unten ist derselbe Eisstand. Alle Zahlen aus dieser Notiz lassen sich nachstellen: Nach einem Klick auf „Von vorn“ siehst du 10 Tage, und die Experimente 1–5 stellen die beschriebenen Fälle ein.</p>
<div id="overfitting-lab"></div>
<p>Es lohnt sich, zwei Dinge zu tun, die ein statisches Diagramm nicht zeigt. Erstens: Schalte „24 andere Hefte“ ein und ändere den Grad: Bei einem niedrigen bleiben die grauen Linien nah beieinander, bei einem hohen laufen sie in alle Richtungen auseinander, obwohl jede vom selben Eisstand stammt. Zweitens: Zieh einen Punkt weit nach oben. Die Kurve vom Grad 2 verschiebt sich nur ein wenig, die Kurve vom Grad 9 baut sich dagegen auf ganzer Länge um, um ihn zu treffen.</p>
<h2 id="was-hilft">Was hilft</h2>
<ul>
<li><strong>Mehr Daten.</strong> Bei 80 Tagen liegt dieselbe Kurve vom Grad 9 typischerweise um 14,8 Kugeln im Heft und um 15,9 an neuen Tagen daneben. Der Unterschied verschwindet fast, weil die Kurve nicht mehr jeden Punkt treffen kann (§5.2).</li>
<li><strong>Weniger Flexibilität.</strong> Kurve vom Grad 3 bei 10 Tagen: 10,9 im Heft, 16,8 an neuen Tagen.</li>
<li><strong>Regularization</strong>, also eine Änderung der Lernweise, die den Fehler auf neuen Daten verringern soll und nicht den auf den Trainingsdaten (§5.2.2). Ein Beispiel ist eine Strafe für große Koeffizienten, verwandt mit <a href="https://paweldubiel.com/de/glossary/weight-decay">Weight decay</a>: Die Kurve vom Grad 9 mit der Strafe λ = 0,01 liegt um 5,8 im Heft und um 21,2 an neuen Tagen daneben, statt um 236,5.</li>
</ul>
<p>Keine dieser Einstellungen lässt sich wählen, wenn man nur auf den Fehler auf den Trainingsdaten schaut.</p>
<h2 id="einschränkungen">Einschränkungen</h2>
<ul>
<li>Das ist ein eigenes Beispiel mit einer einzigen Eingangsgröße und simulierten Daten. Der Zufall allein ergibt hier typischerweise 15 Kugeln Fehler, und keine Regel kommt an neuen Tagen darunter.</li>
<li>Die Form „erst besser, dann schlechter“ ist typisch, aber nicht garantiert. Die Autoren merken an, dass es bei tiefen Netzen schwer ist, die tatsächliche Flexibilität eines Modells überhaupt zu bestimmen, weil sie auch vom Lernalgorithmus abhängt (§5.2). Die Zahl der Parameter eines LLM sagt also für sich allein nicht, ob das Modell überangepasst ist.</li>
<li>Ein kleiner Fehler auf neuen Daten gilt für Daten aus derselben Quelle. Wenn der Eisstand ans Meer umzieht, verspricht das Heft aus der Stadt nichts.</li>
</ul>
<h2 id="verbindungen">Verbindungen</h2>
<ul>
<li><a href="https://paweldubiel.com/de/glossary/weight-decay">Weight decay</a> begrenzt die Größe der Gewichte und ist eine der Möglichkeiten, den Unterschied zwischen dem Fehler auf Trainingsdaten und auf neuen Daten zu verringern.</li>
<li><a href="https://paweldubiel.com/de/glossary/grokking">Grokking</a> beschreibt Fälle, in denen ein Modell, das überangepasst wirkt, nach langem weiterem Training anfängt, auf neuen Daten gut zu funktionieren.</li>
<li><a href="https://paweldubiel.com/de/glossary/fine-tuning">Fine-tuning</a> auf einem kleinen Datensatz verlangt dieselbe Kontrolle: eigene Daten, die das Modell beim Lernen nicht gesehen hat.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> ist ein anderes Problem: Dort verliert das Modell eine alte Fähigkeit nach neuem Lernen, hier überträgt es sich von Anfang an schlecht über die eigenen Trainingsdaten hinaus.</li>
</ul>]]></content:encoded>
</item>
<item>
  <title>Time horizon</title>
  <link>https://paweldubiel.com/de/glossary/time-horizon</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/time-horizon</guid>
  <pubDate>Sun, 11 Oct 2026 15:02:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Der Time horizon (Zeithorizont) beschreibt in der Evaluation von Agenten die Länge der Aufgaben, bei der ein Agent eine gewählte Erfolgsquote erreicht.</description>
  <content:encoded><![CDATA[<p>Der <strong>Time horizon</strong> (Zeithorizont) beschreibt in der Evaluation von Agenten die Länge der Aufgaben, bei der ein Agent eine gewählte Erfolgsquote erreicht. Die Länge wird an der Zeit gemessen, die ein Mensch benötigt, nicht an der Laufzeit der KI.</p>
<p>Für die 50-%-Variante sammeln wir gelungene und misslungene Versuche des Agenten bei Aufgaben mit unterschiedlichen menschlichen Bearbeitungszeiten. Wir passen eine Kurve der Erfolgschance an und lesen dann die Zeit ab, bei der sie 50 % schneidet. Das ist eine Vorhersage für die Verteilung der Aufgaben mit einer bestimmten Dauer; es bedeutet nicht, dass jede von ihnen dieselbe Chance hat, gelöst zu werden. <a href="https://metr.org/time-horizons/" rel="noopener noreferrer">METR: Definition und Methodik</a>.</p>
<p>Ein Lehrbeispiel: Erreicht die angepasste Kurve 50 % bei zwei Stunden, dann beträgt der Horizont zwei Stunden. Der Agent kann eine gelungene Aufgabe deutlich schneller erledigen. Das Ergebnis allein sagt auch nicht, mit welcher Erfolgsquote er eine Aufgabe aus einem anderen Gebiet löst.</p>
<p>Das Ablesen setzt einen sinnvollen Zusammenhang zwischen der menschlichen Bearbeitungszeit und der Schwierigkeit für die KI voraus. Ist die Kurve flach, kann eine kleine Änderung der Chance ihren Schnittpunkt mit der Schwelle weit verschieben. <a href="https://paweldubiel.com/de/articles/ein-laengerer-metr-horizont-bedeutet-nicht-proportional-schwierigere-aufgaben">Der Artikel über die Umrechnung des METR-Horizonts</a> zeigt dieses Problem an einem nachrechenbaren Beispiel und bespricht eine neue Anpassung an die METR-Daten. <a href="https://arxiv.org/html/2610.12466v1#S2" rel="noopener noreferrer">Nguyen und Fithian, §2–3</a>.</p>
<p>Beim Vergleich von Horizonten müssen die Angaben zum Aufgabensatz, zur Umgebung des Agenten, zum Budget an Versuchen und zur gewählten Erfolgsschwelle erhalten bleiben.</p>]]></content:encoded>
</item>
<item>
  <title>Item response theory</title>
  <link>https://paweldubiel.com/de/glossary/item-response-theory</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/item-response-theory</guid>
  <pubDate>Sun, 11 Oct 2026 15:01:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <category>benchmarks</category>
  <description>Item response theory (IRT), auf Deutsch Item-Response-Theorie, ist eine Familie von Methoden, die aus den Antworten auf einzelne Aufgaben gemeinsam die Fähigkeiten der Bearbeiter und die…</description>
  <content:encoded><![CDATA[<p><strong>Item response theory (IRT)</strong>, auf Deutsch Item-Response-Theorie, ist eine Familie von Methoden, die aus den Antworten auf einzelne Aufgaben gemeinsam die Fähigkeiten der Bearbeiter und die Schwierigkeit der Aufgaben schätzen. In der KI-Evaluation ist der Bearbeiter ein Agent, und die Antwort kann der Erfolg oder Misserfolg eines vollständigen Versuchs sein.</p>
<p>Angenommen, zwei Agenten lösen dieselben drei Aufgaben. Der erste kommt meist mit A und B zurecht, der zweite auch mit C. Die Erfolgsquote allein ergibt eine Rangfolge. IRT versucht zusätzlich zu schätzen, wie schwer C im Vergleich zu den übrigen Aufgaben ist und welcher Fähigkeitsunterschied das Antwortmuster erklärt. Das ist ein Lehrbeispiel; eine so kleine Tabelle reicht für eine verlässliche Anpassung nicht aus.</p>
<p>Im einfachen Rasch-Modell steigt die Erfolgschance, wenn die Fähigkeiten des Agenten im Verhältnis zur Schwierigkeit der Aufgabe größer sind. Beide Größen sind latent: Wir schließen aus den Ergebnissen auf sie, statt die Schwierigkeit von vornherein mit der Länge der Anweisung oder der menschlichen Bearbeitungszeit gleichzusetzen. Verschiedene IRT-Varianten fügen weitere Parameter und Annahmen hinzu.</p>
<p>In <a href="https://paweldubiel.com/de/articles/ein-laengerer-metr-horizont-bedeutet-nicht-proportional-schwierigere-aufgaben">der Analyse der METR-Horizonte</a> verknüpfen die Autoren die latente Schwierigkeit über eine gelernte Kurve mit der menschlichen Arbeitszeit. Sie ergänzen Effekte von Aufgabenfamilien und die Streuung der Ergebnisse zwischen Wiederholungen. So lässt sich prüfen, in welchem Bereich die Zeit tatsächlich zwischen Aufgaben unterscheidet, die für die KI schwer oder leicht sind. <a href="https://arxiv.org/html/2610.12466v1#S2.SS3" rel="noopener noreferrer">Nguyen und Fithian, §2.3 und §3.1</a>.</p>
<p>Eine gute Vorhersage der Antworten beweist nicht, dass der gelernte Parameter alle Arten von Fähigkeiten eines Agenten erfasst. Bei der Interpretation müssen die Modellannahmen und die Ergebnisse bei Aufgaben geprüft werden, die bei der Anpassung nicht verwendet wurden.</p>]]></content:encoded>
</item>
<item>
  <title>Elastic Weight Consolidation</title>
  <link>https://paweldubiel.com/de/glossary/elastic-weight-consolidation</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/elastic-weight-consolidation</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein Modell leitet Kundenfragen an die Abteilungen „Lieferung“ und „Rücksendungen“ weiter. Jetzt soll es lernen, Reklamationen zu erkennen, aber die alten Nachrichten dürfen nicht mehr gespeichert…</description>
  <content:encoded><![CDATA[<p>Ein Modell leitet Kundenfragen an die Abteilungen „Lieferung“ und „Rücksendungen“ weiter. Jetzt soll es lernen, Reklamationen zu erkennen, aber die alten Nachrichten dürfen nicht mehr gespeichert werden. Man kann sie beim Lernen also nicht wiederholen. Von der alten Aufgabe ist nur das Modell selbst geblieben: Millionen von Zahlen, die beim früheren Training eingestellt wurden und Gewichte heißen.</p>
<p>Man kann das Modell ohne jede Einschränkung auf Reklamationen trainieren. Dann verschieben sich die Gewichte dorthin, wo es der neuen Aufgabe hilft, auch jene, von denen das Erkennen von Lieferung und Rücksendungen abhing. Man kann auch jede Änderung gleich stark bestrafen, aber dann hält das Modell so fest an den alten Einstellungen, dass es das Neue nur schlecht lernt. Nötig ist eine Antwort auf die Frage: <strong>Welche Gewichte darf man bewegen und welche besser nicht?</strong></p>
<p><strong>Elastic Weight Consolidation (EWC)</strong> fügt dem Lernen der neuen Aufgabe eine Strafe dafür hinzu, dass sich die Gewichte von ihren Werten nach der alten Aufgabe entfernen; die Strafe ist umso größer, je wichtiger das jeweilige Gewicht für die alte Aufgabe war. Die Autoren vergleichen das mit einer Feder, die an jedem Gewicht befestigt ist: steif bei wichtigen Gewichten, locker bei den übrigen (<a href="https://arxiv.org/abs/1612.00796" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §2</a>).</p>
<p><img src="https://paweldubiel.com/assets/elastic-weight-consolidation-stiff-and-loose-springs.webp" alt="Eine Reihe von Scheiben, die mit Federn an Pfosten befestigt sind: Scheiben an dicken, steifen Federn bleiben an ihrem Platz, die an dünnen, lockeren verschieben sich in Richtung eines roten Kreises." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="zwei-gewichte-eine-neue-aufgabe">Zwei Gewichte, eine neue Aufgabe</h2>
<p>Nehmen wir nur zwei Gewichte. Nach dem Lernen von Lieferung und Rücksendungen haben beide den Wert 1. Das erste ist für die alten Abteilungen sehr wichtig (Wichtigkeit 10), das zweite nahezu gleichgültig (Wichtigkeit 0,1). Die neue Aufgabe verlangt lediglich, dass <strong>die Summe beider Gewichte 4 beträgt</strong>. Das erfüllen viele Einstellungen: (2, 2), aber auch (1, 3).</p>
<ul>
<li><strong>Ohne Schutz</strong> verschiebt das Lernen beide Gewichte gleich weit, auf (2, 2). Die neue Aufgabe ist gelernt, aber das wichtige Gewicht ist um 1 abgewandert, und der Verlust bei der alten Aufgabe steigt von 0 auf 5,05.</li>
<li><strong>Eine gleiche Strafe</strong> für beide Gewichte hält sie auf halbem Weg an, bei (1,67, 1,67). Die alte Aufgabe leidet weniger, aber die Summe beträgt 3,33 statt 4.</li>
<li><strong>EWC</strong> verlagert fast die gesamte Bewegung auf das wenig wichtige Gewicht: (1,02, 2,80). Die Summe beträgt 3,82, und der Verlust bei der alten Aufgabe liegt bei nur 0,16.</li>
</ul>
<p>Der Verlust ist eine Zahl, die angibt, wie stark sich das Modell irrt; je kleiner, desto besser. Im Experiment unten kannst du die Stärke der Strafe λ und die Art des Schutzes ändern. Das Ergebnis wird für genau dieses Beispiel mit zwei Gewichten exakt berechnet; es ist keine Simulation eines echten Netzes.</p>
<div id="ewc-spring-lab"></div>
<h2 id="woher-man-weiß-welches-gewicht-wichtig-ist">Woher man weiß, welches Gewicht wichtig ist</h2>
<p>In einem echten Netz gibt niemand die Wichtigkeit vor. Man schätzt sie nach Abschluss der alten Aufgabe, solange deren Daten noch verfügbar sind: Man prüft, wie stark eine kleine Änderung eines Gewichts die Antworten des Modells auf die alten Beispiele verändert. Die Arbeit verwendet dafür die Diagonale der <em>Fisher-Informationsmatrix</em>, also eine Wichtigkeitszahl pro Gewicht. Danach können die Daten gelöscht werden; es bleiben die alten Werte der Gewichte und ihre Wichtigkeiten.</p>
<p>Beim neuen Lernen wird die Summe zweier Bestandteile minimiert (Gleichung 3 der Arbeit):</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>L</mi><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>=</mo><msub><mi>L</mi><mi>B</mi></msub><mo stretchy="false">(</mo><mi>θ</mi><mo stretchy="false">)</mo><mo>+</mo><munder><mo>∑</mo><mi>i</mi></munder><mfrac><mi>λ</mi><mn>2</mn></mfrac><msub><mi>F</mi><mi>i</mi></msub><mtext> </mtext><mo stretchy="false">(</mo><msub><mi>θ</mi><mi>i</mi></msub><mo>−</mo><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup><msup><mo stretchy="false">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">L(\theta) = L_B(\theta) + \sum_i \frac{\lambda}{2} F_i \,(\theta_i - \theta^*_{A,i})^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">L</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:2.6491em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.3714em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord">2</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">λ</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.686em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1.2472em;vertical-align:-0.3831em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.7387em;"><span style="top:-2.453em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3831em;"><span></span></span></span></span></span></span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8641em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>L</mi><mi>B</mi></msub></mrow><annotation encoding="application/x-tex">L_B</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal">L</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em;">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> ist der Verlust bei der neuen Aufgabe, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">\theta_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> der aktuelle Wert des Gewichts Nummer <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msubsup><mi>θ</mi><mrow><mi>A</mi><mo separator="true">,</mo><mi>i</mi></mrow><mo>∗</mo></msubsup></mrow><annotation encoding="application/x-tex">\theta^*_{A,i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1059em;vertical-align:-0.4114em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.6887em;"><span style="top:-2.4247em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">A</span><span class="mpunct mtight">,</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∗</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4114em;"><span></span></span></span></span></span></span></span></span></span> sein Wert nach der alten Aufgabe, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>F</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">F_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8333em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.1389em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> seine Wichtigkeit, und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi></mrow><annotation encoding="application/x-tex">\lambda</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span></span></span></span> gibt an, wie stark die alte Aufgabe gegenüber der neuen zählt. In unserem Beispiel gilt <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mo stretchy="false">(</mo><mn>10</mn><mo separator="true">;</mo><mtext> </mtext><mn>0,1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F = (10;\ 0{,}1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.1389em;">F</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">10</span><span class="mpunct">;</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>λ</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">\lambda = 1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">λ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span>.</p>
<h2 id="grenzen-der-methode">Grenzen der Methode</h2>
<p>Die Wichtigkeit ist eine Näherung, die an einem einzigen Punkt und für jedes Gewicht getrennt berechnet wird. Die Autoren selbst zeigen, dass ihre Schätzung mitunter zu sicher darin ist, welche Gewichte unwichtig sind, und nennen das die Hauptschwäche der Methode (§2.2 und §3). In ihren Experimenten mit Atari-Spielen lernte ein Agent mit EWC viele Spiele nacheinander, reichte aber nicht an getrennte Netze heran, die für jedes Spiel einzeln trainiert wurden. Die Ergebnisse betreffen die Erkennung von Ziffern und Spiele, nicht große Sprachmodelle. Unsere zwei Gewichte und die Kundennachrichten sind eine eigene Vereinfachung.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> ist eine erhebliche Verschlechterung früherer Fähigkeiten nach neuem Lernen; EWC versucht, sie ohne Zugriff auf die alten Daten zu verringern.</li>
<li><a href="https://paweldubiel.com/de/glossary/experience-replay">Experience Replay</a> löst dasselbe Problem anders: Es speichert einen Teil der früheren Beispiele statt der Wichtigkeiten der Gewichte.</li>
<li><a href="https://paweldubiel.com/de/glossary/continual-learning">Continual Learning</a> bezeichnet das Ziel, also das Lernen weiterer Aufgaben unter Erhalt der früheren; EWC ist eine der Methoden.</li>
<li><a href="https://paweldubiel.com/de/glossary/fine-tuning">Fine-tuning</a> ist das weitere Training eines fertigen Modells; EWC verändert dessen Ziel, indem es eine Strafe für das Bewegen wichtiger Gewichte hinzufügt.</li>
</ul>
<p><em>Text und Illustration wurden mit KI-Unterstützung erstellt. Die zwei Gewichte, ihre Wichtigkeiten und die Demonstration sind ein eigenes vereinfachtes Lernbeispiel; die Illustration ist eine Metapher, kein Schema der Modellarchitektur.</em></p>]]></content:encoded>
</item>
<item>
  <title>Reservoir Sampling</title>
  <link>https://paweldubiel.com/de/glossary/reservoir-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/reservoir-sampling</guid>
  <pubDate>Sun, 11 Oct 2026 12:00:11 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein Kundenservice-Modell lernt anhand von Nachrichten, die eine nach der anderen eintreffen. Du möchtest einige davon für spätere Wiederholungen aufbewahren, hast aber nur vier Speicherplätze.</description>
  <content:encoded><![CDATA[<p>Ein Kundenservice-Modell lernt anhand von Nachrichten, die eine nach der anderen eintreffen. Du möchtest einige davon für spätere Wiederholungen aufbewahren, hast aber nur vier Speicherplätze. Du weißt auch nicht, wie viele Nachrichten noch kommen: zwanzig oder zwei Millionen.</p>
<p>Die ersten vier behalten? Dann kennt der Speicher nur den Anfang. Immer die letzten vier behalten? Dann kennt er nur das Ende. Eine faire Auslosung „vier aus allen“ würde verlangen, alles zu speichern oder die Zahl der Nachrichten im Voraus zu kennen. Die Frage lautet: <strong>Wie gibt man bei fester Zahl von Plätzen und unbekannter Länge des Stroms jeder Nachricht dieselbe Chance?</strong></p>
<p><strong>Reservoir Sampling</strong> ist ein Verfahren, mit dem man während eines einzigen Durchgangs durch Daten, deren Anzahl wir nicht im Voraus kennen, eine Zufallsstichprobe fester Größe führt. Nach jeder weiteren Nachricht enthält der Speicher, hier Reservoir genannt, eine faire Zufallsstichprobe von allem, was bis dahin eingetroffen ist. Die einfachste Version, Algorithm R, beschreibt <a href="https://doi.org/10.1145/3147.3165" rel="noopener noreferrer">Vitter, <em>Random Sampling with a Reservoir</em>, §2</a> und schreibt sie Alan Waterman zu.</p>
<p><img src="https://paweldubiel.com/assets/reservoir-sampling-pebble-stream-four-slot-tray.webp" alt="Ein langer Strom aus Kieseln und Muscheln fließt an einem kleinen Holztablett mit vier Mulden vorbei; eine Hand nimmt einen Kiesel vom Tablett, die andere legt an seine Stelle einen Kiesel aus dem Strom." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="das-rezept-in-zwei-schritten">Das Rezept in zwei Schritten</h2>
<ol>
<li>Die ersten vier Nachrichten kommen ohne Auslosung in den Speicher.</li>
<li>Die Nachricht Nummer <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> (die fünfte, die sechste und jede weitere) gelangt mit der Chance <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span> in den Speicher. Gelangt sie hinein, ersetzt sie eine der vier gespeicherten, die zufällig ausgewählt wird.</li>
</ol>
<p>Die fünfte Nachricht kommt also mit der Chance 4/5 hinein, die hundertste mit der Chance 4/100. Neue Nachrichten haben eine immer kleinere Chance hineinzukommen, aber die alten waren schon viele Male der Gefahr ausgesetzt, hinausgeworfen zu werden, und diese beiden Effekte gleichen sich genau aus. Prüfen wir das nach der fünften Nachricht. Sie kommt mit der Chance 4/5 hinein. Die erste Nachricht fällt nur dann heraus, wenn die fünfte hineingekommen ist (4/5) und ausgerechnet ihren Platz getroffen hat (1/4), also mit der Chance 1/5. Sie bleibt mit der Chance 4/5: derselben, die auch die fünfte hat. Nach <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em;"></span><span class="mord mathnormal">t</span></span></span></span> Nachrichten ist jede von ihnen mit der Chance <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mi>t</mi></mrow><annotation encoding="application/x-tex">4/t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/</span><span class="mord mathnormal">t</span></span></span></span> im Speicher.</p>
<h2 id="gleiche-chance-ist-keine-garantie">Gleiche Chance ist keine Garantie</h2>
<p>Im Experiment hat der Strom 20 Nachrichten. Achtzehn betreffen die Lieferung, und zwei, die neunte und die fünfzehnte, betreffen Rücksendungen. Jeder Start lässt einen solchen Strom 2000-mal durchlaufen und zählt, wie oft eine Position am Ende im Speicher geblieben ist. Die Auslosungen sind echt, daher weichen die Ergebnisse jedes Mal um den Bruchteil eines Prozents voneinander ab.</p>
<div id="reservoir-sampling-lab"></div>
<p>Bei Reservoir Sampling liegt jeder Balken bei etwa 20%, also 4/20. Zugleich bleibt in den meisten Durchläufen keine der beiden Rücksendungen im Speicher. Der genaue Wert ist 3060/4845, also etwa 63%: So viele von allen Vierergruppen, die sich aus 20 Nachrichten auswählen lassen, bestehen ausschließlich aus den achtzehn Nachrichten zur Lieferung. Das Verfahren ist fair gegenüber einzelnen Nachrichten, achtet aber nicht darauf, dass jede Kategorie einen Vertreter hat.</p>
<h2 id="wo-das-eine-rolle-spielt">Wo das eine Rolle spielt</h2>
<p>Beim Lernen mit Wiederholungen dient Reservoir Sampling mitunter als Verfahren zum Schreiben in den Puffer: Man muss weder die Länge des Stroms noch die Grenzen zwischen den Aufgaben kennen. <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, Algorithmus 2</a> verwenden es genau so. In ihren Experimenten mit Bildaufgaben bewährte es sich gut, außer bei sehr kleinen Speichern, bei denen frühere Klassen aus dem Puffer verschwanden; besser schnitten dann Strategien ab, die auf eine gleichmäßige Vertretung der Klassen achten (§4.4). Das ist ein Ergebnis für die Bildklassifikation, nicht für LLMs.</p>
<p>Der Algorithmus selbst betrifft nicht das maschinelle Lernen. Vitters Arbeit von 1985 beschreibt das zufällige Auswählen von Datensätzen von einem Magnetband unbekannter Länge und schlägt schnellere Varianten vor, die nicht bei jedem Datensatz losen, sondern berechnen, wie viele Datensätze zu überspringen sind. Die Kundennachrichten und der Strom mit 20 Positionen sind ein eigenes Beispiel.</p>
<ul>
<li><a href="https://paweldubiel.com/de/glossary/experience-replay">Experience Replay</a> braucht einen Puffer mit früheren Beispielen; Reservoir Sampling ist eine der Möglichkeiten zu entscheiden, was hineinkommt.</li>
<li><a href="https://paweldubiel.com/de/glossary/continual-learning">Continual Learning</a> geht vom Lernen aus einem Datenstrom bei begrenztem Speicher aus, also von einer Situation, in der sich nicht alles aufbewahren lässt.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> kann sich verstärken, wenn aus einem kleinen Speicher alle Beispiele einer früheren Kategorie herausfallen.</li>
</ul>
<p><em>Text und Illustration wurden mit KI-Unterstützung erstellt. Der Nachrichtenstrom und die Demonstration sind ein eigenes vereinfachtes Lernbeispiel; die Illustration ist eine Metapher, kein Schema des Algorithmus.</em></p>]]></content:encoded>
</item>
<item>
  <title>Experience Replay</title>
  <link>https://paweldubiel.com/de/glossary/experience-replay</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/experience-replay</guid>
  <pubDate>Sun, 11 Oct 2026 08:22:26 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein Modell hat gelernt, Kundenfragen an „Lieferung“ und „Rücksendungen“ weiterzuleiten. Jetzt trainierst du es weiter, damit es Reklamationen erkennt, etwa „Das Produkt kam beschädigt an“.</description>
  <content:encoded><![CDATA[<p>Ein Modell hat gelernt, Kundenfragen an „Lieferung“ und „Rücksendungen“ weiterzuleiten. Jetzt trainierst du es weiter, damit es Reklamationen erkennt, etwa „Das Produkt kam beschädigt an“. Enthalten die nächsten Übungen nur Reklamationen, kann es bei der vertrauten Frage „Wo ist mein Paket?“ schlechter werden. Das vollständige alte Archiv ist nicht verfügbar. Könnte es zumindest einige gespeicherte Nachrichten erneut durchgehen?</p>
<p><strong>Experience Replay (ER)</strong> bedeutet, einen Teil früherer Beispiele zu speichern und erneut zum Lernen zu verwenden. In einer einfachen Variante mischen wir Beispiele aus dem Speicher in eine Portion neuer Daten. Dieser Speicher heißt <em>replay buffer</em>: ein Behälter für Übungsdaten, kein Verzeichnis des gesamten Modellwissens. Dieses gemeinsame Training beschreiben <a href="https://arxiv.org/html/1902.10486v2#S2" rel="noopener noreferrer">Chaudhry et al., <em>Continual Learning with Tiny Episodic Memories</em>, §2, Algorithmus 1</a>.</p>
<p><img src="https://paweldubiel.com/assets/experience-replay-card-box-returning-examples.webp" alt="Gespeicherte indigoblaue und ockerfarbene Karten kehren aus einer kleinen Box in eine Reihe neuer roter Karten zurück: eine Metapher für Wiederholungen beim weiteren Lernen." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="was-in-die-nächste-übung-kommt">Was in die nächste Übung kommt</h2>
<p>Bevor das Archiv verloren ging, speicherten wir vier Nachrichten zusammen mit den richtigen Abteilungen. Jetzt haben wir vier neue Reklamationen. Ohne Wiederholungen lernt das Modell anhand von vier neuen Nachrichten. Mit Wiederholungen übt es zusätzlich mit vier alten: Es erhält erneut das Signal, dass „Wo ist mein Paket?“ zur Lieferung gehört. In diesem kleinen Beispiel verwenden wir den gesamten Puffer; größere Puffer liefern gewöhnlich eine zufällig ausgewählte Portion.</p>
<p>Es reicht jedoch nicht, Speicherplätze zu zählen. Vier gespeicherte Lieferfragen enthalten kein einziges Beispiel für Rücksendungen. Ersetzen wir zwei davon durch „Wie schicke ich meinen Einkauf zurück?“ und „Ich möchte ein T-Shirt zurückgeben“, bleibt die Zahl der wiederholten Beispiele gleich, umfasst aber beide früheren Abteilungen. Das folgende Experiment <strong>zählt Beispiele in einer Datenportion; es sagt die Treffergenauigkeit des Modells nicht voraus</strong>.</p>
<div id="experience-replay-lab"></div>
<h2 id="wiederholungen-helfen-nur-mit-verfügbaren-daten">Wiederholungen helfen nur mit verfügbaren Daten</h2>
<p>Das Modell erhält Gelegenheit, frühere Antworten zu üben, aber keine Garantie, sämtliche Fähigkeiten zu behalten. Eine kleine Zufallsstichprobe kann eine seltene Kategorie vollständig auslassen; dieses Problem beobachteten die Forschenden bei sehr kleinen Puffern (§4.4 derselben Arbeit). Unsere Nachrichten sind ein eigenes Beispiel, kein Ergebnis dieser Experimente. Die Wirkung des Trainings muss anhand getrennter alter und neuer Nachrichten geprüft werden, die nicht zum Training verwendet wurden. Der Puffer belegt zudem Speicher und erfordert, ausgewählte Daten aufzubewahren.</p>
<p>Siehe auch: <a href="https://paweldubiel.com/de/glossary/reservoir-sampling">Reservoir Sampling</a> — ein Verfahren, das entscheidet, welche Beispiele aus dem Datenstrom in einen Puffer fester Größe gelangen, und jedem die gleiche Chance gibt.</p>
<p>In Spielen, beim <a href="https://paweldubiel.com/de/glossary/reinforcement-learning">Reinforcement Learning</a> — dem Erlernen von Handlungen anhand von Belohnungen — speichert man eine Situation, eine Handlung, eine Belohnung und die nächste Situation. Die zufällige Auswahl solcher Einträge verringert die Abhängigkeit von unmittelbar aufeinanderfolgenden Ereignissen (<a href="https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf#page=7" rel="noopener noreferrer">Mnih et al., <em>Human-level control through deep reinforcement learning</em>, Methods, „Training algorithm for deep Q-networks“</a>). Das sind andere Daten als eine Nachricht mit ihrer richtigen Abteilung; Atari-Ergebnisse sollten nicht unmittelbar auf LLMs übertragen werden.</p>
<ul>
<li><a href="https://paweldubiel.com/de/glossary/continual-learning">Continual Learning</a> bezeichnet das Ziel, weiterzulernen und frühere Fähigkeiten zu behalten; ER ist ein Weg dorthin.</li>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> beschreibt eine erhebliche Verschlechterung früherer Fähigkeiten, die Wiederholungen verringern können.</li>
<li><a href="https://paweldubiel.com/de/glossary/fine-tuning">Fine-tuning</a> ist das weitere Training eines Modells; replay verändert die Auswahl seiner Trainingsdaten. Alte Nachrichten lediglich in ein Gespräch einzufügen, ist keine solche Modellaktualisierung.</li>
</ul>
<p><em>Text und Illustration wurden mit KI-Unterstützung erstellt. Nachrichten und Demonstration sind ein eigenes vereinfachtes Lernbeispiel; die Illustration ist eine Metapher, kein Schema der Modellarchitektur.</em></p>]]></content:encoded>
</item>
<item>
  <title>Continual Learning</title>
  <link>https://paweldubiel.com/de/glossary/continual-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/continual-learning</guid>
  <pubDate>Sat, 10 Oct 2026 20:03:52 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein Modell leitet Kundennachrichten an die Abteilungen „Bestellungen“ und „Rücksendungen“ weiter. Es erkennt „Wo ist mein Paket?“. Jetzt eröffnet das Unternehmen eine Reklamationsabteilung.</description>
  <content:encoded><![CDATA[<p>Ein Modell leitet Kundennachrichten an die Abteilungen „Bestellungen“ und „Rücksendungen“ weiter. Es erkennt „Wo ist mein Paket?“. Jetzt eröffnet das Unternehmen eine Reklamationsabteilung. Du trainierst das Modell mit Nachrichten über beschädigte Produkte weiter. Es ordnet Reklamationen immer besser zu, aber auch einige Fragen zur Lieferung landen nun in der neuen Abteilung. Nur die Reklamationen zu prüfen würde einen falschen Eindruck von Fortschritt vermitteln.</p>
<p>Du musst dem Modell <strong>Neues beibringen und dabei frühere Fähigkeiten erhalten</strong>. Das ist das Ziel von <strong>Continual Learning</strong>: aus nacheinander eintreffenden Daten oder Aufgaben zu lernen und dabei zu berücksichtigen, was das Modell bereits gelernt hat. Der Name bezeichnet ein Problem und eine Familie von Ansätzen; er garantiert nicht, dass das Vergessen ausbleibt. <a href="https://arxiv.org/html/1612.00796v2#S1" rel="noopener noreferrer">Kirkpatrick et al., <em>Overcoming catastrophic forgetting in neural networks</em>, §1</a> beschreiben diesen Bedarf.</p>
<p><img src="https://paweldubiel.com/assets/continual-learning-embroidered-sampler-growing-repertoire.webp" alt="Auf einem einzigen Stück Stoff bleiben gestickte Kreise und Dreiecke erhalten, während eine Nadel ein neues Wellenmuster hinzufügt: eine Metapher für den Ausbau von Fähigkeiten unter Erhalt der bisherigen." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="was-sich-beim-training-und-bei-der-bewertung-ändert">Was sich beim Training und bei der Bewertung ändert</h2>
<p>Nehmen wir an, das vollständige Archiv der Beispiele aus dem früheren Training ist nicht mehr verfügbar. Vor dem Löschen haben wir eine kleine Stichprobe aufbewahrt: 20 Nachrichten, deren richtige Abteilungen bekannt sind. Eine mögliche Methode mischt diese Stichprobe unter die neuen Reklamationsbeispiele. So erhält das weitere Training auch ein Signal, „Wo ist mein Paket?“ weiterhin richtig zu bearbeiten. Die erneute Verwendung früherer Beispiele ist eine der Strategien bei <a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven und Tolias, <em>Three scenarios for continual learning</em>, §3.3</a>.</p>
<p>Siehe auch: <a href="https://paweldubiel.com/de/glossary/experience-replay">Experience Replay</a> — eine kleine Stichprobe früherer Beispiele aufbewahren und sie dem neuen Training beimischen.</p>
<p>Das Bewertungsteam bewahrt einen gesonderten Test mit alten Nachrichten auf, den <strong>wir nicht zum Training verwenden</strong>. Nach jeder Aktualisierung prüfen wir alte und neue Kategorien. Die folgenden Zahlen sind ein erfundenes Beispiel, keine Forschungsergebnisse; jeder Test enthält 100 Nachrichten.</p>

























<table><thead><tr><th>Variante</th><th>Alte Fälle: richtig</th><th>Neue Fälle: richtig</th></tr></thead><tbody><tr><td>Vor dem neuen Training</td><td>90/100</td><td>0/100 — diese Kategorie gibt es noch nicht</td></tr><tr><td>Nach dem Training nur mit Reklamationen</td><td>40/100</td><td>92/100</td></tr><tr><td>Nach dem Training mit einer Stichprobe früherer Nachrichten</td><td>89/100</td><td>87/100</td></tr></tbody></table>
<p>Die letzte Variante erhält die frühere Fähigkeit besser, erkennt Reklamationen aber schlechter als die zweite. Die Tabelle zeigt, <strong>was zu vergleichen ist</strong>; sie verspricht dieses Ergebnis nicht allein durch das Hinzufügen von 20 Beispielen.</p>
<h2 id="die-bedingungen-verändern-die-schwierigkeit">Die Bedingungen verändern die Schwierigkeit</h2>
<p>In unserem Beispiel wählt das Modell selbst zwischen allen bisher gelernten Abteilungen. Ein Hinweis wie „diese Nachricht gehört zur neuen Kategorie“ würde den Test erleichtern. Ob solche Hinweise und Grenzen zwischen Aufgaben verfügbar sind, ist beim Methodenvergleich wichtig (<a href="https://arxiv.org/pdf/1904.07734v1" rel="noopener noreferrer">van de Ven und Tolias, §2–2.3</a>). Eine kleine Stichprobe kann seltene Fragen auslassen; ein guter Durchschnitt beweist nicht, dass jede Fähigkeit erhalten geblieben ist.</p>
<ul>
<li><a href="https://paweldubiel.com/glossary/catastrophic-forgetting" hreflang="pl">Catastrophic Forgetting [Polski]</a> beschreibt eine erhebliche Verschlechterung früherer Fähigkeiten; die Demonstration zeigt, wie neues Training gemeinsame Einstellungen verändert.</li>
<li><a href="https://paweldubiel.com/de/glossary/fine-tuning">Fine-tuning</a> bedeutet, ein Modell mit ausgewählten Beispielen weiterzutrainieren. Nach aufeinanderfolgenden Trainings prüfen wir auch frühere Fähigkeiten.</li>
<li><a href="https://paweldubiel.com/de/glossary/wissensdestillation">Knowledge Distillation</a> kann Hinweise von einem älteren Modell an das aktualisierte Modell weitergeben; das ist eine andere Strategie als das Aufbewahren der ursprünglichen Nachrichten (§3.3 der Arbeit von van de Ven und Tolias).</li>
</ul>
<p><em>Text und Illustration wurden mit KI-Unterstützung erstellt; die Nachrichten, die Größe der Stichprobe und die Tabellenergebnisse sind ein eigenes Lehrbeispiel. Die Illustration zeigt das Ziel, frühere Fähigkeiten zu erhalten, nicht den Aufbau des Modells.</em></p>]]></content:encoded>
</item>
<item>
  <title>Sequence Packing</title>
  <link>https://paweldubiel.com/de/glossary/sequence-packing</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/sequence-packing</guid>
  <pubDate>Wed, 07 Oct 2026 07:34:31 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du trainierst ein Modell, kurze Antworten an Kunden zu schreiben: „Vielen Dank“, „Nein“ und „Ja“. Nach der Aufteilung in Textstücke, also Tokens, haben die Beispiele hier vereinfachend 3, 2 und 2…</description>
  <content:encoded><![CDATA[<p>Du trainierst ein Modell, kurze Antworten an Kunden zu schreiben: „Vielen Dank“, „Nein“ und „Ja“. Nach der Aufteilung in Textstücke, also <a href="https://paweldubiel.com/de/glossary/token">Tokens</a>, haben die Beispiele hier vereinfachend 3, 2 und 2 Positionen, einschließlich einer Endmarkierung für jeden Text. Wenn du jedes in einer eigenen Zeile mit acht Plätzen speicherst, enthalten von 24 Plätzen nur sieben Daten. Der Rest ist <strong>Padding</strong> — Füllmaterial, das die Längen angleicht, aber kein zu lernender Inhalt ist. Wie lassen sich die freien Plätze nutzen?</p>
<p><strong>Sequence Packing</strong> ordnet mehrere Beispiele in einer Eingabefolge an, um das Padding beim Training zu verringern. In unserem Beispiel passen alle drei in eine einzige Zeile mit acht Positionen: sieben Plätze mit Daten, einer leer. Es sind keine neuen Antworten entstanden; ihre Anordnung hat sich geändert. Diese Rolle beschreibt die <a href="https://huggingface.co/docs/trl/v0.29.0/sft_trainer#packing" rel="noopener noreferrer">TRL-Dokumentation 0.29.0, SFT Trainer, Abschnitt „Packing“</a>.</p>
<p><img src="https://paweldubiel.com/assets/sequence-packing-paper-strips-divided-tray.webp" alt="Drei farbige Papierstreifen liegen dicht in einer länglichen Schale, mit dünnen Trennwänden, die ihre Eigenständigkeit bewahren: eine Metapher für Sequence Packing." loading="eager" decoding="async" width="1536" height="1024"></p>
<p>Acht Plätze sind eine <strong>eigene Vereinfachung</strong>, keine voreingestellte Zeilengröße in TRL. Ein gewöhnlicher Batch kann nur auf die Länge des längsten Textes aufgefüllt werden; das Gruppieren ähnlicher Längen verringert ebenfalls ungenutzten Platz. Bereits <a href="https://arxiv.org/html/1706.03762v7#S5.SS1" rel="noopener noreferrer"><em>Attention Is All You Need</em>, §5.1</a>, beschreibt diese Gruppierung. Die Zahl leerer Plätze allein bestimmt die Beschleunigung nicht: Sie hängt auch von der Ausführung der Berechnungen ab.</p>
<h2 id="eine-gemeinsame-zeile-muss-kein-gemeinsames-gespräch-sein">Eine gemeinsame Zeile muss kein gemeinsames Gespräch sein</h2>
<p>Du möchtest, dass „Nein“ ein unabhängiges Beispiel bleibt und keine Fortsetzung von „Vielen Dank“ wird. Die Endmarkierung selbst ist nur ein Token. Die gewöhnliche Sperre des Blicks in die Zukunft — <a href="https://paweldubiel.com/de/glossary/kausale-maskierung">Causal Masking</a> — erlaubt späterem Text weiterhin, früheren Text derselben Zeile zu lesen.</p>
<p>Um die Unabhängigkeit zu bewahren, müssen die Berechnungen die Beispielgrenzen kennen und den Zugriff über diese Grenzen hinweg blockieren. Die Fehlerbewertung muss separat kontrolliert werden: Die Vorhersage des ersten Tokens von „Nein“ aus dem Ende des vorherigen Textes darf nicht trainiert werden. Die Auswahl bewerteter Positionen ist <a href="https://paweldubiel.com/de/glossary/loss-masking">Loss Masking</a>; das Auslassen einer Strafe für eine Position <strong>blockiert das Lesen dieser Position nicht</strong>.</p>
<p>Konkret dienen im <a href="https://github.com/huggingface/trl/blob/v0.29.0/trl/trainer/sft_trainer.py" rel="noopener noreferrer">Code von TRL 0.29.0: DataCollatorForLanguageModeling und BFD-Packing-Konfiguration</a> die Beispiellängen der Rekonstruktion der Grenzen, und die Anfänge werden von der Fehlerbewertung ausgenommen. Dieser Ablauf benötigt eine kompatible Attention-Implementierung — den Mechanismus zur Nutzung anderer Textpositionen; der Code warnt bei einer nicht unterstützten Konfiguration vor durchsickernden Informationen. Das ist eine Bedingung dieses konkreten Verfahrens, keine Eigenschaft jedes Packings.</p>
<h2 id="prüfe-zwei-getrennte-dinge">Prüfe zwei getrennte Dinge</h2>
<p>Aktiviere das Packing und deaktiviere anschließend die Trennung der Zugriffe. Die Platzersparnis bleibt erhalten, aber B1 kann das frühere Beispiel A nutzen. Quadrate bezeichnen Endtokens; A1, B1 und so weiter sind beispielhafte Textstücke. Die Demonstration zeigt erlaubte Verbindungen, ohne Modellantworten zu simulieren. Die Variante „volle Zeilen“ zeigt die fehlende Ersparnis, wenn bereits alle Beispiele jeweils acht Plätze füllen.</p>
<div id="sequence-packing-lab"></div>
<p>Die Strategien unterscheiden sich im Umgang mit langen Texten. In <a href="https://github.com/huggingface/trl/blob/v0.29.0/trl/data_utils.py" rel="noopener noreferrer">TRL 0.29.0, Funktion <code>pack_dataset</code></a>, passt <code>bfd</code> ganze Beispiele in freie Plätze ein, schneidet aber den Überhang eines zu langen Beispiels ab; <code>wrapped</code> kann den Text mittendrin teilen. Deshalb müssen sowohl die erhaltenen Daten als auch die Grenzen geprüft werden. Packing ordnet Eingaben für das Training, einschließlich <a href="https://paweldubiel.com/de/glossary/fine-tuning">Fine-tuning</a> — der weiteren Anpassung eines Modells anhand von Beispielen. Es vergrößert nicht die maximale Textlänge, die das Modell verarbeiten kann.</p>]]></content:encoded>
</item>
<item>
  <title>Reinforcement Learning</title>
  <link>https://paweldubiel.com/de/glossary/reinforcement-learning</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/reinforcement-learning</guid>
  <pubDate>Mon, 05 Oct 2026 08:44:03 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du möchtest einem Programm beibringen, ein kleines Spiel zu gewinnen. An einer Weggabelung kann es Weg A wählen, sofort zwei Münzen sammeln und die zweite Runde ohne neue Münzen beenden.</description>
  <content:encoded><![CDATA[<p>Du möchtest einem Programm beibringen, ein kleines Spiel zu gewinnen. An einer Weggabelung kann es Weg A wählen, sofort zwei Münzen sammeln und die zweite Runde ohne neue Münzen beenden. Weg B gibt in der ersten Runde nichts, führt aber in der zweiten zu fünf Münzen. Die Regel „wähle, was jetzt am meisten bringt“ zeigt auf A, obwohl B nach zwei Runden das bessere Ergebnis liefert. Du hast auch keinen fertigen Antwortdatensatz, der in jeder Situation den richtigen Zug vorgibt. Das Programm kann jedoch Partien spielen und ihre Ergebnisse prüfen.</p>
<p><strong>Reinforcement Learning (RL)</strong> ist das Lernen einer Handlungsstrategie anhand von Erfahrungen und numerischen Bewertungen der Aktionsfolgen. Ziel ist, die erwartete Gesamtbelohnung zu erhöhen: das Ergebnis, das eine Strategie im Mittel über viele Versuche erzielt. Die Belohnung muss nicht sofort nach der Entscheidung erscheinen. So beschreibt das offizielle <a href="https://spinningup.openai.com/en/latest/spinningup/rl_intro.html" rel="noopener noreferrer">Spinning Up, Teil 1, „Key Concepts and Terminology“, „Reward and Return“ und „The RL Problem“</a>, das Problem.</p>
<p><img src="https://paweldubiel.com/assets/reinforcement-learning-two-routes-delayed-reward.webp" alt="Ein verzweigter Weg auf einem Holzspielbrett: Der nähere Zweig führt zu einer kleinen Belohnung, der längere zu einer größeren." loading="eager" decoding="async" width="1536" height="1024"></p>
<h2 id="was-das-programm-aus-einer-gespielten-partie-lernt">Was das Programm aus einer gespielten Partie lernt</h2>
<p>In unserem Spiel ist der <strong>Agent</strong> das Programm, das den Weg wählt, und die <strong>Umgebung</strong> ist das Spiel, das den Zug ausführt und Münzen vergibt. Das Programm erhält eine Beobachtung, also verfügbare Informationen zur Situation, etwa die Position auf dem Brett. Die <strong>Policy</strong> ist seine Regel zur Aktionsauswahl; sie kann auch die Wahrscheinlichkeiten unterschiedlicher Züge festlegen.</p>
<p>Nach Versuch A speichert das Programm das Ergebnis „2, dann 0“. Versuch B ergibt „0, dann 5“. Der Lernalgorithmus nutzt solche Erfahrungen zur Verbesserung der Policy, etwa um an dieser Gabelung häufiger B zu wählen. Das beschreibt das Ziel, nicht ein universelles Aktualisierungsrezept. Das Ergebnis 5 muss mit der früheren Entscheidung für B verknüpft werden. Wählt das Programm immer A, sammelt es keine Informationen über B; deshalb erfordert das Lernen oft auch das Ausprobieren weniger bekannter Aktionen.</p>
<p>Das erfundene Spiel hat feste Ergebnisse und zwei Runden. In einer schwierigeren Umgebung kann derselbe Zug unterschiedliche Folgen haben; deshalb zählt das erwartete Ergebnis, und ein einzelner Erfolg beweist keine gute Strategie. Auch das bloße Vergleichen zweier bekannter Summen ist noch kein Lernen.</p>
<p>Beim <a href="https://paweldubiel.com/de/glossary/behavioral-cloning">Behavioral Cloning</a> lernt das Programm, Aktionen aus Beispielen nachzuahmen. Bei RL ist die Bewertung der Folgen die Information, die das Lernen lenkt. In Sprachmodellen kann die Aktion das Erzeugen einer Antwort sein, die Belohnung eine Bewertung ihrer Richtigkeit oder Nützlichkeit. <a href="https://paweldubiel.com/glossary/reinforcement-learning-from-human-feedback" hreflang="pl">RLHF [Polski]</a> nutzt dafür Informationen von Menschen.</p>
<p>Eine wichtige Grenze: RL verbessert das Ergebnis nach der festgelegten Belohnung. Belohnen die Punkte das Umgehen von Regeln statt der Aufgabe, kann der Agent <a href="https://paweldubiel.com/glossary/reward-hacking-wykorzystywanie-luk-w-systemie-nagrod" hreflang="pl">Reward Hacking [Polski]</a> lernen. Mehr Punkte müssen nicht das Verhalten bedeuten, das wir tatsächlich erreichen wollten.</p>
<h2 id="wähle-einen-weg-und-prüfe-dann-die-zweite-runde">Wähle einen Weg und prüfe dann die zweite Runde</h2>
<p>In diesem Experiment vergleichst du das Ziel zweier Strategien; <strong>du trainierst keinen Agenten</strong>. Wähle einen Weg und decke das spätere Ergebnis auf. Der Regler verändert die Bedeutung der zukünftigen Belohnung, nicht die Zahl gesammelter Münzen.</p>
<p>Wir berechnen den <strong>Return</strong>, also das Ergebnis des gesamten Versuchs: <code>erste Belohnung + γ × zweite Belohnung</code>. Das Symbol γ (Gamma) ist das Gewicht der zukünftigen Belohnung. Bei γ = 1 zählen wir beide Runden vollständig: A ergibt 2, B ergibt 5. Bei γ = 0,2 erhalten wir A = 2, B = 1. Das ist ein anderes Bewertungsziel für dasselbe Spiel. Die Grenzwerte γ = 0 und 1 sind hier zulässig, weil der Versuch nach zwei Runden endet; es ist keine unendliche Belohnungsfolge. Quelle des Formalismus: <a href="https://spinningup.openai.com/en/latest/spinningup/rl_intro.html#reward-and-return" rel="noopener noreferrer">Spinning Up, „Reward and Return“</a>.</p>
<div id="rl-delayed-reward-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Loss Masking</title>
  <link>https://paweldubiel.com/de/glossary/loss-masking</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/loss-masking</guid>
  <pubDate>Sun, 20 Sep 2026 15:05:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>training</category>
  <description>Du trainierst einen Agenten anhand von Aufzeichnungen seiner Gespräche mit Werkzeugen. Die Aufzeichnung enthält seine Befehle und die Antworten der Werkzeuge.</description>
  <content:encoded><![CDATA[<p>Du trainierst einen Agenten anhand von Aufzeichnungen seiner Gespräche mit Werkzeugen. Die Aufzeichnung enthält seine Befehle und die Antworten der Werkzeuge. Du möchtest ihn für ausgewählte Abschnitte bewerten, ihm aber weiterhin erlauben, die übrigen als Kontext für die nächste Aktion zu lesen.</p>
<p><strong>Loss Masking</strong> legt fest, welche Positionen zum Verlust beitragen, also zur numerischen Bewertung des Fehlers beim Lernen. Ein <a href="https://paweldubiel.com/de/glossary/token">Token</a> — ein Stück Text — kann in der Eingabe sichtbar bleiben, obwohl das Modell nicht direkt für seine Vorhersage bewertet wird.</p>
<p>Beim Lernen allein aus den Antworten des Agenten helfen der Nutzertext und das Werkzeugergebnis bei der Wahl des nächsten Schritts, erhalten aber keine eigene Strafe für ihre Vorhersage. Das Modell muss also nicht lernen, jeden Teil der gesamten Aufzeichnung zu erzeugen.</p>
<p>Das unterscheidet sich von <a href="https://paweldubiel.com/de/glossary/kausale-maskierung">Causal Masking</a>, das den Informationsfluss zwischen Positionen begrenzt. Ein fehlender Verlustterm für ein Token muss nicht bedeuten, dass es keinen Einfluss auf das Training hat: Seine Berechnungen können später bewertete Positionen beeinflussen. Die <a href="https://arxiv.org/html/2609.20715v1#S2" rel="noopener noreferrer">Arbeit „Don’t Mask the Environment“, §2</a>, untersucht die Folgen der Auswahl bewerteter Abschnitte.</p>
<p>Siehe auch: <a href="https://paweldubiel.com/de/glossary/sequence-packing">Sequence Packing</a> zeigt, warum beim Zusammenfügen von Beispielen der Zugang zum Kontext und die vom Verlust bewerteten Positionen getrennt gesteuert werden müssen.</p>
<p><img src="https://paweldubiel.com/assets/loss-masking-hero.webp" alt="Sechs Tokens bleiben in einer Reihe, doch nur drei orangefarbene sind mit einer Waagschale verbunden, die den Verlust symbolisiert." loading="eager" decoding="async" width="1600" height="900"></p>]]></content:encoded>
</item>
<item>
  <title>pass@k</title>
  <link>https://paweldubiel.com/de/glossary/pass-k</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/pass-k</guid>
  <pubDate>Sun, 20 Sep 2026 15:04:00 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>papers</category>
  <category>llm</category>
  <category>agents</category>
  <description>Ein Modell hat zehn Programme erstellt, von denen eines die Tests bestanden hat. Bedeutet das eine hohe Erfolgsquote für eine einzelne Antwort?</description>
  <content:encoded><![CDATA[<p>Ein Modell hat zehn Programme erstellt, von denen eines die Tests bestanden hat. Bedeutet das eine hohe Erfolgsquote für eine einzelne Antwort? Du musst „beim ersten Versuch gelungen“ von „unter vielen Versuchen einen Erfolg gefunden“ unterscheiden.</p>
<p><strong>pass@k</strong> misst die Wahrscheinlichkeit, dass mindestens einer von <code>k</code> Versuchen zur Lösung einer Aufgabe eine festgelegte Prüfung besteht. Das Ergebnis wird über die Aufgaben zusammengefasst. Die Zahl <code>k</code> gehört zur Bedeutung der Metrik, weil sie das Budget an Versuchen bestimmt.</p>
<p>In einer Menge von vier Ausführungen mit einem Erfolg beträgt die Schätzung von pass@1 <code>1/4</code>. Von den sechs möglichen Paaren enthalten drei den Erfolg, also beträgt die Schätzung von pass@2 aus dieser Menge <code>1/2</code>. Die Zahl der zur Schätzung gesammelten Versuche darf nicht mit der Zahl der in der gemessenen Situation erlaubten Versuche verwechselt werden.</p>
<p>Ein hohes pass@10 verspricht kein ebenso gutes pass@1. Es sagt auch nicht, ob der Nutzer den richtigen Versuch ohne Prüfer erkennen kann. <a href="https://arxiv.org/abs/2107.03374" rel="noopener noreferrer">Chen und Mitautoren, §3.1</a>, beschreiben die Schätzung von pass@k; die <a href="https://arxiv.org/html/2609.20715v1#A1" rel="noopener noreferrer">Arbeit über Agenten</a> verwendet diese Metrik in einem anderen Kontext.</p>]]></content:encoded>
</item>
<item>
  <title>Continuous Batching</title>
  <link>https://paweldubiel.com/de/glossary/continuous-batching</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/continuous-batching</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein Server erzeugt zwei Antworten gleichzeitig. Eine endet schnell, die andere ist lang. Wenn der nächste Nutzer warten muss, bis das gesamte Paar fertig ist, bleibt der frei gewordene Platz viele…</description>
  <content:encoded><![CDATA[<p>Ein Server erzeugt zwei Antworten gleichzeitig. Eine endet schnell, die andere ist lang. Wenn der nächste Nutzer warten muss, bis das gesamte Paar fertig ist, bleibt der frei gewordene Platz viele Schritte lang ungenutzt.</p>
<p><strong>Continuous Batching</strong> erlaubt es, die Zusammensetzung der bearbeiteten Anfragen zwischen aufeinanderfolgenden Modelliterationen zu ändern. Eine fertige Antwort verlässt den Batch — die gemeinsam verarbeitete Gruppe — und eine neue Anfrage kann ihren Platz einnehmen.</p>
<p>Die lange Antwort wächst weiter, während die kurze durch die nächste ersetzt wird. Für die Auswahl der Teilnehmer ist der Scheduler zuständig, also das Programm zur Arbeitsplanung. Man muss nicht auf den langsamsten Teilnehmer der gesamten vorherigen Gruppe warten.</p>
<p>Diese Nutzung freier Plätze kann den Durchsatz erhöhen, garantiert aber nicht jedem Nutzer eine kürzere Wartezeit. Die Länge der Anfragen, Speichergrenzen und Planungsregeln spielen eine Rolle. Bei ähnlichen Längen kann der Vorteil gegenüber einer festen Gruppe gering sein.</p>
<p>Quelle des Mechanismus: <a href="https://www.usenix.org/system/files/osdi22-yu.pdf#page=6" rel="noopener noreferrer"><em>Orca</em>, §3, „Iteration-level scheduling“</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/continuous-batching-hero.webp" alt="Eine Presse mit zwei Bahnen: Ein langes türkisfarbenes Band läuft weiter; an die Stelle des kurzen ockerfarbenen tritt ein orangefarbenes." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Das ist besonders beim <a href="https://paweldubiel.com/de/glossary/decode">Decode</a> nützlich: Eine Person braucht eine kurze Antwort, eine andere mehrere Hundert <a href="https://paweldubiel.com/de/glossary/token">Tokens</a>. Allein das Sammeln mehrerer Anfragen vor dem Modellstart ermöglicht noch keine Änderung der Zusammensetzung eines bereits laufenden Batches. Eine neue Anfrage benötigt außerdem <a href="https://paweldubiel.com/de/glossary/prefill">Prefill</a>; wie dieser Schritt zusammen mit der Generierung behandelt wird, hängt von der Implementierung der Engine ab.</p>
<h2 id="muss-c-auf-a-warten">Muss C auf A warten?</h2>
<p>Eigenes Experiment: Zwei Plätze sind verfügbar. A und B sind zum Zeitpunkt 0 bereit und benötigen sechs beziehungsweise zwei Runden. C wird zum Zeitpunkt 1 bereit und benötigt zwei Runden. Beide Varianten führen dieselben Berechnungen aus, aber in der festen Gruppe nimmt der Platz von B erst nach dem Ende von A die Anfrage C auf.</p>
<p>Bei Continuous Batching startet C zum Zeitpunkt 2 und endet bei 4; in der festen Gruppe startet C bei 6 und endet bei 8. Stelle B auf sechs Runden um: Dann entfällt die frühere Freigabe eines Platzes, und beide Strategien ergeben denselben Zeitplan.</p>
<div id="continuous-batch-lab"></div>
<p>Die Runden haben hier eine angenommene gleiche Länge. Prefill und Transfers liegen außerhalb des Experiments; „bereit“ bedeutet bereit für die dargestellten Runden. Auf der GPU hängt die Iterationsdauer von der Arbeit ab. Die Anzahl belegter Plätze ist daher kein Prozentsatz der Geräteauslastung.</p>
<p>Die Möglichkeit, eine Anfrage hinzuzufügen, garantiert keinen sofortigen Start: Speichergrenzen und Scheduler-Regeln gelten weiterhin (<em>Orca</em>, §4.2). <a href="https://paweldubiel.com/de/glossary/pagedattention">PagedAttention</a> erleichtert die Speicherverwaltung, bestimmt aber selbst nicht die Bearbeitungsreihenfolge.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>PagedAttention</title>
  <link>https://paweldubiel.com/de/glossary/pagedattention</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/pagedattention</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein Server bearbeitet Gespräche unterschiedlicher Länge. Wenn er für jedes im Voraus einen großen zusammenhängenden Speicherbereich für die gesamte künftige Antwort reserviert, bleibt ein Teil des…</description>
  <content:encoded><![CDATA[<p>Ein Server bearbeitet Gespräche unterschiedlicher Länge. Wenn er für jedes im Voraus einen großen zusammenhängenden Speicherbereich für die gesamte künftige Antwort reserviert, bleibt ein Teil des Platzes ungenutzt. Du möchtest kleinere Abschnitte nach Bedarf zuweisen.</p>
<p><strong>PagedAttention</strong> liest Informationen aus dem <a href="https://paweldubiel.com/de/glossary/kv-cache">KV Cache</a>, die in Blöcken gespeichert sind und an unterschiedlichen Stellen im Speicher liegen können. Eine Blocktabelle zeigt, wo der nächste logische Abschnitt des Gesprächs zu finden ist. Die Reihenfolge des Textes bleibt korrekt.</p>
<p>Wenn ein Block die Beschreibungen von vier <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> — Textstücken — aufnimmt, wird nach dem fünften ein zweiter Block benötigt. Das System muss nicht im Voraus Platz für die maximale Länge jedes Gesprächs reservieren. Es kann auch unveränderte Blöcke nach den Regeln der Speicherverwaltung gemeinsam nutzen.</p>
<p>Das ist eine Art der Adressierung und Datenorganisation, keine automatische Verkürzung des Kontexts oder Änderung des Attention-Ergebnisses. Der Aufwand für Tabellen und teilweise gefüllte Blöcke bleibt. Das Experiment zeigt die Trennung von logischer Reihenfolge und physischem Speicherort.</p>
<p>Quelle des Mechanismus: <a href="https://arxiv.org/html/2309.06180v1#S4.SS1" rel="noopener noreferrer">Kwon et al., §4.1–4.3</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/pagedattention-hero.webp" alt="Ein aprikosenfarbener Faden verbindet vier voneinander entfernte Blöcke und erhält die Sequenzkontinuität trotz verteilter Speicherlage." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Eigenes Beispiel: Ein Block enthält KV für vier Positionen. Eine Sequenz der Länge fünf benötigt zwei Blöcke, also acht Plätze. Der erste ist voll, der zweite enthält einen Eintrag und drei freie Plätze. Die logischen Blöcke 0 und 1 können auf die physischen Blöcke 4 und 1 verweisen. Das bisherige Präfix muss nicht verschoben werden, um während <a href="https://paweldubiel.com/de/glossary/decode">Decode</a> den nächsten Block anzuhängen.</p>
<h2 id="textreihenfolge-ist-keine-speicheradresse">Textreihenfolge ist keine Speicheradresse</h2>
<p>Die Demonstration zeigt eine Sequenz und Blöcke mit vier Positionen. Verarbeite weitere Positionen, insbesondere den Übergang von vier zu fünf. Ändere dann die Anordnung derselben Daten. Wir nehmen einen skalaren Kopf an: Alle Keys sind null, das Query ist 1, und die Values aufeinanderfolgender Positionen sind 1, 2, 3… Die Attention-Gewichte sind somit gleich und das Ergebnis ist der Value-Mittelwert. Für fünf Positionen beträgt er in beiden Anordnungen 3.</p>
<div id="paged-kv-lab"></div>
<p>Dies veranschaulicht Adressierung und Zuweisung, simuliert aber keine GPU-Zeit. Leere Plätze im letzten Block belegen weiterhin Speicher; PagedAttention entfernt oder komprimiert vorhandenes KV nicht. <a href="https://paweldubiel.com/de/glossary/flashattention">FlashAttention</a> konzentriert sich auf die Organisation von Berechnungen und Transfers bei Attention. Die Mechanismen können sich ergänzen. Blockweises Teilen von Speicher hilft auch beim <a href="https://paweldubiel.com/de/glossary/prefix-caching">Prefix Caching</a>.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Prefix Caching</title>
  <link>https://paweldubiel.com/de/glossary/prefix-caching</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/prefix-caching</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du stellst fünf Fragen zum selben langen Dokument. Jede Eingabe beginnt mit derselben Anweisung und dem Dokumenttext; erst am Ende steht die neue Frage.</description>
  <content:encoded><![CDATA[<p>Du stellst fünf Fragen zum selben langen Dokument. Jede Eingabe beginnt mit derselben Anweisung und dem Dokumenttext; erst am Ende steht die neue Frage. Den gleichen Anfang erneut zu berechnen würde Arbeit wiederholen.</p>
<p><strong>Prefix Caching</strong> nutzt zuvor berechnete Ergebnisse eines gemeinsamen Anfangs von <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> — Textstücken — für weitere Anfragen. Bei geeigneten Modellen können das Daten des <a href="https://paweldubiel.com/de/glossary/kv-cache">KV Cache</a> sein, die einen Teil der <a href="https://paweldubiel.com/de/glossary/prefill">Eingabeverarbeitung</a> ersparen.</p>
<p>Die neue Frage muss weiterhin verarbeitet und ihre Antwort erzeugt werden. Der Cache ist keine Bibliothek fertiger Antworten. Entscheidend sind die Übereinstimmung des Anfangs und der Berechnungsbedingungen: Zwei Dokumente mit ähnlicher Bedeutung müssen keinen gemeinsamen Cache ergeben.</p>
<p>Schon eine kleine Änderung eines früheren Abschnitts kann die Wiederverwendung späterer Blöcke verhindern. Die Einsparung betrifft wiederholte Arbeit, nicht jedes Gespräch; auch das Speichern gemeinsamer Ergebnisse beansprucht Speicher.</p>
<p>Quelle des Mechanismus: <a href="https://docs.vllm.ai/en/v0.21.0/features/automatic_prefix_caching/" rel="noopener noreferrer">vLLM 0.21.0, „Introduction“ und „Limits“</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/prefix-caching-hero.webp" alt="Ein gemeinsamer Stamm aus denselben Segmenten teilt sich in drei unterschiedliche, unvollständige Äste." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Entscheidend ist ein <strong>identisches Tokenpräfix in einem übereinstimmenden Berechnungskontext</strong>, nicht semantische Ähnlichkeit. Keys und Values späterer Schichten hängen vom vorherigen Kontext ab. Derselbe letzte Absatz nach einem geänderten Anfang liefert nicht automatisch dasselbe KV.</p>
<p>vLLM identifiziert einen Block anhand seiner Tokens, der Kennung des vorherigen Blocks und zusätzlicher Daten, unter anderem der Kennung des <a href="https://paweldubiel.com/de/glossary/lora">LoRA</a>-Adapters und der Bildeingabe. In der beschriebenen Version werden vollständige Blöcke zur Wiederverwendung gespeichert. Siehe die <a href="https://docs.vllm.ai/en/v0.21.0/design/prefix_caching/" rel="noopener noreferrer">Beschreibung des Mechanismus Automatic Prefix Caching</a>. Die Übereinstimmung des Modells, der Positionen und anderer Einstellungen, die KV beeinflussen, ist eine Voraussetzung für die korrekte Wiederverwendung; ein Vergleich der Texte allein genügt nicht.</p>
<h2 id="ein-verändertes-token-unterschiedliche-folgen">Ein verändertes Token, unterschiedliche Folgen</h2>
<p>Der Cache unseres Beispiels enthält A B C D E F G H in Blöcken mit je zwei Tokens. Die Buchstaben stehen für angenommene Token-IDs. Eine neue Anfrage ersetzt genau eine Position durch X. Verändere deren Position und prüfe, wie viele vollständige Blöcke sich zurückgewinnen lassen.</p>
<p>Wird H durch X ersetzt, bleiben sieben gemeinsame Tokens, aber nur sechs in vollständigen Blöcken. Wird A durch X ersetzt, gibt es null Treffer, obwohl die folgenden sieben Tokens übereinstimmen. Alle übrigen Bedingungen sind im Beispiel konstant; der Cache ist verfügbar und nichts wurde daraus entfernt.</p>
<div id="prefix-match-lab"></div>
<p>Dies ist ein Cache für Berechnungen, keine fertige Antwort. <a href="https://paweldubiel.com/de/glossary/decode">Decode</a> muss weitere Tokens weiterhin erzeugen, und entfernte Blöcke müssen neu berechnet werden. Die blockweise Speicherorganisation erklärt <a href="https://paweldubiel.com/de/glossary/pagedattention">PagedAttention</a>.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Zeit bis zum ersten Token</title>
  <link>https://paweldubiel.com/de/glossary/zeit-bis-zum-ersten-token</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/zeit-bis-zum-ersten-token</guid>
  <pubDate>Sun, 20 Sep 2026 07:26:41 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du klickst auf „Senden“ und schaust auf einen leeren Chat. Für den Nutzerkomfort ist entscheidend, wann der Anfang der Antwort erscheint, auch wenn die gesamte Antwort deutlich länger braucht.</description>
  <content:encoded><![CDATA[<p>Du klickst auf „Senden“ und schaust auf einen leeren Chat. Für den Nutzerkomfort ist entscheidend, wann der Anfang der Antwort erscheint, auch wenn die gesamte Antwort deutlich länger braucht. Du benötigst eine Messung dieser ersten Wartezeit.</p>
<p><strong>Time to First Token (TTFT)</strong> ist die Zeit von einem festgelegten Beginn der Bearbeitung bis zum ersten <a href="https://paweldubiel.com/de/glossary/token">Token</a>, also einem Antwortfragment. Bei der beschriebenen Messung auf Clientseite beginnen wir mit dem Absenden der Anfrage und enden mit dem ersten nicht leeren Inhalt.</p>
<p>Wenn die Frage bei <code>0 ms</code> gesendet wurde und der erste Text bei <code>800 ms</code> eintraf, beträgt TTFT <code>800 ms</code>. In dieser Zahl können Netzwerk, Warteschlange, Eingabevorbereitung und Berechnungen enthalten sein. Eine Messung der reinen Modellzeit hätte andere Grenzen.</p>
<p>Ein kleines TTFT garantiert keinen flüssigen weiteren Verlauf: Nach dem ersten Fragment kann eine lange Pause folgen. Das beschreibt <a href="https://paweldubiel.com/glossary/inter-token-latency" hreflang="pl">Inter-token Latency [Polski]</a>. Bei Vergleichen muss immer angegeben werden, von welchem bis zu welchem Zeitpunkt gemessen wurde.</p>
<p>Quelle des Mechanismus: <a href="https://docs.nvidia.com/nim/benchmarking/llm/latest/metrics.html#time-to-first-token" rel="noopener noreferrer">NVIDIA NIM Benchmarking-Dokumentation, „Time to First Token“</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/time-to-first-token-hero.webp" alt="Das erste goldene Quadrat passiert die Engstelle einer Sanduhr, obwohl der Großteil des Inhalts noch oben liegt." loading="eager" decoding="async" width="1600" height="900"></p>
<p>TTFT umfasst mehr als <a href="https://paweldubiel.com/de/glossary/prefill">Prefill</a>: Der Client kann auf Netzwerk, Eingabevorbereitung, Warteschlange, Berechnungen und Ergebnisübertragung warten. Eine erst im Server beginnende Messung hat andere Grenzen. Solche Zahlen dürfen nicht verglichen werden, ohne die Herkunft ihrer Zeitstempel zu prüfen.</p>
<h2 id="das-erste-zeichen-schnell-die-ganze-antwort-spät">Das erste Zeichen schnell, die ganze Antwort spät</h2>
<p>Eigene Ereignisspur: Senden bei 0 ms, Serverankunft bei 30 ms, Vorbereitung für 10 ms, Warteschlange 200 ms, Prefill 120 ms, Vorbereitung des ersten Ergebnisses 5 ms und dessen Lieferung 35 ms. Die Client-TTFT beträgt <strong>400 ms</strong>; von der Anfrageankunft bis zum vorbereiteten Serverergebnis vergehen <strong>335 ms</strong>.</p>
<p>Nach dem ersten Token empfangen wir vier weitere, alle 20 ms. Die gesamte Antwort trifft nach 480 ms ein. Erhöhe die Abstände auf 100 ms: Das Ende verschiebt sich auf 800 ms, aber das erste Token kommt weiterhin bei 400 ms. Erhöhe dann die Warteschlange und beobachte, welche Ergebnisse sich gemeinsam ändern.</p>
<div id="ttft-clock-lab"></div>
<p>Die Zeiten sind synthetisch, die Phasen überschneiden sich nicht, und jede Nachricht enthält ein Token. Reales Streaming kann Tokens gruppieren. TTFT beschreibt weder den Rhythmus des <a href="https://paweldubiel.com/de/glossary/decode">Decode</a> noch die Zeit bis zum Erhalt der gesamten Antwort; die Dokumentation trennt diese Metriken in den Abschnitten „Inter-token Latency“ und „End-to-End Request Latency“. <a href="https://paweldubiel.com/glossary/inter-token-latency" hreflang="pl">Inter-token Latency [Polski]</a> beschreibt die Abstände und Pausen nach dem ersten Token. <a href="https://paweldubiel.com/de/glossary/prefix-caching">Prefix Caching</a> kann die Arbeit am Prompt verringern, während <a href="https://paweldubiel.com/de/glossary/continuous-batching">Continuous Batching</a> beeinflusst, wann der Scheduler eine Anfrage zur Ausführung zulässt.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Decode</title>
  <link>https://paweldubiel.com/de/glossary/decode</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/decode</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Das erste Fragment der Antwort ist bereits erschienen. Das nächste muss berücksichtigen, was gerade geschrieben wurde: Nach „Heute trinke ich Tee“ hat das Modell einen anderen Kontext als nach…</description>
  <content:encoded><![CDATA[<p>Das erste Fragment der Antwort ist bereits erschienen. Das nächste muss berücksichtigen, was gerade geschrieben wurde: Nach „Heute trinke ich Tee“ hat das Modell einen anderen Kontext als nach „Heute trinke ich Wasser“. Dieser sich verändernde Text muss schrittweise erweitert werden.</p>
<p><strong>Decode</strong> ist die Phase der Erzeugung einer Fortsetzung nach der Verarbeitung der anfänglichen Eingabe. In der üblichen Schleife verarbeitet das Modell das zuletzt gewählte <a href="https://paweldubiel.com/de/glossary/token">Token</a> — ein Textstück —, berechnet die Wahrscheinlichkeiten für das nächste, und eine Auswahlregel fügt einen der Kandidaten hinzu.</p>
<p>Das gewählte Fragment wird zur Eingabe des nächsten Schritts. Der <a href="https://paweldubiel.com/de/glossary/kv-cache">KV Cache</a> bewahrt benötigte Ergebnisse früherer Berechnungen auf, sodass nicht die gesamte Historie von Neuem verarbeitet werden muss.</p>
<p>So entsteht eine Abhängigkeit zwischen aufeinanderfolgenden Entscheidungen, obwohl mehrere unterschiedliche Antworten gemeinsam bearbeitet werden können. Decode bezeichnet hier das Erweitern des Textes durch das Modell, nicht nur die Umwandlung von Tokenkennungen in Zeichen. <a href="https://paweldubiel.com/de/glossary/prefill">Prefill</a> bereitet den anfänglichen Kontext vor.</p>
<p>Quelle des Mechanismus: <a href="https://arxiv.org/html/1911.02150v1#S2.SS4" rel="noopener noreferrer">Shazeer, <em>Fast Transformer Decoding</em>, §2.4</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/decode-hero.webp" alt="Eine Reihe fertiger Strickmaschen endet mit einer neuen Masche, die auf der Nadel entsteht." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Das erste Antworttoken lässt sich aus dem <a href="https://paweldubiel.com/de/glossary/prefill">Prefill</a>-Ergebnis auswählen. Wird weitergeneriert, ist dieses Token die Eingabe des nächsten Modelldurchlaufs. Seine neuen K und V kommen in den <a href="https://paweldubiel.com/de/glossary/kv-cache">KV-Cache</a>, und das Query nutzt aktuelle und frühere Positionen. Die bloße Auswahl einer Token-ID ergänzt noch nicht deren Repräsentation im Cache. Das zeigt die <a href="https://huggingface.co/docs/transformers/cache_explanation#cache-storage-implementation" rel="noopener noreferrer">Hugging-Face-Generierungsschleife, „Cache storage implementation“</a>.</p>
<h2 id="token-ausgewählt-aber-noch-nicht-verarbeitet">Token ausgewählt, aber noch nicht verarbeitet</h2>
<p>Das eigene Miniaturmodell hat drei Tokens: A, B und C. Ihre Vektoren sind <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(0,1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mo>−</mo><mn>1</mn><mo separator="true">,</mo><mo>−</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(-1,-1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">−</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">−</span><span class="mord">1</span><span class="mclose">)</span></span></span></span>. Wir setzen <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Q</mi><mo>=</mo><mi>K</mi><mo>=</mo><mi>V</mi></mrow><annotation encoding="application/x-tex">Q=K=V</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">Q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0715em;">K</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.2222em;">V</span></span></span></span> gleich diesen Vektoren; Attention nutzt die Skala <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>1</mn><mi mathvariant="normal">/</mi><msqrt><mn>2</mn></msqrt></mrow><annotation encoding="application/x-tex">1/\sqrt{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1572em;vertical-align:-0.25em;"></span><span class="mord">1/</span><span class="mord sqrt"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.9072em;"><span class="svg-align" style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord" style="padding-left:0.833em;"><span class="mord">2</span></span></span><span style="top:-2.8672em;"><span class="pstrut" style="height:3em;"></span><span class="hide-tail" style="min-width:0.853em;height:1.08em;"><svg xmlns="http://www.w3.org/2000/svg" width="400em" height="1.08em" viewBox="0 0 400000 1080" preserveAspectRatio="xMinYMin slice"><path d="M95,702
c-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14
c0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54
c44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10
s173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429
c69,-144,104.5,-217.7,106.5,-221
l0 -0
c5.3,-9.3,12,-14,20,-14
H400000v40H845.2724
s-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7
c-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z
M834 80h400000v40h-400000z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1328em;"><span></span></span></span></span></span></span></span></span>. Aus dem Ergebnis <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>h</mi><mo>=</mo><mo stretchy="false">(</mo><msub><mi>h</mi><mn>0</mn></msub><mo separator="true">,</mo><msub><mi>h</mi><mn>1</mn></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">h=(h_0,h_1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span> bilden wir die Logits <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><msub><mi>h</mi><mn>1</mn></msub><mo separator="true">,</mo><msub><mi>h</mi><mn>0</mn></msub><mo separator="true">,</mo><mo>−</mo><msub><mi>h</mi><mn>0</mn></msub><mo>−</mo><msub><mi>h</mi><mn>1</mn></msub><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[h_1,h_0,-h_0-h_1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">−</span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">h</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">]</span></span></span></span>, und <a href="https://paweldubiel.com/de/glossary/greedy-decoding">Greedy Decoding</a> wählt den größten.</p>
<p>Der Prompt A B ergibt näherungsweise <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>h</mi><mo>=</mo><mo stretchy="false">(</mo><mn>0,330</mn><mo separator="true">;</mo><mn>0,670</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">h=(0{,}330;0{,}670)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal">h</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">330</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">670</span><span class="mclose">)</span></span></span></span>. Das erste Antworttoken ist somit A. Der Cache enthält vorerst nur die zwei Promptpositionen. Erst der nächste Durchlauf verarbeitet das gewählte A.</p>
<div id="decode-cache-lab"></div>
<p>Dies ist ein vollständig definiertes Demonstrationsmodell ohne Training, Positionen, mehrere Schichten oder Endtoken. Seine wiederholte Antwort hat keine sprachliche Bedeutung. Der Vergleich mit der Neuberechnung des gesamten Präfixes prüft die Ergebnisgleichheit. Der Zähler umfasst ausschließlich Positionen, für die K/V berechnet wurden.</p>
<p>Der Cache vermeidet wiederholte Berechnungen früherer K/V, aber Attention liest weiterhin den Kontext. Bei kleinen Batches wird oft die Übertragung der Gewichte oder des Caches zum begrenzenden Faktor; das hängt vom Modell, der Hardware und der Sequenzlänge ab. In der Architektur <a href="https://paweldubiel.com/glossary/disaggregated-serving" hreflang="pl">Disaggregated Serving [Polski]</a> läuft Decode nach dem Empfang des Caches auf eigenen Ressourcen. Decode in diesem Sinn ist nicht die Rückumwandlung von Tokenkennungen in Text durch den Tokenizer.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>FlashAttention</title>
  <link>https://paweldubiel.com/de/glossary/flashattention</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/flashattention</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Attention vergleicht viele Paare von Textfragmenten. Wenn alle Zwischenergebnisse in den großen Speicher der Rechenkarte geschrieben werden, kann die Datenübertragung teuer werden.</description>
  <content:encoded><![CDATA[<p>Attention vergleicht viele Paare von Textfragmenten. Wenn alle Zwischenergebnisse in den großen Speicher der Rechenkarte geschrieben werden, kann die Datenübertragung teuer werden. Du möchtest dieselbe Berechnung ausführen und dabei die Übertragung und Speicherung einer riesigen Tabelle begrenzen.</p>
<p><strong>FlashAttention</strong> organisiert die Attention-Berechnung in Blöcken im kleinen, schnellen Speicher des Chips. Es schreibt nicht die gesamte Matrix der Vergleiche und Gewichte in den großen GPU-Speicher, also den Speicher der für parallele Berechnungen verwendeten Karte.</p>
<p>Jede Portion trägt einen Teil zum Ergebnis bei, und der Algorithmus aktualisiert die Normalisierung und die Summe korrekt. Man kann nicht einfach getrennte Mittelwerte der Portionen berechnen und diese mitteln: Die Portionen können unterschiedliche Anteile haben.</p>
<p>Die mathematische Operation der exakten Attention bleibt erhalten, mit den üblichen Unterschieden der Computerarithmetik. Bei dichter Attention wächst die Zahl der Vergleiche weiterhin quadratisch. Der Gewinn entsteht durch Speicherorganisation und Ausführung, nicht durch das Entfernen von Abhängigkeiten zwischen Paaren.</p>
<p>Quelle des Mechanismus: <a href="https://arxiv.org/html/2205.14135v2#S3" rel="noopener noreferrer">Dao et al., §2–3.2, Algorithmus 1</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/flashattention-hero.webp" alt="Eine kleine Arbeitsfläche verarbeitet eine einzelne Kachel aus einem großen Vorrat und begrenzt so den Transfer des gesamten Inhalts." loading="eager" decoding="async" width="1600" height="900"></p>
<p>Bei dichter Attention wächst die Anzahl der Operationen weiterhin quadratisch mit der Sequenzlänge. Der Gewinn stammt aus der Organisation von Berechnung und Speicher. Beim Training werden manche Größen im Rückwärtslauf neu berechnet statt gespeichert. „Exakt“ bedeutet, dass die Operation selbst nicht angenähert wird; eine andere Reihenfolge von Gleitkommaoperationen kann kleine numerische Unterschiede ergeben.</p>
<h2 id="blockergebnisse-einfach-zu-mitteln-reicht-nicht">Blockergebnisse einfach zu mitteln reicht nicht</h2>
<p><a href="https://paweldubiel.com/de/glossary/softmax">Softmax</a> normalisiert die Gewichte über alle erlaubten Keys. Blöcke können sehr unterschiedliche Summen unnormalisierter Gewichte haben. Jeder muss daher den richtigen Anteil am Ergebnis erhalten.</p>
<p>Dies lässt sich schrittweise berechnen, indem man das Scoremaximum <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">m</span></span></span></span>, die Summe <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>l</mi><mo>=</mo><msub><mo>∑</mo><mi>j</mi></msub><msup><mi>e</mi><mrow><msub><mi>s</mi><mi>j</mi></msub><mo>−</mo><mi>m</mi></mrow></msup></mrow><annotation encoding="application/x-tex">l=\sum_j e^{s_j-m}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.2071em;vertical-align:-0.4358em;"></span><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:0em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.162em;"><span style="top:-2.4003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4358em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7713em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3281em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2819em;"><span></span></span></span></span></span></span><span class="mbin mtight">−</span><span class="mord mathnormal mtight">m</span></span></span></span></span></span></span></span></span></span></span></span> und den Zähler <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>=</mo><msub><mo>∑</mo><mi>j</mi></msub><msup><mi>e</mi><mrow><msub><mi>s</mi><mi>j</mi></msub><mo>−</mo><mi>m</mi></mrow></msup><msub><mi>v</mi><mi>j</mi></msub></mrow><annotation encoding="application/x-tex">u=\sum_j e^{s_j-m}v_j</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.2071em;vertical-align:-0.4358em;"></span><span class="mop"><span class="mop op-symbol small-op" style="position:relative;top:0em;">∑</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.162em;"><span style="top:-2.4003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4358em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7713em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">s</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3281em;"><span style="top:-2.357em;margin-left:0em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2819em;"><span></span></span></span></span></span></span><span class="mbin mtight">−</span><span class="mord mathnormal mtight">m</span></span></span></span></span></span></span></span></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0572em;">j</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.2861em;"><span></span></span></span></span></span></span></span></span></span> führt. Das Ergebnis ist <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mi mathvariant="normal">/</mi><mi>l</mi></mrow><annotation encoding="application/x-tex">u/l</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">u</span><span class="mord">/</span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span></span></span></span>. Erhöht ein neuer Block das Maximum auf <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>m</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow><annotation encoding="application/x-tex">m'</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7519em;"></span><span class="mord"><span class="mord mathnormal">m</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7519em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span>, müssen die bisherigen <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>l</mi></mrow><annotation encoding="application/x-tex">l</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0197em;">l</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi></mrow><annotation encoding="application/x-tex">u</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">u</span></span></span></span> vor dem Addieren neuer Terme mit <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mi>e</mi><mrow><mi>m</mi><mo>−</mo><msup><mi>m</mi><mo mathvariant="normal" lspace="0em" rspace="0em">′</mo></msup></mrow></msup></mrow><annotation encoding="application/x-tex">e^{m-m'}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.9425em;"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.9425em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="mbin mtight">−</span><span class="mord mtight"><span class="mord mathnormal mtight">m</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8278em;"><span style="top:-2.931em;margin-right:0.0714em;"><span class="pstrut" style="height:2.5em;"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight"><span class="mord mtight">′</span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span> skaliert werden. Die stabile Normalisierung erklären <a href="https://arxiv.org/html/1805.02867v2#S3" rel="noopener noreferrer">Milakov und Gimelshein, §3, Algorithmus 3</a>.</p>
<p>Das eigene Beispiel verwendet vorgegebene Scores <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mi>ln</mi><mo>⁡</mo><mn>3</mn><mo separator="true">,</mo><mi>ln</mi><mo>⁡</mo><mn>3</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0,0,\ln 3,\ln 3]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mclose">]</span></span></span></span> und Values <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0</mn><mo separator="true">,</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0,0,1,1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>. Die Gewichte vor der Normalisierung haben das Verhältnis <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>1</mn><mo separator="true">,</mo><mn>1</mn><mo separator="true">,</mo><mn>3</mn><mo separator="true">,</mo><mn>3</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[1,1,3,3]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mclose">]</span></span></span></span>. Das Ergebnis ist daher <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>6</mn><mi mathvariant="normal">/</mi><mn>8</mn><mo>=</mo><mn>0,75</mn></mrow><annotation encoding="application/x-tex">6/8=0{,}75</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">6/8</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">75</span></span></span></span>. Die Ergebnisse der beiden Blöcke sind 0 und 1. Ihr gewöhnlicher Mittelwert liefert die falsche 0,5.</p>
<div id="flashattention-blocks-lab"></div>
<p>Die Demonstration isoliert die Aggregation für ein Query und skalare Values. Der vollständige Kernel berechnet Scoreblöcke aus Q und K auf der GPU; hier ermöglichen vorgegebene Zahlen die Prüfung von Hand. Der Wechsel der Blockgröße ist kein Benchmark.</p>
<p><a href="https://paweldubiel.com/de/glossary/grouped-query-attention">Grouped-Query Attention</a> begrenzt die Anzahl der K/V-Köpfe, FlashAttention die Art von Datentransfer und Verarbeitung. Beide Techniken lassen sich kombinieren. FlashAttention 2 ist eine spätere Implementierungsweiterentwicklung; der hier beschriebene Mechanismus stammt aus der ersten Arbeit.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Prefill</title>
  <link>https://paweldubiel.com/de/glossary/prefill</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/prefill</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Du sendest eine lange Frage an den Chat und wartest auf das erste Wort. Bevor das Modell eine Antwort hinzufügt, muss es den bereits erhaltenen Inhalt verarbeiten.</description>
  <content:encoded><![CDATA[<p>Du sendest eine lange Frage an den Chat und wartest auf das erste Wort. Bevor das Modell eine Antwort hinzufügt, muss es den bereits erhaltenen Inhalt verarbeiten. Diese anfängliche Phase kann viel Arbeit erfordern, besonders bei einem langen Dokument.</p>
<p><strong>Prefill</strong> ist die Verarbeitung der bekannten Eingabe, des sogenannten Prompts, vor der weiteren Generierung. Das Modell erstellt numerische Beschreibungen der <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> — Textstücke — und kann einen Teil der Ergebnisse im <a href="https://paweldubiel.com/de/glossary/kv-cache">KV Cache</a> zur Wiederverwendung aufbewahren.</p>
<p>Da die gesamte Eingabe bereits vorliegt, können viele ihrer Positionen innerhalb einer Schicht parallel berechnet werden. Die Regeln für den Kontextzugriff gelten weiterhin: Parallele Arbeit erlaubt einer früheren Position keinen Blick auf die verbotene Zukunft.</p>
<p>Das Ergebnis der letzten Position erlaubt es, die Wahrscheinlichkeiten für das erste neue Token zu berechnen. Seine Auswahl ist ein eigener Schritt. Prefill umfasst nicht die gesamte Zeit ab dem Absenden der Frage: Netzwerk, Warteschlange und weitere Phasen kommen hinzu. Das weitere Erweitern der Antwort beschreibt <a href="https://paweldubiel.com/de/glossary/decode">Decode</a>.</p>
<p>Quelle des Mechanismus: <a href="https://developer.nvidia.com/blog/mastering-llm-techniques-inference-optimization/" rel="noopener noreferrer">NVIDIA, <em>Mastering LLM Techniques: Inference Optimization</em>, Abschnitt „Understanding LLM inference“</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p><img src="https://paweldubiel.com/assets/prefill-hero.webp" alt="Mehrere fertige Papierstreifen gelangen gleichzeitig unter einen breiten Kamm; der letzte erreicht einen leeren Platz für ein neues Element." loading="eager" decoding="async" width="1600" height="900"></p>
<h2 id="der-bekannte-prompt-lässt-sich-parallel-verarbeiten">Der bekannte Prompt lässt sich parallel verarbeiten</h2>
<p>Alle Eingabetokens sind bereits verfügbar. Innerhalb einer Schicht können deshalb viele Positionen gleichzeitig berechnet werden. Weiterhin gilt die <a href="https://paweldubiel.com/de/glossary/kausale-maskierung">kausale Maskierung</a>: Die zweite Position verwendet nicht die dritte. Parallele Berechnungen heben weder diese Abhängigkeit noch die Reihenfolge beim Durchlaufen der Schichten auf. Die Grundlage beschreiben <a href="https://arxiv.org/html/1706.03762v7#S3" rel="noopener noreferrer">Vaswani et al., §3.1–3.2</a>.</p>
<p>Prefill kann den <a href="https://paweldubiel.com/glossary/chunked-prefill" hreflang="pl">Prompt auch in Portionen verarbeiten [Polski]</a> und dabei den Cache früherer Positionen bewahren. Die <a href="https://docs.vllm.ai/en/v0.21.0/configuration/optimization/#chunked-prefill" rel="noopener noreferrer">vLLM-Dokumentation, „Chunked Prefill“</a> beschreibt, wie diese Aufteilung die Arbeit an Prompts mit der Erzeugung von Antworten für andere Anfragen verschränkt.</p>
<h2 id="vier-positionen-gleiches-ergebnis">Vier Positionen, gleiches Ergebnis</h2>
<p>Das eigene Beispiel isoliert einen Attention-Kopf mit Dimension 1: Alle Queries und Keys sind 1, die Values <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>2</mn><mo separator="true">,</mo><mn>4</mn><mo separator="true">,</mo><mn>8</mn><mo separator="true">,</mo><mn>10</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[2,4,8,10]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">4</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">8</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">10</span><span class="mclose">]</span></span></span></span>. Die zulässigen Vergleichswerte sind gleich. Jede Position liefert daher den Mittelwert der sichtbaren Values: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>2</mn><mo separator="true">,</mo><mn>3</mn><mo separator="true">,</mo><mn>14</mn><mi mathvariant="normal">/</mi><mn>3</mn><mo separator="true">,</mo><mn>6</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[2,3,14/3,6]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">14/3</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">6</span><span class="mclose">]</span></span></span></span>. Vergleiche die Verarbeitung aller vier Positionen mit Abschnitten zu je zwei. In der zweiten Variante muss die dritte Position weiterhin die ersten beiden sehen.</p>
<div id="prefill-chunks-lab"></div>
<p>Dies ist die Berechnung einer einzelnen Operation ohne trainierte Modellgewichte und ohne GPU-Messung. Im vollständigen Modell wird der Cache für jede Schicht separat geführt. Eine andere Aufteilung kann kleine numerische Implementierungsunterschiede verursachen; die mathematische Maske verändert sie nicht.</p>
<p>Nach dem Prompt beginnt <a href="https://paweldubiel.com/de/glossary/decode">Decode</a>, bei dem weitere Eingaben von gerade ausgewählten Tokens abhängen. Die Prefill-Zeit allein umfasst nicht die gesamte Wartezeit des Nutzers: Warteschlange, Eingabevorbereitung und Ergebnislieferung zählen ebenfalls. Siehe auch: <a href="https://paweldubiel.com/de/glossary/zeit-bis-zum-ersten-token">Time to First Token</a> umfasst die Wartezeit des Clients bis zum ersten Token, und <a href="https://paweldubiel.com/de/glossary/continuous-batching">Continuous Batching</a> ermöglicht Änderungen der bearbeiteten Gruppe zwischen Iterationen.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Speculative Decoding</title>
  <link>https://paweldubiel.com/de/glossary/speculative-decoding</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/speculative-decoding</guid>
  <pubDate>Fri, 18 Sep 2026 07:31:25 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein großes Modell erzeugt korrekten Text, ist aber langsam. Ein kleineres Modell kann schnell mehrere weitere Stücke vorschlagen.</description>
  <content:encoded><![CDATA[<p>Ein großes Modell erzeugt korrekten Text, ist aber langsam. Ein kleineres Modell kann schnell mehrere weitere Stücke vorschlagen. Du möchtest seine Arbeit nutzen und dabei die Kontrolle des großen Modells über das endgültige Ergebnis bewahren.</p>
<p><strong>Speculative Decoding</strong> erstellt einen günstigeren Vorschlag für die Fortsetzung und prüft ihn anschließend mit dem Zielmodell. Im klassischen Algorithmus übernehmen wir die anfängliche Folge akzeptierter <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> — Textstücke — bis zur ersten Ablehnung und berechnen dann eine Korrektur.</p>
<p>Das große Modell kann den bekannten Vorschlag für mehrere Positionen parallel bewerten. Die korrekte Stichprobenvariante verwendet besondere Akzeptanz- und Korrekturwahrscheinlichkeiten, um die Zielverteilung zu erhalten. Der bloße Test „klingt das sinnvoll?“ gewährleistet das nicht.</p>
<p>Die Beschleunigung hängt vom Aufwand für den Vorschlag, der Zahl der Akzeptanzen und der Hardware ab. Wenn das kleine Modell häufig vom großen abweicht, kann die zusätzliche Arbeit den Gewinn aufheben. Die Demonstration unten zeigt die Erhaltung der Wahrscheinlichkeiten, keine garantierte Laufzeit.</p>
<p>Quelle des Mechanismus: <a href="https://arxiv.org/html/2211.17192v2#S2" rel="noopener noreferrer">Leviathan et al., §2, Algorithmus 1</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Dies beschleunigt <a href="https://paweldubiel.com/de/glossary/decode">Decode</a> unter Erhaltung der Zielmodellverteilung unter den Bedingungen des Algorithmus. Zu prüfen, ob ein Vorschlag „gut aussieht“, genügt nicht.</p>
<h2 id="warum-eine-korrektur-nötig-ist">Warum eine Korrektur nötig ist</h2>
<p>Bezeichnen wir die Zielverteilung mit <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> und die Draft-Verteilung mit <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi></mrow><annotation encoding="application/x-tex">q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span>, für dasselbe Präfix und dieselbe Tokenmenge. Beide berücksichtigen die ausgewählten Ziehungsregeln, etwa <a href="https://paweldubiel.com/de/glossary/temperatur">Temperatur</a> und <a href="https://paweldubiel.com/de/glossary/top-p-sampling">Top-p-Sampling</a>. Ein Vorschlag <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>∼</mo><mi>q</mi></mrow><annotation encoding="application/x-tex">x\sim q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">∼</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span> wird mit folgender Wahrscheinlichkeit akzeptiert:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>min</mi><mo>⁡</mo><mrow><mo fence="true">(</mo><mn>1</mn><mo separator="true">,</mo><mfrac><mrow><mi>p</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><mrow><mi>q</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mfrac><mo fence="true">)</mo></mrow></mrow><annotation encoding="application/x-tex">\min\left(1,\frac{p(x)}{q(x)}\right)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:2.4em;vertical-align:-0.95em;"></span><span class="mop">min</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;"><span class="delimsizing size3">(</span></span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.427em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.936em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose delimcenter" style="top:0em;"><span class="delimsizing size3">)</span></span></span></span></span></span></span>
<p>Ein gezogener Vorschlag hat <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>></mo><mn>0</mn></mrow><annotation encoding="application/x-tex">q(x)>0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>. Nach einer Ablehnung ziehen wir aus einer Verteilung proportional zu <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>max</mi><mo>⁡</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mi>p</mi><mo>−</mo><mi>q</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\max(0,p-q)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">max</span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mclose">)</span></span></span></span>. Dieser Schritt ergänzt genau die fehlende Wahrscheinlichkeitsmasse. Ist <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mi>q</mi></mrow><annotation encoding="application/x-tex">p=q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span>, wird nichts abgelehnt und keine Korrektur benötigt. <a href="https://arxiv.org/html/2211.17192v2#A1.SS1" rel="noopener noreferrer">Leviathan et al., §2.3 und Beweis A.1</a>.</p>
<p>Eigenes Beispiel: Für A, B und C sei <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,2</mn><mo separator="true">;</mo><mn>0,5</mn><mo separator="true">;</mo><mn>0,3</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">p=[0{,}2;0{,}5;0{,}3]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">2</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">3</span><span class="mclose">]</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,6</mn><mo separator="true">;</mo><mn>0,3</mn><mo separator="true">;</mo><mn>0,1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">q=[0{,}6;0{,}3;0{,}1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">6</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">3</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>. Die unbedingte Masse akzeptierter Vorschläge beträgt <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0,2</mn><mo separator="true">;</mo><mn>0,3</mn><mo separator="true">;</mo><mn>0,1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0{,}2;0{,}3;0{,}1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">2</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">3</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">]</span></span></span></span>. Die verbleibenden 0,4 müssen gleichmäßig zwischen B und C aufgeteilt werden. Eine Korrekturziehung aus dem gewöhnlichen <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> würde stattdessen <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0,28</mn><mo separator="true">;</mo><mn>0,50</mn><mo separator="true">;</mo><mn>0,22</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0{,}28;0{,}50;0{,}22]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">28</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">50</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">22</span><span class="mclose">]</span></span></span></span> ergeben.</p>
<div id="speculative-mass-lab"></div>
<p>Das Experiment zeigt die genaue Bilanz einer Position, ohne die gesamte Schleife oder Laufzeit zu simulieren. Eine erhaltene Verteilung garantiert keinen identischen Text beim selben Seed: Algorithmen verbrauchen Zufälligkeit unterschiedlich, und Berechnungen haben begrenzte Präzision. Das besprechen <a href="https://arxiv.org/html/2302.01318v1#S6.SS1" rel="noopener noreferrer">Chen et al., §4.2 und §6.1</a>.</p>
<p>Die Beschleunigung hängt von Akzeptanzrate, Draft-Kosten und Hardware ab. Ein zu teurer Draft oder viele Ablehnungen können die Einsparung aufheben, selbst wenn die Verteilung korrekt bleibt.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Beam Search</title>
  <link>https://paweldubiel.com/de/glossary/beam-search</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/beam-search</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Bei der Auswahl des ersten Antwortfragments kannst du einen Weg zu früh verwerfen, der sich später als besser erwiesen hätte. Alle möglichen Folgen zu prüfen ist jedoch zu teuer.</description>
  <content:encoded><![CDATA[<p>Bei der Auswahl des ersten Antwortfragments kannst du einen Weg zu früh verwerfen, der sich später als besser erwiesen hätte. Alle möglichen Folgen zu prüfen ist jedoch zu teuer. Du brauchst eine begrenzte Menge an Alternativen.</p>
<p><strong>Beam Search</strong> behält mehrere der am besten bewerteten Teilantworten. In jedem Schritt erweitert es sie, vergleicht die neuen Folgen und lässt erneut nur eine festgelegte Anzahl übrig. Die Größe dieser Menge heißt Beam Width.</p>
<p>Bei einer Breite von zwei kann das System die Anfänge A und B behalten, statt sofort A zu wählen. Im nächsten Schritt vergleicht es ihre Fortsetzungen. Die grundlegende Bewertung verbindet die Wahrscheinlichkeiten aufeinanderfolgender <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> — Textstücke —, wobei Implementierungen den Einfluss der Länge korrigieren können.</p>
<p>Eine größere Menge kostet mehr Speicher und Berechnungen und kann trotzdem den besten Weg verwerfen. Eine hohe Wahrscheinlichkeit der gesamten Folge garantiert außerdem weder Wahrheit noch Vielfalt oder Nützlichkeit der Aussage.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Bei der <a href="https://paweldubiel.com/de/glossary/autoregressive-sprachmodellierung">autoregressiven Sprachmodellierung</a> ist der grundlegende Sequenzscore die Summe der Logarithmen ihrer Tokenwahrscheinlichkeiten:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>S</mi><mo stretchy="false">(</mo><msub><mi>x</mi><mrow><mn>1</mn><mo>:</mo><mi>t</mi></mrow></msub><mo stretchy="false">)</mo><mo>=</mo><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>t</mi></munderover><mi>ln</mi><mo>⁡</mo><mi>p</mi><mo stretchy="false">(</mo><msub><mi>x</mi><mi>i</mi></msub><mo>∣</mo><msub><mi>x</mi><mrow><mo>&#x3C;</mo><mi>i</mi></mrow></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">S(x_{1:t})=\sum_{i=1}^{t}\ln p(x_i\mid x_{&#x3C;i})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0576em;">S</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span><span class="mrel mtight">:</span><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:3.0582em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.7806em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">i</span><span class="mrel mtight">=</span><span class="mord mtight">1</span></span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span><span style="top:-4.3em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">∣</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mrel mtight">&#x3C;</span><span class="mord mathnormal mtight">i</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1774em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span></span>
<p>Dies ist der Logarithmus des Wahrscheinlichkeitsprodukts. Ein größerer Wert ist besser; die Summe vermeidet die Multiplikation sehr kleiner Zahlen. Die <a href="https://huggingface.co/docs/transformers/generation_strategies#beam-search" rel="noopener noreferrer">Hugging-Face-Dokumentation, „Beam search“</a> beschreibt das Behalten mehrerer Sequenzen. Bei Breite 1 reduziert sich diese grundlegende Variante auf <a href="https://paweldubiel.com/de/glossary/greedy-decoding">Greedy Decoding</a>.</p>
<h2 id="welches-präfix-verwirfst-du-zu-früh">Welches Präfix verwirfst du zu früh?</h2>
<p>Das eigene Beispiel beginnt mit A = 0,45, B = 0,35 und C = 0,20. Ein Beam mit Breite 2 verwirft C. Die beste Fortsetzung von A hat später die Chance 0,4; AA erreicht daher 0,18. Das übergangene CA hätte aber <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,20</mn><mo>⋅</mo><mn>0,99</mn><mo>=</mo><mn>0,198</mn></mrow><annotation encoding="application/x-tex">0{,}20\cdot0{,}99=0{,}198</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">20</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">99</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">198</span></span></span></span> erreicht. Breite 3 behält C und findet das bessere Ergebnis. Dies ist ein vollständiger kleiner Baum mit zwei Tokens, ohne vorzeitiges Ende und ohne Längennormalisierung.</p>
<div id="beam-pruning-lab"></div>
<p>Beam Search bleibt eine Näherung: Ein verworfenes Präfix wird nicht erneut erweitert. Die Breite bezeichnet nicht die Anzahl der aus einer Verteilung gezogenen Tokens wie bei <a href="https://paweldubiel.com/de/glossary/top-k-sampling">Top-k-Sampling</a>.</p>
<p>Bei unterschiedlich langen Sequenzen zählen Endtoken, Abbruchbedingung und Bewertungsfunktion. Beispielsweise teilt <code>length_penalty</code> in <a href="https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.GenerationConfig" rel="noopener noreferrer">GenerationConfig</a> den logarithmischen Score durch die mit einem festgelegten Exponenten potenzierte Länge. Dieses Kriterium darf nicht mit reiner Wahrscheinlichkeit verwechselt werden. Ein breiterer Beam garantiert auch keinen besseren Inhalt; das Problem besprechen <a href="https://arxiv.org/html/1904.09751v2#S3" rel="noopener noreferrer">Holtzman et al., §2.2–3</a>.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Greedy Decoding</title>
  <link>https://paweldubiel.com/de/glossary/greedy-decoding</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/greedy-decoding</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Das Modell kann mehrere unterschiedliche Fragmente hinzufügen. Die einfachste Wahl besteht darin, immer das mit der höchsten Wahrscheinlichkeit zu nehmen.</description>
  <content:encoded><![CDATA[<p>Das Modell kann mehrere unterschiedliche Fragmente hinzufügen. Die einfachste Wahl besteht darin, immer das mit der höchsten Wahrscheinlichkeit zu nehmen. Das erspart die Betrachtung von Alternativen, aber führt der beste erste Schritt zur besten gesamten Folge?</p>
<p><strong>Greedy Decoding</strong> wählt in jedem Schritt das höchstbewertete <a href="https://paweldubiel.com/de/glossary/token">Token</a>, also ein Textstück, und setzt von dieser Entscheidung aus fort. Es zieht keine Zufallsstichprobe und kehrt nicht zu ausgelassenen Wegen zurück.</p>
<p>Wenn A eine Wahrscheinlichkeit von <code>0,6</code> und B von <code>0,4</code> hat, wählt es A. Hat aber der beste weitere Schritt nach A eine Wahrscheinlichkeit von <code>0,51</code>, liegt der gesamte Weg bei <code>0,306</code>. Der Weg über B mit einer Fortsetzung von <code>0,99</code> hat <code>0,396</code>. Der lokale Spitzenreiter kann also verlieren, wenn zwei Schritte gemeinsam bewertet werden.</p>
<p>Die Methode ist einfach, garantiert aber weder die wahrscheinlichste gesamte Sequenz noch die beste Antwort für einen Menschen. <a href="https://paweldubiel.com/de/glossary/beam-search">Beam Search</a> behält mehr Wege und verursacht zusätzliche Kosten.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Die Regel beschreibt die <a href="https://huggingface.co/docs/transformers/generation_strategies#greedy-search" rel="noopener noreferrer">Hugging-Face-Dokumentation, „Greedy search“</a>. Mathematisch wählen wir <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>arg</mi><mo>⁡</mo><msub><mrow><mi>max</mi><mo>⁡</mo></mrow><mi>v</mi></msub><mi>p</mi><mo stretchy="false">(</mo><mi>v</mi><mo>∣</mo><msub><mi>x</mi><mrow><mo>&#x3C;</mo><mi>t</mi></mrow></msub><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\arg\max_v p(v\mid x_{&#x3C;t})</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">ar<span style="margin-right:0.0139em;">g</span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop"><span class="mop">max</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1514em;"><span style="top:-2.55em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0359em;">v</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">∣</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mrel mtight">&#x3C;</span><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1774em;"><span></span></span></span></span></span></span><span class="mclose">)</span></span></span></span>: Aus den Tokens <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>v</mi></mrow><annotation encoding="application/x-tex">v</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">v</span></span></span></span> nehmen wir das Maximum bei der bisherigen Folge <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mrow><mo>&#x3C;</mo><mi>t</mi></mrow></msub></mrow><annotation encoding="application/x-tex">x_{&#x3C;t}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6079em;vertical-align:-0.1774em;"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mrel mtight">&#x3C;</span><span class="mord mathnormal mtight">t</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1774em;"><span></span></span></span></span></span></span></span></span></span>. Ein Gleichstand erfordert eine festgelegte Entscheidungsregel. Der Verzicht auf Zufallsziehung verspricht kein identisches Ergebnis, wenn sich Modell, Berechnungen oder Konfiguration ändern.</p>
<h2 id="der-lokale-gewinner-kann-bei-der-gesamten-sequenz-verlieren">Der lokale Gewinner kann bei der gesamten Sequenz verlieren</h2>
<p>Das eigene Beispiel hat genau zwei Schritte. Anfangs hat A die Wahrscheinlichkeit 0,6 und B 0,4. Nach A hat die beste Fortsetzung eine Chance von 0,51, nach B von 0,99. Greedy wählt A und anschließend dessen beste Fortsetzung: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,6</mn><mo>⋅</mo><mn>0,51</mn><mo>=</mo><mn>0,306</mn></mrow><annotation encoding="application/x-tex">0{,}6\cdot0{,}51=0{,}306</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">6</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">51</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">306</span></span></span></span>. Der übergangene Pfad über B hat jedoch <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,4</mn><mo>⋅</mo><mn>0,99</mn><mo>=</mo><mn>0,396</mn></mrow><annotation encoding="application/x-tex">0{,}4\cdot0{,}99=0{,}396</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">99</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">396</span></span></span></span>. Alle angegebenen Verteilungen sind erfunden und summieren sich zu 1; nach zwei Tokens ist Schluss.</p>
<div id="greedy-choice-lab"></div>
<p><a href="https://paweldubiel.com/de/glossary/beam-search">Beam Search</a> behält mehrere Teilsequenzen, um eine solche Entscheidung aufzuschieben. <a href="https://paweldubiel.com/de/glossary/top-k-sampling">Top-k-Sampling</a> begrenzt dagegen die Kandidaten für das Ziehen des nächsten Tokens. Bei einem eindeutigen Maximum und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> entspricht die Tokenauswahl Greedy.</p>
<p>Der wahrscheinlichste Text muss weder wahr noch nützlich sein. <a href="https://arxiv.org/html/1904.09751v2#S3" rel="noopener noreferrer">Holtzman et al., §2.2–3</a> trennen die Maximierung der Wahrscheinlichkeit von der Qualität offener Fortsetzungen. Das ist ein anderes Problem als der oben gezeigte Suchfehler.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Grouped-Query Attention</title>
  <link>https://paweldubiel.com/de/glossary/grouped-query-attention</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/grouped-query-attention</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Das Modell liest früheren Text auf mehrere Arten parallel. Jede solche Berechnung ist ein Attention-Kopf, also ein Aufmerksamkeitskopf.</description>
  <content:encoded><![CDATA[<p>Das Modell liest früheren Text auf mehrere Arten parallel. Jede solche Berechnung ist ein Attention-Kopf, also ein Aufmerksamkeitskopf. Du möchtest den Speicherbedarf dieser Köpfe verringern, aber die vollständige gemeinsame Nutzung eines einzigen Datensatzes könnte das Modell zu stark einschränken. Möglich ist eine Zwischenvariante: Manche Köpfe nutzen einen gemeinsamen Satz, andere einen anderen.</p>
<p><strong>Grouped-Query Attention (GQA)</strong> unterteilt Query-Köpfe in Gruppen, die Key und Value gemeinsam nutzen. Query ist eine numerische Beschreibung zum Lesen des Kontexts, Key zum Abgleich und Value zur Weitergabe von Informationen. Jeder Kopf berechnet weiterhin seine eigenen Anteile.</p>
<p>Acht Query-Köpfe, aufgeteilt in zwei Gruppen mit je vier Köpfen, bedeuten zwei Key/Value-Sätze statt acht. Eine einzige Gruppe ergibt <a href="https://paweldubiel.com/de/glossary/multi-query-attention">MQA</a>; eine Gruppe pro Kopf entspricht gewöhnlichem <a href="https://paweldubiel.com/de/glossary/multi-head-attention">MHA</a>.</p>
<p>Weniger Sätze verringern bei passenden Dimensionen die Speicherkosten für KV. Das ist ein Kompromiss zwischen Konstruktion und Qualität, kein Schalter, der eine bestimmte Geschwindigkeit garantiert. Die Laufzeit hängt auch von der Hardware und den übrigen Berechnungen ab.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Für <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>H</mi></mrow><annotation encoding="application/x-tex">H</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span></span></span></span> Query-Köpfe und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi></mrow><annotation encoding="application/x-tex">G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span></span></span></span> Gruppen erhalten wir <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi></mrow><annotation encoding="application/x-tex">G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span></span></span></span> K/V-Sätze. Bei <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">G=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> ist dies <a href="https://paweldubiel.com/de/glossary/multi-query-attention">Multi-Query Attention</a>. Bei <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo>=</mo><mi>H</mi></mrow><annotation encoding="application/x-tex">G=H</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span></span></span></span> kehren wir zu <a href="https://paweldubiel.com/de/glossary/multi-head-attention">Multi-Head Attention</a> zurück. Diese Familie und die Bezeichnung GQA-g beschreiben <a href="https://arxiv.org/html/2305.13245v3#S2.SS2" rel="noopener noreferrer">Ainslie et al., <em>GQA</em>, §2.2</a>.</p>
<h2 id="berechne-den-speicher-bevor-du-die-geschwindigkeit-schätzt">Berechne den Speicher, bevor du die Geschwindigkeit schätzt</h2>
<p>Die eigene Berechnung für den <a href="https://paweldubiel.com/de/glossary/kv-cache">KV Cache</a> nimmt Batchgröße 1, 32 Schichten, 1024 gespeicherte <a href="https://paweldubiel.com/de/glossary/token">Tokens</a>, die Dimension 128 für jeden Key/Value-Kopf und 2 Byte pro Zahl an. Die K/V-Elemente allein belegen:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mn>2</mn><mo>⋅</mo><mn>32</mn><mo>⋅</mo><mn>1024</mn><mo>⋅</mo><mi>G</mi><mo>⋅</mo><mn>128</mn><mo>⋅</mo><mn>2</mn><mtext> Byte</mtext></mrow><annotation encoding="application/x-tex">2\cdot32\cdot1024\cdot G\cdot128\cdot2\ \text{Byte}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">32</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1024</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6833em;"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">128</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord">2</span><span class="mspace"> </span><span class="mord text"><span class="mord">Byte</span></span></span></span></span></span>
<p>Die erste Zwei steht für K und V. Bei acht Query-Köpfen ergibt sich 128 MiB für MHA, 32 MiB für zwei KV-Köpfe und 16 MiB für MQA. Ein MiB sind <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msup><mn>2</mn><mn>20</mn></msup></mrow><annotation encoding="application/x-tex">2^{20}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8141em;"></span><span class="mord"><span class="mord">2</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">20</span></span></span></span></span></span></span></span></span></span></span></span> Byte. Modellgewichte, Puffer, Speicherausrichtung und Replikation zwischen Geräten zählen wir nicht mit.</p>
<div id="gqa-groups-lab"></div>
<p>Die Verringerung der KV-Kopfanzahl verkürzt hier weder den Kontext noch entfernt sie Query-Köpfe. Sie begrenzt die Zahl separater K/V-Repräsentationen. Die Speicherrechnung sagt weder Qualität noch Laufzeit voraus; beide hängen auch von Training, Hardware und Implementierung ab.</p>
<p>Bei der Checkpoint-Konvertierung mittelten die Autoren die K/V-Projektionen innerhalb der Gruppen und setzten danach das <a href="https://paweldubiel.com/de/glossary/pre-training">Pre-Training</a> fort (§2.1–2.2). Die Ergebnisse in §3 betreffen konkrete T5-Varianten und Aufgaben. Sie bestimmen weder eine universelle Gruppenanzahl noch garantieren sie Qualitätserhalt beim bloßen Umstellen der Konfiguration.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Multi-Query Attention</title>
  <link>https://paweldubiel.com/de/glossary/multi-query-attention</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/multi-query-attention</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Das Modell verbindet das aktuelle Textfragment über mehrere parallele Berechnungen mit dem früheren Gespräch. Solche Berechnungen heißen Attention-Köpfe, also Aufmerksamkeitsköpfe.</description>
  <content:encoded><![CDATA[<p>Das Modell verbindet das aktuelle Textfragment über mehrere parallele Berechnungen mit dem früheren Gespräch. Solche Berechnungen heißen Attention-Köpfe, also Aufmerksamkeitsköpfe. Wenn jeder Kopf seine eigenen Beschreibungen des gesamten früheren Gesprächs speichert, steigen der Speicherbedarf und die Kosten des Auslesens. Lassen sich einige Daten gemeinsam nutzen, während unterschiedliche Arten des Auslesens erhalten bleiben?</p>
<p><strong>Multi-Query Attention (MQA)</strong> behält viele Queries — Beschreibungen des Bedarfs der aktuellen Positionen —, gibt ihnen aber einen gemeinsamen Satz von Key und Value. Key dient dem Abgleich, Value enthält weiterzugebende Informationen. Alle sind Listen von Zahlen.</p>
<p>Zwei Köpfe können denselben Key/Value-Satz nutzen und trotzdem die Anteile anders verteilen, weil sie unterschiedliche Queries haben. Gemeinsame Daten erzwingen kein identisches Ergebnis.</p>
<p>Die Einsparung betrifft unter anderem den <a href="https://paweldubiel.com/de/glossary/kv-cache">KV Cache</a>, also gespeicherte Beschreibungen früheren Textes. Die Änderung kann jedoch die Qualität beeinflussen und bedeutet keine proportionale Beschleunigung des gesamten Modells. <a href="https://paweldubiel.com/de/glossary/grouped-query-attention">Grouped-Query Attention</a> nutzt die gemeinsame Verwendung innerhalb kleinerer Gruppen.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Bei gewöhnlicher <a href="https://paweldubiel.com/de/glossary/multi-head-attention">Multi-Head Attention</a> hat jeder Kopf eigene Query-, Key- und Value-Projektionen. MQA entfernt die Kopfdimension aus K/V und deren Projektionen und erhält sie für Query. So definiert <a href="https://arxiv.org/html/1911.02150v1#S3" rel="noopener noreferrer">Noam Shazeer, <em>Fast Transformer Decoding: One Write-Head is All You Need</em>, §3</a> diese Variante.</p>
<h2 id="gleicher-speicher-andere-frage">Gleicher Speicher, andere Frage</h2>
<p>Das eigene Beispiel hat zwei Schlüssel: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>1</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">k_1=(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0315em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>k</mi><mn>2</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">k_2=(0,1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0315em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span>. Zwei Query-Köpfe erhalten jeweils <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mn>1</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>2</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q_1=(2,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">2</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mn>2</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>2</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q_2=(0,2)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">2</span><span class="mclose">)</span></span></span></span>. <a href="https://paweldubiel.com/de/glossary/scaled-dot-product-attention">Scaled Dot-Product Attention</a> teilt die Produkte durch <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msqrt><mn>2</mn></msqrt></mrow><annotation encoding="application/x-tex">\sqrt{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.04em;vertical-align:-0.1328em;"></span><span class="mord sqrt"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.9072em;"><span class="svg-align" style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord" style="padding-left:0.833em;"><span class="mord">2</span></span></span><span style="top:-2.8672em;"><span class="pstrut" style="height:3em;"></span><span class="hide-tail" style="min-width:0.853em;height:1.08em;"><svg xmlns="http://www.w3.org/2000/svg" width="400em" height="1.08em" viewBox="0 0 400000 1080" preserveAspectRatio="xMinYMin slice"><path d="M95,702
c-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14
c0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54
c44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10
s173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429
c69,-144,104.5,-217.7,106.5,-221
l0 -0
c5.3,-9.3,12,-14,20,-14
H400000v40H845.2724
s-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7
c-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z
M834 80h400000v40h-400000z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.1328em;"><span></span></span></span></span></span></span></span></span> und wendet <a href="https://paweldubiel.com/de/glossary/softmax">Softmax</a> an. Der erste Kopf gibt den Schlüsseln Gewichte von etwa 0,804 und 0,196; der zweite kehrt diese Anteile um. Bei gemeinsamen <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>1</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">v_1=(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>2</mn></msub><mo>=</mo><mo stretchy="false">(</mo><mn>0</mn><mo separator="true">,</mo><mn>1</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">v_2=(0,1)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">v</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3011em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">1</span><span class="mclose">)</span></span></span></span> sind dies zugleich die Koordinaten zweier unterschiedlicher Ergebnisse.</p>
<div id="mqa-shared-lab"></div>
<h2 id="woher-die-einsparung-kommt">Woher die Einsparung kommt</h2>
<p>Der <a href="https://paweldubiel.com/de/glossary/kv-cache">KV-Cache</a> speichert frühere K/V. Bei acht Query-Köpfen speichert MHA acht K/V-Sätze, MQA einen. Bei gleicher Sequenzlänge, Kopfdimension und Präzision sind die Cachetensoren dann achtmal kleiner. Das ist eine Größenberechnung, keine achtfache Beschleunigung des gesamten Modells.</p>
<p>Shazeers Analyse in §2.4.1 und §3.1 verbindet diese Änderung mit dem Speichertransfer während aufeinanderfolgender Generierungsschritte. Allerdings verändern sich Architektur und Repräsentationsmöglichkeiten. Es handelt sich nicht um das verlustfreie Entfernen identischer Kopien aus einem beliebigen trainierten MHA. <a href="https://paweldubiel.com/de/glossary/grouped-query-attention">Grouped-Query Attention</a> behält als Zwischenvariante mehrere K/V-Sätze.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>Rotary Position Embedding</title>
  <link>https://paweldubiel.com/de/glossary/rotary-position-embedding</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/rotary-position-embedding</guid>
  <pubDate>Fri, 18 Sep 2026 06:30:24 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Das Modell vergleicht Textfragmente, muss aber auch wissen, wie weit sie voneinander entfernt liegen.</description>
  <content:encoded><![CDATA[<p>Das Modell vergleicht Textfragmente, muss aber auch wissen, wie weit sie voneinander entfernt liegen. „Gestern“ neben einem Verb kann eine andere Rolle spielen als dasselbe Wort in einem entfernten Zitat. Wie lässt sich die Position in den Vergleich numerischer Beschreibungen einbeziehen?</p>
<p><strong>Rotary Position Embedding (RoPE)</strong> dreht Zahlenpaare in Query und Key entsprechend der Position des <a href="https://paweldubiel.com/de/glossary/token">Tokens</a>, also eines Textstücks. Query und Key sind Vektoren — Listen von Zahlen, die in Attention verglichen werden.</p>
<p>Stell dir zwei Pfeile mit bestimmten Längen vor. Die Position legt ihren Drehwinkel fest. Beim Vergleich zählt der Unterschied der Winkel und damit der Unterschied der Positionen. Im tatsächlichen Modell werden viele Paare mit unterschiedlichen Frequenzen gedreht.</p>
<p>Das ist eine Analogie für eine Operation auf Zahlen, keine Bewegung des Textes im Speicher. RoPE verbietet keinen Zugang zur Zukunft und garantiert kein gutes Verhalten jenseits der aus dem Training bekannten Längen. Es unterscheidet sich vom Hinzufügen eines Positionssignals im ursprünglichen <a href="https://paweldubiel.com/de/glossary/positionskodierung">Positional Encoding</a>.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Anders als beim Addieren eines Vektors in der ursprünglichen <a href="https://paweldubiel.com/de/glossary/positionskodierung">Positionskodierung</a> verändert sich hier die Orientierung von Query und Key. Für das zweidimensionale Paar <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo>=</mo><mo stretchy="false">(</mo><mi>a</mi><mo separator="true">,</mo><mi>b</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">u=(a,b)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">a</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">b</span><span class="mclose">)</span></span></span></span> ergibt eine Rotation um <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>ϕ</mi></mrow><annotation encoding="application/x-tex">\phi</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">ϕ</span></span></span></span>:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mi>R</mi><mo stretchy="false">(</mo><mi>ϕ</mi><mo stretchy="false">)</mo><mi>u</mi><mo>=</mo><mo stretchy="false">(</mo><mi>a</mi><mi>cos</mi><mo>⁡</mo><mi>ϕ</mi><mo>−</mo><mi>b</mi><mi>sin</mi><mo>⁡</mo><mi>ϕ</mi><mo separator="true">,</mo><mtext> </mtext><mi>a</mi><mi>sin</mi><mo>⁡</mo><mi>ϕ</mi><mo>+</mo><mi>b</mi><mi>cos</mi><mo>⁡</mo><mi>ϕ</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">R(\phi)u=(a\cos\phi-b\sin\phi,\ a\sin\phi+b\cos\phi)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">(</span><span class="mord mathnormal">ϕ</span><span class="mclose">)</span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">cos</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">sin</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mpunct">,</span><span class="mspace"> </span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">a</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">sin</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">b</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">cos</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">ϕ</span><span class="mclose">)</span></span></span></span></span>
<p>Die Rotation erhält die Vektorlänge. <a href="https://arxiv.org/html/2104.09864v5#S3.SS2" rel="noopener noreferrer">Su et al., <em>RoFormer</em>, §3.1–3.2</a> leiten die Konstruktion her und kombinieren viele solcher Paare mit unterschiedlichen Frequenzen.</p>
<h2 id="verschiebe-beide-tokens-und-prüfe-das-ergebnis">Verschiebe beide Tokens und prüfe das Ergebnis</h2>
<p>Bleiben die unrotierten Queries und Keys fest, gilt:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mo stretchy="false">(</mo><mi>R</mi><mo stretchy="false">(</mo><mi>m</mi><mi>θ</mi><mo stretchy="false">)</mo><mi>q</mi><msup><mo stretchy="false">)</mo><mi mathvariant="normal">⊤</mi></msup><mi>R</mi><mo stretchy="false">(</mo><mi>n</mi><mi>θ</mi><mo stretchy="false">)</mo><mi>k</mi><mo>=</mo><msup><mi>q</mi><mi mathvariant="normal">⊤</mi></msup><mi>R</mi><mo stretchy="false">(</mo><mo stretchy="false">(</mo><mi>n</mi><mo>−</mo><mi>m</mi><mo stretchy="false">)</mo><mi>θ</mi><mo stretchy="false">)</mo><mi>k</mi></mrow><annotation encoding="application/x-tex">(R(m\theta)q)^\top R(n\theta)k=q^\top R((n-m)\theta)k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.1491em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">(</span><span class="mord mathnormal">m</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8991em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">⊤</span></span></span></span></span></span></span></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">(</span><span class="mord mathnormal">n</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1.1491em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8991em;"><span style="top:-3.113em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">⊤</span></span></span></span></span></span></span></span><span class="mord mathnormal" style="margin-right:0.0077em;">R</span><span class="mopen">((</span><span class="mord mathnormal">n</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal">m</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>m</mi></mrow><annotation encoding="application/x-tex">m</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">m</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi></mrow><annotation encoding="application/x-tex">n</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em;"></span><span class="mord mathnormal">n</span></span></span></span> sind Positionen; <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi></mrow><annotation encoding="application/x-tex">\theta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span></span></span></span> ist der Winkel pro Abstandseinheit für das jeweilige Paar. Das Ergebnis hängt von der Positionsdifferenz ab. Eine gemeinsame Verschiebung beider Positionen dreht die Pfeile, erhält aber ihr Skalarprodukt.</p>
<p>Das eigene Beispiel verwendet <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><mi>k</mi><mo>=</mo><mo stretchy="false">(</mo><mn>1</mn><mo separator="true">,</mo><mn>0</mn><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">q=k=(1,0)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">(</span><span class="mord">1</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mclose">)</span></span></span></span> und ein angenommenes <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi><mo>=</mo><msup><mn>30</mn><mo>∘</mo></msup></mrow><annotation encoding="application/x-tex">\theta=30^\circ</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6741em;"></span><span class="mord">3</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.6741em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mbin mtight">∘</span></span></span></span></span></span></span></span></span></span></span>. Bei Abstand 1 beträgt das Produkt ungefähr 0,866, bei 6 ist es −1 und bei 12 wieder 1. Dies ist ein einzelnes Paar mit bewusst einfacher Frequenz, keine vollständige Modellrezeptur. Die Originalarbeit verwendet für das Paar mit Index <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi><mo>=</mo><mn>0</mn><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><mi>d</mi><mi mathvariant="normal">/</mi><mn>2</mn><mo>−</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">i=0,\ldots,d/2-1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">d</span><span class="mord">/2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> den Wert <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>θ</mi><mi>i</mi></msub><mo>=</mo><msup><mn>10000</mn><mrow><mo>−</mo><mn>2</mn><mi>i</mi><mi mathvariant="normal">/</mi><mi>d</mi></mrow></msup></mrow><annotation encoding="application/x-tex">\theta_i=10000^{-2i/d}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">θ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.888em;"></span><span class="mord">1000</span><span class="mord"><span class="mord">0</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.888em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">2</span><span class="mord mathnormal mtight">i</span><span class="mord mtight">/</span><span class="mord mathnormal mtight">d</span></span></span></span></span></span></span></span></span></span></span></span> Radiant.</p>
<div id="rope-rotation-lab"></div>
<p>Das gezeigte Ergebnis ist ein Bestandteil der <a href="https://paweldubiel.com/de/glossary/scaled-dot-product-attention">Scaled Dot-Product Attention</a> vor Skalierung und <a href="https://paweldubiel.com/de/glossary/softmax">Softmax</a>. Es ist keine Wahrscheinlichkeit. In dieser Variante rotieren wir Q und K; V benötigt diese Rotation nicht. RoPE ersetzt keine <a href="https://paweldubiel.com/de/glossary/kausale-maskierung">kausale Maskierung</a>.</p>
<p>Die Rückkehr eines einzelnen Paares zur gleichen Orientierung zeigt auch, warum nicht angenommen werden darf, dass jeder Wert mit dem Abstand monoton abnimmt. Die Eigenschaft relativer Positionen allein beweist keine korrekte Funktion des gesamten Modells für beliebig lange Texte.</p>
<p>Ich verwende KI-generierte Inhalte als Teil meines täglichen Lernprozesses.</p>]]></content:encoded>
</item>
<item>
  <title>KL-Divergenz</title>
  <link>https://paweldubiel.com/de/glossary/kl-divergenz</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/kl-divergenz</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Zwei Modelle verteilen die Wahrscheinlichkeiten unterschiedlich auf dieselben Antworten. Eines setzt 90% auf A und 10% auf B, das andere gibt beiden 50%.</description>
  <content:encoded><![CDATA[<p>Zwei Modelle verteilen die Wahrscheinlichkeiten unterschiedlich auf dieselben Antworten. Eines setzt <code>90%</code> auf A und <code>10%</code> auf B, das andere gibt beiden <code>50%</code>. Du möchtest messen, wie gut das zweite die Vorhersagen des ersten nachbildet.</p>
<p><strong>KL Divergence</strong> vergleicht zwei Wahrscheinlichkeitsverteilungen, also Sätze von Wahrscheinlichkeiten derselben Ereignisse. Die Referenzverteilung und die Verteilung, die sie annähert, müssen angegeben werden. Der Beitrag jedes Ereignisses hängt von seiner Wahrscheinlichkeit in der Referenzverteilung und vom Verhältnis der beiden Wahrscheinlichkeiten ab.</p>
<p>Für diese Zahlen beträgt der Vergleich der ersten mit der zweiten etwa <code>0,368</code>, der umgekehrte etwa <code>0,511</code>, jeweils mit dem natürlichen Logarithmus. Die Richtung zählt: Es ist keine symmetrische Entfernung wie die Kilometerzahl zwischen Städten.</p>
<p>Bei <a href="https://paweldubiel.com/de/glossary/wissensdestillation">Knowledge Distillation</a> lassen sich die Vorhersagen des Lehrers und des Schülers vergleichen. Ein kleines KL bedeutet ihre Übereinstimmung, nicht die Wahrheit des Lehrers. Einem Ereignis mit positiver Wahrscheinlichkeit in der Referenzverteilung die Wahrscheinlichkeit null zuzuweisen, ergibt mathematisch eine unendliche Strafe.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><msub><mi>D</mi><mrow><mi mathvariant="normal">K</mi><mi mathvariant="normal">L</mi></mrow></msub><mo stretchy="false">(</mo><mi>q</mi><mi mathvariant="normal">∥</mi><mi>p</mi><mo stretchy="false">)</mo><mo>=</mo><munder><mo>∑</mo><mi>i</mi></munder><msub><mi>q</mi><mi>i</mi></msub><mi>ln</mi><mo>⁡</mo><mfrac><msub><mi>q</mi><mi>i</mi></msub><msub><mi>p</mi><mi>i</mi></msub></mfrac></mrow><annotation encoding="application/x-tex">D_{\mathrm{KL}}(q\|p)=\sum_i q_i\ln\frac{q_i}{p_i}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">D</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathrm mtight">KL</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mord">∥</span><span class="mord mathnormal">p</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:2.3852em;vertical-align:-1.2777em;"></span><span class="mop op-limits"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.05em;"><span style="top:-1.8723em;margin-left:0em;"><span class="pstrut" style="height:3.05em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span><span style="top:-3.05em;"><span class="pstrut" style="height:3.05em;"></span><span><span class="mop op-symbol large-op">∑</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:1.2777em;"><span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.1076em;"><span style="top:-2.314em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.677em;"><span class="pstrut" style="height:3em;"></span><span class="mord"><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.8804em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">q_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>p</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">p_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span> sind die Wahrscheinlichkeiten desselben Ereignisses <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>i</mi></mrow><annotation encoding="application/x-tex">i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6595em;"></span><span class="mord mathnormal">i</span></span></span></span>, etwa eines bestimmten <a href="https://paweldubiel.com/de/glossary/token">Tokens</a>. Die Formel und ihre Beziehung zu <a href="https://paweldubiel.com/de/glossary/kreuzentropie">Cross-entropy</a> beschreibt die <a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.entropy.html" rel="noopener noreferrer">SciPy-Dokumentation: entropy</a>. Es gilt <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>D</mi><mrow><mi mathvariant="normal">K</mi><mi mathvariant="normal">L</mi></mrow></msub><mo stretchy="false">(</mo><mi>q</mi><mi mathvariant="normal">∥</mi><mi>p</mi><mo stretchy="false">)</mo><mo>=</mo><mi>H</mi><mo stretchy="false">(</mo><mi>q</mi><mo separator="true">,</mo><mi>p</mi><mo stretchy="false">)</mo><mo>−</mo><mi>H</mi><mo stretchy="false">(</mo><mi>q</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">D_{\mathrm{KL}}(q\|p)=H(q,p)-H(q)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0278em;">D</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em;"><span style="top:-2.55em;margin-left:-0.0278em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathrm mtight">KL</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mord">∥</span><span class="mord mathnormal">p</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord mathnormal">p</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord mathnormal" style="margin-right:0.0813em;">H</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mclose">)</span></span></span></span>: Von der Cross-entropy ziehen wir die Entropie der Referenzverteilung ab. Wenn <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi></mrow><annotation encoding="application/x-tex">q</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span></span></span></span> konstant ist, verändert diese Differenz das Minimum bezüglich der Modellparameter, die <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> bestimmen, nicht.</p>
<h2 id="die-vergleichsrichtung-zählt">Die Vergleichsrichtung zählt</h2>
<p>Eigenes Beispiel: Für <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>q</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,9</mn><mo separator="true">;</mo><mn>0,1</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">q=[0{,}9;0{,}1]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">9</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">1</span><span class="mclose">]</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mo stretchy="false">[</mo><mn>0,5</mn><mo separator="true">;</mo><mn>0,5</mn><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">p=[0{,}5;0{,}5]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">[</span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mpunct">;</span><span class="mspace" style="margin-right:0.1667em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">5</span><span class="mclose">]</span></span></span></span> erhalten wir ungefähr 0,368. Vertauschen wir die Rollen der Verteilungen, beträgt das Ergebnis ungefähr 0,511. Wir verwenden den natürlichen Logarithmus; die Einheit ist daher Nat. KL-Divergenz ist kein symmetrischer Abstand. Es muss immer angegeben werden, welche Verteilung auf welcher Seite steht.</p>
<p>Ist <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mi>i</mi></msub><mo>></mo><mn>0</mn></mrow><annotation encoding="application/x-tex">q_i>0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7335em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>, aber <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>p</mi><mi>i</mi></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">p_i=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal">p</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span>, ist das Ergebnis unendlich. Ein Term mit <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>q</mi><mi>i</mi></msub><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">q_i=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0359em;">q</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3117em;"><span style="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">i</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">0</span></span></span></span> wird als null definiert. Diese Randfälle definiert <a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.rel_entr.html" rel="noopener noreferrer">SciPy: rel_entr</a>.</p>
<p>Bei der <a href="https://paweldubiel.com/de/glossary/wissensdestillation">Wissensdestillation</a> kann die Lehrervorhersage als Referenzverteilung und die Schülervorhersage als Näherung dienen. Ein kleiner Wert beschreibt die Übereinstimmung dieser Verteilungen auf den bewerteten Daten, nicht den Wahrheitsgehalt der Lehrerantworten.</p>
<p>Bei der Implementierung muss die Argumentreihenfolge beachtet werden. <a href="https://docs.pytorch.org/docs/2.11/generated/torch.nn.KLDivLoss.html#torch.nn.KLDivLoss" rel="noopener noreferrer">PyTorch: KLDivLoss</a> erwartet als <code>input</code> die logarithmischen Modellwahrscheinlichkeiten und bei <code>log_target=False</code> als <code>target</code> die Referenzverteilung. Für eine Matrix „Beispiele × Klassen“ summiert <code>batchmean</code> die Terme über Klassen und mittelt über Beispiele; <code>mean</code> mittelt alle Elemente und liefert dadurch eine andere Skala.</p>
<div id="kl-divergence-lab"></div>]]></content:encoded>
</item>
<item>
  <title>KV-Cache</title>
  <link>https://paweldubiel.com/de/glossary/kv-cache</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/kv-cache</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Das Modell ergänzt die Antwort Stück für Stück. Viele Informationen über den früheren Text hat es bereits berechnet; sie in jedem Schritt von Grund auf neu zu berechnen würde Arbeit wiederholen.</description>
  <content:encoded><![CDATA[<p>Das Modell ergänzt die Antwort Stück für Stück. Viele Informationen über den früheren Text hat es bereits berechnet; sie in jedem Schritt von Grund auf neu zu berechnen würde Arbeit wiederholen. Du möchtest die weiterhin gültigen Ergebnisse speichern.</p>
<p><strong>KV Cache</strong> speichert Key und Value aus den Attention-Schichten. Das sind Listen von Zahlen, die dem Abgleich von Fragmenten beziehungsweise der Weitergabe ihrer Informationen dienen. Der Cache speichert weder eine fertige Antwort noch eine Zusammenfassung des Gesprächs.</p>
<p>Nach der Verarbeitung von A, B und C nutzt das neue Fragment D die gespeicherten Beschreibungen dieser Positionen und fügt seine eigenen hinzu. In einem Modell mit gesperrtem Zugang zur Zukunft verändern neue Fragmente die früheren Beschreibungen nicht; bei übereinstimmenden Einstellungen können sie deshalb wiederverwendet werden.</p>
<p>Wir sparen wiederholte Berechnungen, bezahlen aber mit Speicher für die aufbewahrten Zahlen. Bei langem Kontext steigt dieser Aufwand. <a href="https://paweldubiel.com/de/glossary/prefill">Prefill</a> bereitet den Cache der bekannten Eingabe vor, während <a href="https://paweldubiel.com/de/glossary/decode">Decode</a> ihn während der Antwort ergänzt. Benötigte Informationen müssen weiterhin gelesen und vermischt werden.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>In einem Modell mit <a href="https://paweldubiel.com/de/glossary/kausale-maskierung">Causal Masking</a> verändern spätere <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> die Repräsentationen früherer Positionen nicht. Das erlaubt die Wiederverwendung des Caches für dasselbe Präfix und dieselben Modelleinstellungen. Die Grundlage des Informationsflusses beschreibt <a href="https://arxiv.org/html/1706.03762v7#S3.SS1" rel="noopener noreferrer"><em>Attention Is All You Need</em>, §3.1 und §3.2.3</a>, die Aktualisierung des Caches in jeder Schicht die <a href="https://huggingface.co/docs/transformers/cache_explanation" rel="noopener noreferrer">Hugging-Face-Dokumentation: How caching works</a>.</p>
<h2 id="was-vom-vorherigen-schritt-bleibt">Was vom vorherigen Schritt bleibt</h2>
<p>Eigene Illustration: Das Modell hat A, B und C verarbeitet. Bei der Verarbeitung von D nutzt es die gespeicherten K und V der drei vorherigen Positionen und ergänzt das Paar für D. Das Query der aktuellen Position wird mit verfügbaren Keys verglichen; das Ergebnis verwendet die entsprechenden Values. Der Cache ist weder eine fertige Antwort noch eine Textzusammenfassung der Unterhaltung.</p>
<p>Das Speichern von Ergebnissen kostet Ressourcen. Eigenes kleines Beispiel für eine Schicht: vier Positionen, zwei KV-Köpfe, jeweils drei Zahlen pro K- und V-Vektor und vier Byte pro Zahl:</p>
<span class="katex-display"><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML" display="block"><semantics><mrow><mn>2</mn><mo>⋅</mo><mn>4</mn><mo>⋅</mo><mn>2</mn><mo>⋅</mo><mn>3</mn><mo>⋅</mo><mn>4</mn><mo>=</mo><mn>192</mn><mtext> Byte</mtext></mrow><annotation encoding="application/x-tex">2\cdot4\cdot2\cdot3\cdot4=192\ \text{Byte}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">3</span><span class="mspace" style="margin-right:0.2222em;"></span><span class="mbin">⋅</span><span class="mspace" style="margin-right:0.2222em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">4</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8778em;vertical-align:-0.1944em;"></span><span class="mord">192</span><span class="mspace"> </span><span class="mord text"><span class="mord">Byte</span></span></span></span></span></span>
<p>Der erste Faktor 2 steht für getrennte Keys und Values. Das Ergebnis umfasst nur die Tensorelemente ohne Allokationsaufwand. Ein vollständiger dynamischer Cache wächst mit der Zahl gespeicherter Positionen; Varianten mit begrenztem Fenster können ältere Positionen entfernen.</p>
<p>Ein älterer <a href="https://paweldubiel.com/en/articles/kv-cache-scaling-problem-in-llm-inference" hreflang="en">Artikel über die Skalierung des KV-Caches [English]</a> vertieft die Speicherkosten. Der <a href="https://paweldubiel.com/articles/kv-cache-miedzy-modelami-nvidia-zmniejsza-koszt-przelaczania" hreflang="pl">Artikel über Cache-Übertragung zwischen Modellen [Polski]</a> behandelt ein separates Problem: Übereinstimmende Tensordimensionen gewährleisten keine übereinstimmende Bedeutung. Bei einer Änderung des Modells oder Präfixes muss erneut bestimmt werden, welcher Cacheteil gültig bleibt. Siehe auch: <a href="https://paweldubiel.com/de/glossary/pagedattention">PagedAttention</a> beschreibt eine blockweise Speicherorganisation, <a href="https://paweldubiel.com/de/glossary/prefix-caching">Prefix Caching</a> die Wiederverwendung von KV für ein gemeinsames Präfix.</p>
<div id="kv-cache-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Top-k-Sampling</title>
  <link>https://paweldubiel.com/de/glossary/top-k-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/top-k-sampling</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Bei der zufälligen Auswahl des nächsten Fragments lässt das Modell viele sehr unwahrscheinliche Möglichkeiten zu. Du möchtest etwas Vielfalt behalten, aber den fernen Rand der Kandidaten entfernen.</description>
  <content:encoded><![CDATA[<p>Bei der zufälligen Auswahl des nächsten Fragments lässt das Modell viele sehr unwahrscheinliche Möglichkeiten zu. Du möchtest etwas Vielfalt behalten, aber den fernen Rand der Kandidaten entfernen. Du kannst nur eine festgelegte Zahl von Spitzenreitern zulassen.</p>
<p><strong>Top-k Sampling</strong> zieht das nächste <a href="https://paweldubiel.com/de/glossary/token">Token</a>, also ein Textstück, aus den <code>k</code> höchstbewerteten Kandidaten. Es schließt die übrigen aus und rechnet die Wahrscheinlichkeiten der behaltenen Kandidaten auf die Summe eins um.</p>
<p>Wenn A die Wahrscheinlichkeit <code>0,5</code>, B <code>0,3</code> und die übrigen zusammen <code>0,2</code> haben, bleiben bei <code>k=2</code> A und B. Nach Division durch <code>0,8</code> betragen ihre Wahrscheinlichkeiten <code>0,625</code> und <code>0,375</code>. B kann weiterhin gewinnen; die Methode gibt nicht allen gleich viel.</p>
<p>Ein festes <code>k</code> bestimmt die Zahl der Kandidaten, nicht ihre gemeinsame Verlässlichkeit. Bei einer sehr flachen Verteilung können sogar die Spitzenreiter geringe Wahrscheinlichkeiten haben. <a href="https://paweldubiel.com/de/glossary/top-p-sampling">Top-p Sampling</a> bestimmt die Menge anhand der Summe der Wahrscheinlichkeiten, während <a href="https://paweldubiel.com/de/glossary/temperatur">Temperature</a> ihre Verhältnisse regelt.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Eine praktische Implementierung kann die Logits bereits vor <a href="https://paweldubiel.com/de/glossary/softmax">Softmax</a> filtern: Den verworfenen Positionen wird negative Unendlichkeit zugewiesen. Nach der Normalisierung beträgt ihre Wahrscheinlichkeit dann null. Diesen Mechanismus beschreibt die <a href="https://huggingface.co/docs/transformers/internal/generation_utils#transformers.TopKLogitsWarper" rel="noopener noreferrer">Dokumentation von Transformers: TopKLogitsWarper</a>.</p>
<h2 id="zwei-kandidaten-bedeuten-keine-gleichen-chancen">Zwei Kandidaten bedeuten keine gleichen Chancen</h2>
<p>Eigenes Beispiel für <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>2</mn></mrow><annotation encoding="application/x-tex">k=2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">2</span></span></span></span>:</p>






























<table><thead><tr><th>Token</th><th align="right">Vor dem Filtern</th><th align="right">Nach Filtern und Normalisierung</th></tr></thead><tbody><tr><td>A</td><td align="right">0,50</td><td align="right">0,625</td></tr><tr><td>B</td><td align="right">0,30</td><td align="right">0,375</td></tr><tr><td>C</td><td align="right">0,15</td><td align="right">0</td></tr><tr><td>D</td><td align="right">0,05</td><td align="right">0</td></tr></tbody></table>
<p>A und B hatten zusammen eine Wahrscheinlichkeit von 0,80. Wir teilen durch diese Summe: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,50</mn><mi mathvariant="normal">/</mi><mn>0,80</mn><mo>=</mo><mn>0,625</mn></mrow><annotation encoding="application/x-tex">0{,}50/0{,}80=0{,}625</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">50/0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">80</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">625</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>0,30</mn><mi mathvariant="normal">/</mi><mn>0,80</mn><mo>=</mo><mn>0,375</mn></mrow><annotation encoding="application/x-tex">0{,}30/0{,}80=0{,}375</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">30/0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">80</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">375</span></span></span></span>. Das Ziehen kann weiterhin B auswählen. Bei <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi><mo>=</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k=1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.6444em;"></span><span class="mord">1</span></span></span></span> und einem eindeutigen Maximum wählen wir immer das am höchsten bewertete Token.</p>
<p>Ein festes <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em;"></span><span class="mord mathnormal" style="margin-right:0.0315em;">k</span></span></span></span> kontrolliert die Anzahl der Kandidaten, nicht deren gemeinsame Wahrscheinlichkeit vor dem Abschneiden. Zwei erhaltene Positionen können nahezu die gesamte Verteilung oder nur einen kleinen Teil davon umfassen. <a href="https://paweldubiel.com/de/glossary/top-p-sampling">Top-p-Sampling</a> bestimmt die Grenze anhand der Summe der Wahrscheinlichkeiten. Die <a href="https://paweldubiel.com/de/glossary/temperatur">Temperatur</a> verändert die Chancenverhältnisse; eine positive Skalierung allein verändert die Reihenfolge endlicher Logits nicht.</p>
<p>Bei Gleichständen lohnt sich ein Blick auf die Implementierung. Der <a href="https://github.com/huggingface/transformers/blob/v5.17.0/src/transformers/generation/logits_process.py" rel="noopener noreferrer">Code von Transformers 5.17.0</a> entfernt Ergebnisse, die strikt unter dem Ergebnis des k-ten Kandidaten liegen. Er kann daher auch zusätzliche Tokens mit demselben Wert an der Grenze erhalten. Das Tabellenbeispiel enthält keine Gleichstände.</p>
<div id="top-k-sampling-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Top-p-Sampling</title>
  <link>https://paweldubiel.com/de/glossary/top-p-sampling</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/top-p-sampling</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Manchmal hat das Modell einen klaren Spitzenreiter, manchmal viele ähnlich bewertete Fortsetzungen. Stets fünf Kandidaten zuzulassen berücksichtigt diesen Unterschied nicht.</description>
  <content:encoded><![CDATA[<p>Manchmal hat das Modell einen klaren Spitzenreiter, manchmal viele ähnlich bewertete Fortsetzungen. Stets fünf Kandidaten zuzulassen berücksichtigt diesen Unterschied nicht. Du möchtest die Gruppengröße danach wählen, wo sich die Wahrscheinlichkeit konzentriert.</p>
<p><strong>Top-p Sampling</strong>, auch Nucleus Sampling, wählt die kleinste Anfangsgruppe der nach absteigender Wahrscheinlichkeit sortierten Kandidaten, deren Summe den Schwellenwert <code>p</code> erreicht. Anschließend zieht es aus dieser Gruppe, nachdem die Wahrscheinlichkeiten auf die Summe eins umgerechnet wurden.</p>
<p>Bei Wahrscheinlichkeiten von <code>0,7; 0,15; 0,1; 0,05</code> und einem Schwellenwert von <code>0,75</code> bleiben die ersten beiden: Zusammen haben sie <code>0,85</code>. Bei <code>0,4; 0,3; 0,2; 0,1</code> werden bereits drei benötigt. Jeder Generierungsschritt kann also eine andere Zahl zugelassener <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> — Textstücke — haben.</p>
<p>Der Schwellenwert bedeutet weder eine Mindestwahrscheinlichkeit jedes Kandidaten noch eine garantierte Antwortqualität. <a href="https://paweldubiel.com/de/glossary/top-k-sampling">Top-k Sampling</a> legt die Zahl fest, während top-p auf die Verteilung reagiert; keiner dieser Filter bewertet allein die Wahrheit des Textes.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>Methode und Normalisierung beschreiben <a href="https://arxiv.org/html/1904.09751v2#S3.SS1" rel="noopener noreferrer">Holtzman et al., <em>The Curious Case of Neural Text Degeneration</em>, §3.1</a>. In jedem Schritt der <a href="https://paweldubiel.com/de/glossary/autoregressive-sprachmodellierung">autoregressiven Sprachmodellierung</a> wird die Kandidatenmenge neu bestimmt.</p>
<h2 id="gleiche-schwelle-unterschiedliche-tokenanzahl">Gleiche Schwelle, unterschiedliche Tokenanzahl</h2>
<p>Eigenes Beispiel für <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi><mo>=</mo><mn>0,75</mn></mrow><annotation encoding="application/x-tex">p=0{,}75</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span><span class="mspace" style="margin-right:0.2778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em;"></span></span><span class="base"><span class="strut" style="height:0.8389em;vertical-align:-0.1944em;"></span><span class="mord">0</span><span class="mord"><span class="mpunct">,</span></span><span class="mord">75</span></span></span></span>; die Zeilen enthalten bereits sortierte Wahrscheinlichkeiten:</p>




















<table><thead><tr><th>Verteilung für A, B, C, D</th><th>Erhaltene Tokens</th><th align="right">Ihre Summe vor der Normalisierung</th></tr></thead><tbody><tr><td>0,70; 0,15; 0,10; 0,05</td><td>A, B</td><td align="right">0,85</td></tr><tr><td>0,40; 0,30; 0,20; 0,10</td><td>A, B, C</td><td align="right">0,90</td></tr></tbody></table>
<p>In der zweiten Zeile ergeben A und B nur 0,70, deshalb muss C hinzukommen. Nach der Normalisierung betragen ihre Chancen <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>4</mn><mi mathvariant="normal">/</mi><mn>9</mn></mrow><annotation encoding="application/x-tex">4/9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">4/9</span></span></span></span>, <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>3</mn><mi mathvariant="normal">/</mi><mn>9</mn></mrow><annotation encoding="application/x-tex">3/9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">3/9</span></span></span></span> und <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mn>2</mn><mi mathvariant="normal">/</mi><mn>9</mn></mrow><annotation encoding="application/x-tex">2/9</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">2/9</span></span></span></span>. D wird ausgeschlossen. Die Schwelle bedeutet nicht, dass nur Tokens erhalten bleiben, deren Wahrscheinlichkeit <strong>jeweils einzeln</strong> mindestens 0,75 beträgt.</p>
<p><a href="https://paweldubiel.com/de/glossary/top-k-sampling">Top-k-Sampling</a> würde in beiden Fällen versuchen, dieselbe Anzahl von Kandidaten zu erhalten. Top-p reagiert auf die Verteilung ihrer Chancen. Wenden wir vorher eine <a href="https://paweldubiel.com/de/glossary/temperatur">Temperatur</a> an, verändert sich die Summe aufeinanderfolgender Wahrscheinlichkeiten, und die Abschneidegrenze kann an einer anderen Stelle liegen.</p>
<p>Die Arbeit untersuchte unter anderem die offene Textfortsetzung durch GPT-2 (§4.1). Ihre Ergebnisse legen keinen einheitlichen optimalen Schwellenwert für jedes Modell und jede Aufgabe fest. Der Parameter <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>p</mi></mrow><annotation encoding="application/x-tex">p</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em;"></span><span class="mord mathnormal">p</span></span></span></span> ist auch nicht die Wahrscheinlichkeit, dass die erzeugte Antwort korrekt sein wird.</p>
<div id="top-p-sampling-lab"></div>]]></content:encoded>
</item>
<item>
  <title>Wissensdestillation</title>
  <link>https://paweldubiel.com/de/glossary/wissensdestillation</link>
  <guid isPermaLink="true">https://paweldubiel.com/de/glossary/wissensdestillation</guid>
  <pubDate>Wed, 16 Sep 2026 21:39:15 GMT</pubDate>
  <dc:creator>Paweł Dubiel</dc:creator>
  <category>ai</category>
  <category>llm</category>
  <category>glossary</category>
  <description>Ein großes Modell löst die Aufgabe gut, ist aber für den täglichen Einsatz zu teuer. Ein kleineres Modell könnte versuchen, sein Verhalten nachzubilden.</description>
  <content:encoded><![CDATA[<p>Ein großes Modell löst die Aufgabe gut, ist aber für den täglichen Einsatz zu teuer. Ein kleineres Modell könnte versuchen, sein Verhalten nachzubilden. Es braucht jedoch Beispiele oder Bewertungen, die mehr zeigen als nur eine Liste korrekter Etiketten.</p>
<p><strong>Knowledge Distillation</strong> ist das Trainieren eines Schülermodells mit den Ausgaben oder Vorhersagen eines Lehrermodells. Der Schüler verändert dabei tatsächlich seine Parameter; eine bloße Anfrage an den Lehrer ist kein Training.</p>
<p>Wenn der Lehrer A die Wahrscheinlichkeit <code>0,60</code>, B <code>0,35</code> und C <code>0,05</code> gibt, lässt das Etikett „A“ die Information aus, dass B eine nahe Alternative ist. Der Schüler kann lernen, die gesamte Verteilung nachzubilden. Eine andere Variante verwendet vollständige, vom Lehrer erzeugte Texte.</p>
<p>Der Lehrer muss kein einzelnes größeres Modell sein, dient klassisch aber als Quelle des nachzuahmenden Verhaltens. Die Destillation kann auch Fehler übertragen. <a href="https://paweldubiel.com/de/glossary/kl-divergenz">KL Divergence</a> hilft, die Übereinstimmung der Vorhersagen zu messen; <a href="https://paweldubiel.com/de/glossary/on-policy-selbstdestillation">On-policy self-distillation</a> ist eine speziellere Konstruktion der Daten und des Lehrers.</p>
<h2 id="mechanismus-und-details">Mechanismus und Details</h2>
<p>In <a href="https://arxiv.org/pdf/1503.02531#page=2" rel="noopener noreferrer"><em>Distilling the Knowledge in a Neural Network</em>, §2</a> beschreiben Hinton, Vinyals und Dean das Lernen anhand weicher Wahrscheinlichkeitsverteilungen. Eine erhöhte <a href="https://paweldubiel.com/de/glossary/temperatur">Temperatur</a> macht mehr Informationen über die Beziehungen zwischen Kandidaten sichtbar. Beim Vergleich der Verteilungen wird derselbe Parameter für Lehrer und Schüler verwendet. Die Autoren kombinieren dieses Ziel mit dem Lernen anhand korrekter Labels, sofern diese verfügbar sind.</p>
<h2 id="mehr-informationen-als-eine-einzelne-antwort">Mehr Informationen als eine einzelne Antwort</h2>
<p>Eigenes Beispiel: Der Lehrer weist den beispielhaften <a href="https://paweldubiel.com/de/glossary/token">Tokens</a> A, B und C die Wahrscheinlichkeiten 0,60; 0,35; 0,05 zu. Das Etikett „A“ benennt nur den Gewinner. Die gesamte Verteilung zeigt auch, dass B wesentlich wahrscheinlicher als C war. Der Schüler kann versuchen, diese Verhältnisse mit <a href="https://paweldubiel.com/de/glossary/kreuzentropie">Cross-entropy</a> oder entsprechend gerichteter <a href="https://paweldubiel.com/de/glossary/kl-divergenz">KL Divergence</a> nachzubilden. Das ist ein zusätzliches Trainingssignal, kein Beweis für die Richtigkeit der Etiketten des Lehrers.</p>
<p>Bei texterzeugenden Modellen muss man den Vergleich von Verteilungen des nächsten Tokens vom Lernen anhand vollständiger erzeugter Sequenzen unterscheiden. <a href="https://aclanthology.org/D16-1139.pdf#page=3" rel="noopener noreferrer">Kim und Rush, <em>Sequence-Level Knowledge Distillation</em>, §2.2–3.2</a> beschreiben beide Ansätze für die maschinelle Übersetzung. In der sequenzbasierten Variante trainiert der Schüler auf Ausgaben, die die <a href="https://paweldubiel.com/de/glossary/beam-search">Beam Search</a> des Lehrers gefunden hat. Der Text einer solchen Antwort enthält nicht die vollständigen Wahrscheinlichkeiten aller alternativen Tokens.</p>
<p>Das Ergebnis hängt vom Lehrer, den Daten und den Fähigkeiten des Schülers ab. Es bedeutet weder eine Kopie sämtlicher Fähigkeiten noch eine garantierte Verbesserung bei jeder Aufgabe. Die separate Notiz <a href="https://paweldubiel.com/de/glossary/on-policy-selbstdestillation">On-Policy-Selbstdestillation</a> beschreibt eine besondere Variante in TTPO; ihre Bedingungen sind keine allgemeine Definition der Wissensdestillation.</p>]]></content:encoded>
</item>
</channel>
</rss>