> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide.md). # Anleitung zu Reinforcement Learning (RL) Reinforcement Learning ist der Bereich, in dem ein „Agent“ durch die Interaktion mit einer Umgebung und den Empfang von **Feedback** in Form von **Belohnungen** oder **Strafen**. * **Aktion:** Was das Modell generiert (z. B. einen Satz). * **Belohnung:** Ein Signal, das angibt, wie gut oder schlecht die Aktion des Modells war (z. B. ob die Antwort den Anweisungen gefolgt ist? war sie hilfreich?). * **Umgebung:** Das Szenario oder die Aufgabe, an der das Modell arbeitet (z. B. die Beantwortung einer Nutzerfrage). ### :sloth:Was du lernen wirst 1. Was ist RL? RLVR? PPO? GRPO? RLHF? Ist **„Luck is All You Need?“** für RL? 2. Was ist eine Umgebung? Agent? Aktion? Belohnungsfunktion? Belohnungen? Dieser Artikel behandelt alles (vom Einsteiger- bis zum Fortgeschrittenenniveau), was du über GRPO, Reinforcement Learning (RL) und Belohnungsfunktionen wissen musst, zusammen mit Tipps und den Grundlagen zur Verwendung von GRPO mit [Unsloth](https://github.com/unslothai/unsloth). Wenn du nach einem Schritt-für-Schritt-Tutorial zur Verwendung von GRPO suchst, sieh dir unseren Leitfaden [hier](/docs/de/loslegen/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md). {% hint style="success" %} **Update vom 15. Jan. 2026:** [Ultra-langer Kontext RL](/docs/de/loslegen/reinforcement-learning-rl-guide/grpo-long-context.md) ist da! Trainiere gpt-oss mit einem 380K-Kontextfenster. **Update vom 26. Nov. 2025:** Wir führen FP8-Präzisions-RL und GRPO in Unsloth ein! [Blog lesen](/docs/de/loslegen/reinforcement-learning-rl-guide/fp8-reinforcement-learning.md) {% endhint %} ## :question:Was ist Reinforcement Learning (RL)? Das Ziel von RL ist es, 1. **die Wahrscheinlichkeit zu erhöhen, ****„gute“**** Ergebnisse zu sehen.** 2. **die Wahrscheinlichkeit zu verringern, ****„schlechte“**** Ergebnisse zu sehen.** **Das ist alles!** Es gibt Feinheiten dabei, was „gut“ und „schlecht“ bedeutet, oder wie wir es „erhöhen“ oder „verringern“, oder was überhaupt „Ergebnisse“ bedeutet. {% columns %} {% column width="50%" %} Zum Beispiel im **Pacman-Spiel**: 1. ist die **Umgebung** die Spielwelt. 2. ist die **Aktionen** die du ausführen kannst, sind OBEN, LINKS, RECHTS und UNTEN. 3. ist die **Belohnungen** sind gut, wenn du einen Keks isst, oder schlecht, wenn du einen der schlängelnden Gegner triffst. 4. In RL kannst du nicht wissen, welche „beste Aktion“ du ausführen kannst, aber du kannst Zwischenschritte oder den endgültigen Spielzustand beobachten (Gewinn oder Niederlage). {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column width="50%" %}
{% endcolumn %} {% column %} Ein weiteres Beispiel: Stell dir vor, dir wird die Frage gestellt: **„Was ist 2 + 2?“** (4) Ein unausgerichtetes Sprachmodell wird 3, 4, C, D, -10 ausspucken – buchstäblich alles Mögliche. 1. Zahlen sind besser als C oder D, oder? 2. 3 zu bekommen ist besser als zum Beispiel 8, oder? 3. 4 zu bekommen ist definitiv korrekt. Wir haben gerade eine **Belohnungsfunktion**! {% endcolumn %} {% endcolumns %} ### :person\_running:Von RLHF, PPO bis GRPO und RLVR {% columns %} {% column %}
{% endcolumn %} {% column %} OpenAI machte das Konzept von [RLHF](https://en.wikipedia.org/wiki/Reinforcement_learning_from_human_feedback) (Reinforcement Learning from Human Feedback) populär, bei dem wir einen **„Agenten“** darauf trainieren, auf eine Frage Ausgaben zu erzeugen (den **Zustand**), die von Menschen als nützlicher bewertet werden. Die Daumen-hoch- und Daumen-runter-Bewertungen in ChatGPT können beispielsweise im RLHF-Prozess verwendet werden. {% endcolumn %} {% endcolumns %} {% columns %} {% column %}

PPO-Formel

Der Begriff clip(..., 1-e, 1+e) wird verwendet, um PPO zu zwingen, keine zu großen Änderungen vorzunehmen. Es gibt auch einen KL-Term mit beta > 0, um das Modell davon abzuhalten, zu stark abzuweichen. {% endcolumn %} {% column %} Um RLHF durchzuführen, [**PPO**](https://en.wikipedia.org/wiki/Proximal_policy_optimization) (Proximal Policy Optimization) wurde entwickelt. Der **Agent** ist in diesem Fall das Sprachmodell. Tatsächlich besteht es aus 3 Systemen: 1. ist die **Generierende Policy (aktuell trainiertes Modell)** 2. ist die **Referenz-Policy (ursprüngliches Modell)** 3. ist die **Wertemodell (Schätzer des durchschnittlichen Belohnungswerts)** Wir verwenden das **Belohnungsmodell** um die Belohnung für die aktuelle Umgebung zu berechnen, und unser Ziel ist es, **dies zu maximieren**! Die Formel für PPO sieht ziemlich kompliziert aus, weil sie auf Stabilität ausgelegt wurde. Besuche unseren [AI Engineer Talk](https://docs.unsloth.ai/ai-engineers-2025) den wir 2025 über RL gehalten haben, für ausführlichere mathematische Herleitungen zu PPO. {% endcolumn %} {% endcolumns %} {% columns %} {% column %}
{% endcolumn %} {% column %} DeepSeek entwickelte [**GRPO**](https://unsloth.ai/blog/grpo) (Group Relative Policy Optimization), um ihre R1-Reasoning-Modelle zu trainieren. Die wichtigsten Unterschiede zu PPO sind: 1. ist die **Das Wertemodell wird entfernt,** ersetzt durch Statistiken aus mehrfachen Aufrufen des Belohnungsmodells. 2. ist die **Das Belohnungsmodell wird entfernt** und durch eine nur benutzerdefinierte Belohnungsfunktion ersetzt, die **RLVR** verwenden kann. {% endcolumn %} {% endcolumns %} Das bedeutet, dass GRPO extrem effizient ist. Früher musste PPO mehrere Modelle trainieren – jetzt können wir mit entferntem Belohnungs- und Wertemodell Speicher sparen und alles beschleunigen. **RLVR (Reinforcement Learning with Verifiable Rewards)** ermöglicht es uns, das Modell auf Basis von Aufgaben mit leicht überprüfbaren Lösungen zu belohnen. Zum Beispiel: 1. Mathematische Gleichungen lassen sich leicht überprüfen. Z. B. 2+2 = 4. 2. Code-Ausgaben können darauf überprüft werden, ob sie korrekt ausgeführt wurden oder nicht. 3. Verifizierbare Belohnungsfunktionen zu entwerfen kann schwierig sein, daher sind die meisten Beispiele Mathematik oder Code. 4. Anwendungsfälle für GRPO beschränken sich nicht nur auf Code oder Mathematik – sein Reasoning-Prozess kann Aufgaben wie E-Mail-Automatisierung, Datenbankabfragen, Recht und Medizin verbessern und die Genauigkeit auf Basis deines Datensatzes und deiner Belohnungsfunktion erheblich steigern – der Trick besteht darin, eine **Rubrik zu definieren – also eine Liste kleinerer, überprüfbarer Belohnungen und nicht eine finale, alles umfassende einzelne Belohnung.** OpenAI popularisierte dies in ihrem [Reinforcement Learning Finetuning (RFT)](https://platform.openai.com/docs/guides/reinforcement-fine-tuning) Angebot zum Beispiel. {% columns %} {% column %} **Warum „Group Relative“?** GRPO entfernt das Wertemodell vollständig, aber wir müssen dennoch den **„durchschnittlichen Belohnungswert“** für den aktuellen Zustand schätzen. ist die **Der Trick besteht darin, das LLM zu sampeln**! Anschließend berechnen wir die durchschnittliche Belohnung anhand von Statistiken des Sampling-Prozesses über mehrere verschiedene Fragen hinweg. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Zum Beispiel sampeln wir für „Was ist 2+2?“ viermal. Wir könnten 4, 3, D, C erhalten. Dann berechnen wir die Belohnung für jede dieser Antworten und anschließend den **durchschnittlichen Belohnungswert** und die **Standardabweichung**, dann **per Z-Score standardisieren** wir dies! Dadurch entstehen die **Vorteile A**, die wir als Ersatz für das Wertemodell verwenden. Das spart viel Speicher! {% endcolumn %} {% column %}

GRPO-Vorteilsberechnung

{% endcolumn %} {% endcolumns %} ### :fingers\_crossed:Glück (naja, Geduld) ist alles, was du brauchst Der Trick bei RL ist, dass du nur 2 Dinge brauchst: 1. Eine Frage oder Anweisung, z. B. „Was ist 2+2?“ „Erstelle ein Flappy-Bird-Spiel in Python“ 2. Eine Belohnungsfunktion und einen Verifizierer, um zu prüfen, ob die Ausgabe gut oder schlecht ist. Mit nur diesen 2 können wir im Grunde **ein Sprachmodell unendlich oft aufrufen** bis wir eine gute Antwort erhalten. Zum Beispiel würde für „Was ist 2+2?“ ein untrainiertes, schlechtes Sprachmodell Folgendes ausgeben: ***0, Katze, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31\*\*\*\*\*\*\*\* ****dann plötzlich 4****.*** ***Das Belohnungssignal war 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\*\*\*\*\*\*\*\* ****dann plötzlich 1.*** Also hat RL durch Glück und Zufall die korrekte Antwort über mehrere **Rollouts**gefunden. Unser Ziel ist, dass wir die gute Antwort 4 häufiger sehen und den Rest (die schlechten Antworten) viel seltener. **Das Ziel von RL ist also, geduldig zu sein – im Grenzfall, wenn die Wahrscheinlichkeit der korrekten Antwort mindestens eine kleine Zahl (nicht null) ist, ist es nur ein Wartespiel – du wirst im Grenzfall mit 100 % Sicherheit auf die korrekte Antwort stoßen.** **Deshalb nenne ich es gern „Luck Is All You Need“ für RL.** **Nun, ein besserer Ausdruck ist „Patience is All You Need“ für RL.**
RL bietet uns im Wesentlichen einen Trick – statt einfach unendlich zu warten, erhalten wir „schlechte Signale“, also schlechte Antworten, und können das Modell im Grunde schon dazu „lenken“, schlechte Lösungen möglichst nicht zu generieren. Das bedeutet, obwohl du sehr lange auf das Auftauchen einer „guten“ Antwort gewartet hast, wurde das Modell bereits so verändert, dass es sein Bestes gibt, keine schlechten Antworten auszugeben. Im Beispiel „Was ist 2+2?“ – ***0, Katze, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31\*\*\*\*\*\*\*\* ****dann plötzlich 4****.*** Da wir schlechte Antworten erhalten haben, beeinflusst RL das Modell so, dass es versucht, KEINE schlechten Antworten auszugeben. Das bedeutet, dass wir mit der Zeit vorsichtig die Ausgabeverteilung des Modells von schlechten Antworten weg „beschneiden“ oder verschieben. Das macht RL **effizient**, da wir NICHT nur unendlich warten, sondern aktiv versuchen, das Modell so weit wie möglich in den „Raum der korrekten Antworten“ zu schieben. {% hint style="danger" %} **Wenn die Wahrscheinlichkeit immer 0 ist, wird RL niemals funktionieren**. Deshalb machen Leute gern RL auf einem bereits instruktions-feinabgestimmten Modell, das Anweisungen einigermaßen gut befolgen kann – dadurch steigt die Wahrscheinlichkeit meist über 0. {% endhint %} ## :sloth:Was Unsloth für RL bietet * Mit 15 GB VRAM ermöglicht Unsloth dir, jedes Modell mit bis zu 17B Parametern wie Llama 3.1 (8B), Phi-4 (14B), Mistral (7B) oder Qwen2.5 (7B) in ein Reasoning-Modell zu verwandeln * **Unsloth unterstützt jetzt** [**RL für Vision-/Multimodal-**](/docs/de/loslegen/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md) **Modelle!** * **Mindestanforderung:** Schon 5 GB VRAM reichen aus, um dein eigenes Reasoning-Modell lokal zu trainieren (für jedes Modell mit 1,5B Parametern oder weniger) {% columns %} {% column %} {% content-ref url="/pages/2b7904fd5422b954809fd2460ec92281ba56a6fa" %} [Tutorial: GRPO Training](/docs/de/loslegen/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md) {% endcontent-ref %} {% endcolumn %} {% column %} {% content-ref url="/pages/b6b5ca32e463fa09c0f26919da403e22381129bc" %} [Vision RL](/docs/de/loslegen/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md) {% endcontent-ref %} {% endcolumn %} {% endcolumns %} {% hint style="info" %} Für **fortgeschrittenes GRPO** Dokumentation zu Batching, Generierung und Trainingsparametern, [lies unseren Leitfaden!](/docs/de/loslegen/reinforcement-learning-rl-guide/advanced-rl-documentation.md) {% endhint %} ### GRPO-Notebooks: | [**Gemma 4 E2B**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E2B\)_Reinforcement_Learning_Sudoku_Game.ipynb) - **neu** | [Qwen3-VL-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_VL_\(8B\)-Vision-GRPO.ipynb) - Vision GSPO | [Gemma 3 (4B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\)-Vision-GRPO.ipynb) - Vision GSPO | | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | [**Qwen3.5 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)_Vision_GRPO.ipynb) **- Vision - *****neu*** | [gpt-oss-20b](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-GRPO.ipynb) GSPO | [Llama 3.2 (3B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Advanced_Llama3_2_\(3B\)_GRPO_LoRA.ipynb) - Fortgeschritten | | [Qwen3 (4B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-GRPO.ipynb) - Fortgeschritten | [Phi-4 (14B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Phi_4_\(14B\)-GRPO.ipynb) | [DeepSeek-R1-0528-Qwen3-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/DeepSeek_R1_0528_Qwen3_\(8B\)_GRPO.ipynb) | | [Mistral v0.3 (7B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Mistral_v0.3_\(7B\)-GRPO.ipynb) | [Llama 3.1 (8B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.1_\(8B\)-GRPO.ipynb) | [Qwen3-8B - **FP8**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_8B_FP8_GRPO.ipynb) (L4) | {% hint style="success" %} Wir unterstützen [**GSPO**](/docs/de/loslegen/reinforcement-learning-rl-guide/advanced-rl-documentation/gspo-reinforcement-learning.md) und die meisten anderen neuen GRPO-Techniken. Du kannst in GRPOConfig mit den folgenden Argumenten spielen, um zu aktivieren: ```python epsilon=0.2, epsilon_high=0.28, # einseitig delta=1.5 # zweiseitig loss_type='gspo', # oder: loss_type='grpo', # oder: loss_type='dr_grpo', mask_truncated_completions=True, ``` {% endhint %} * Wenn du kein Reasoning bekommst, stelle sicher, dass du genügend Trainingsschritte hast und dass deine [Belohnungsfunktion/dein Verifizierer](#reward-functions-verifier) funktioniert. Wir stellen Beispiele für Belohnungsfunktionen bereit [hier](#reward-function-examples). * Frühere Demonstrationen zeigen, dass du mit Qwen2.5 (3B) deinen eigenen „Aha“-Moment erreichen konntest – aber dafür waren 2xA100-GPUs (160 GB VRAM) erforderlich. Jetzt kannst du mit Unsloth denselben „Aha“-Moment mit nur einer einzigen 5-GB-VRAM-GPU erreichen. * Früher wurde GRPO nur für vollständiges Fine-Tuning unterstützt, aber wir haben es mit QLoRA und LoRA zum Laufen gebracht * Bei [**20K-Kontextlängen**](#grpo-requirement-guidelines) zum Beispiel mit 8 Generierungen pro Prompt verwendet Unsloth nur 54,3 GB VRAM für Llama 3.1 (8B), während Standardimplementierungen (+ Flash Attention 2) **510,8 GB (90 % weniger für Unsloth)**. * Bitte beachte, dass dies nicht das Fine-Tuning von DeepSeeks R1-distillierten Modellen oder die Verwendung von distillierten Daten aus R1 zum Tuning ist, was Unsloth bereits unterstützte. Dies verwandelt ein Standardmodell mithilfe von GRPO in ein vollwertiges Reasoning-Modell. In einem Testbeispiel sind die Ergebnisse schon klar, obwohl wir Phi-4 nur mit 100 Schritten mittels GRPO trainiert haben. Das Modell ohne GRPO hat das Thinking-Token nicht, während das mit GRPO trainierte es hat und außerdem die richtige Antwort enthält.
## :computer:Training mit GRPO Für ein Tutorial dazu, wie du jedes offene LLM mit Unsloth & GRPO in ein Reasoning-Modell verwandelst, [sieh hier](/docs/de/loslegen/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md). {% hint style="success" %} Für **fortgeschrittenes GRPO** Dokumentation zu Batching, Generierung und Trainingsparametern, [lies unseren Leitfaden!](/docs/de/loslegen/reinforcement-learning-rl-guide/advanced-rl-documentation.md) {% endhint %} ### **Wie GRPO ein Modell trainiert** 1. Für jedes Frage-Antwort-Paar generiert das Modell mehrere mögliche Antworten (z. B. 8 Varianten). 2. Jede Antwort wird mithilfe von Belohnungsfunktionen bewertet. 3. Trainingsschritte: * Wenn du 300 Datenzeilen hast, sind das 300 Trainingsschritte (oder 900 Schritte bei 3 Epochen). * Du kannst die Anzahl der pro Frage generierten Antworten erhöhen (z. B. von 8 auf 16). 4. Das Modell lernt, indem es seine Gewichte bei jedem Schritt aktualisiert. {% hint style="warning" %} Wenn dein GRPO-Modell nicht lernt und du Probleme hast, empfehlen wir dir dringend, unsere [Fortgeschrittenen GRPO-Notebooks](/docs/de/loslegen/unsloth-notebooks.md#grpo-reasoning-notebooks) zu verwenden, da sie eine deutlich bessere Belohnungsfunktion haben und du Ergebnisse viel schneller und häufiger sehen solltest. {% endhint %} ### Grundlagen/Tipps * Warte mindestens **300 Schritte** bis die Belohnung tatsächlich steigt. Um brauchbare Ergebnisse zu erzielen, musst du möglicherweise mindestens 12 Stunden investieren (so funktioniert GRPO), aber beachte, dass das nicht zwingend ist, da du jederzeit stoppen kannst. * Für optimale Ergebnisse mindestens **500 Datenzeilen**verwenden. Du kannst es sogar mit 10 Datenzeilen versuchen, aber mehr ist besser. * Jeder Trainingslauf wird je nach Modell, Daten, Belohnungsfunktion/Verifizierer usw. immer anders sein, also obwohl 300 Schritte das Minimum sind, das wir angegeben haben, können es manchmal 1000 Schritte oder mehr sein. Es hängt also von verschiedenen Faktoren ab. * Wenn du GRPO lokal mit Unsloth verwendest, installiere bitte auch „pip install diffusers“, falls ein Fehler auftritt. Bitte verwende außerdem die neueste Version von vLLM. * Es wird empfohlen, GRPO auf ein Modell mit mindestens **1,5B Parametern** anzuwenden, um korrekt Thinking-Tokens zu erzeugen, da kleinere Modelle dies möglicherweise nicht tun. * Für GRPOs [**GPU-VRAM-Anforderungen**](#grpo-requirement-guidelines) **für QLoRA 4-Bit**gilt allgemein: Die Modellparameter = die Menge an VRAM, die du benötigst (du kannst weniger VRAM verwenden, aber das ist nur zur Sicherheit). Je mehr Kontextlänge du festlegst, desto mehr VRAM. LoRA 16-Bit benötigt mindestens 4x mehr VRAM. * **Kontinuierliches Fine-Tuning ist** möglich und du kannst GRPO einfach im Hintergrund laufen lassen. * In den Beispiel-Notebooks verwenden wir das [**GSM8K-Dataset**](#gsm8k-reward-functions), die derzeit beliebteste Wahl für R1-artiges Training. * Wenn du ein Basismodell verwendest, stelle sicher, dass du eine Chat-Vorlage hast. * Je mehr du mit GRPO trainierst, desto besser. Das Beste an GRPO ist, dass du nicht einmal so viele Daten brauchst. Alles, was du brauchst, ist eine großartige Belohnungsfunktion/einen Verifizierer, und je mehr Zeit du mit Training verbringst, desto besser wird dein Modell. Erwarte, dass Belohnung vs. Schritt im Laufe der Zeit etwa so ansteigt:
* Das Tracking des Trainingsverlusts für GRPO ist jetzt direkt in Unsloth integriert, sodass externe Tools wie wandb usw. nicht mehr nötig sind. Es enthält jetzt vollständige Protokolldetails für alle Belohnungsfunktionen einschließlich der gesamten aggregierten Belohnungsfunktion selbst.
### RL auf nicht unterstützten Modellen: Du kannst mit Unsloth auch RL auf Modellen ausführen, die von vLLM nicht unterstützt werden, wie z. B. [Qwen3.5](/docs/de/modelle/qwen3.5/fine-tune.md). Setze einfach `fast_inference=False` beim Laden des Modells. ```python from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name="unsloth/Qwen3.5-4B", fast_inference=False, ) ``` ## :clipboard:Belohnungsfunktionen / Verifizierer Im Reinforcement Learning dienen eine **Belohnungsfunktion** und ein **Verifizierer** unterschiedlichen Zwecken bei der Bewertung der Ausgabe eines Modells. Im Allgemeinen kannst du sie als dasselbe interpretieren, technisch gesehen sind sie es jedoch nicht, aber das ist weniger wichtig, da sie normalerweise zusammen verwendet werden. **Verifizierer**: * Legt fest, ob die generierte Antwort korrekt oder inkorrekt ist. * Sie vergibt keinen numerischen Score – sie verifiziert lediglich die Korrektheit. * Beispiel: Wenn ein Modell für „2+2“ „5“ generiert, prüft der Verifizierer dies und markiert es als „falsch“ (da die richtige Antwort 4 ist). * Verifizierer können auch Code ausführen (z. B. in Python), um Logik, Syntax und Korrektheit ohne manuelle Bewertung zu prüfen. **Belohnungsfunktion**: * Wandelt Verifikationsergebnisse (oder andere Kriterien) in einen numerischen Score um. * Beispiel: Wenn eine Antwort falsch ist, könnte sie eine Strafe (-1, -2 usw.) vergeben, während eine korrekte Antwort einen positiven Score (+1, +2) erhalten könnte. * Sie kann auch auf Basis von Kriterien bestrafen, die über die Korrektheit hinausgehen, wie etwa übermäßige Länge oder schlechte Lesbarkeit. **Wichtige Unterschiede**: * Eine **Verifizierer** prüft die Korrektheit, vergibt aber keine Punktzahl. * Eine **Belohnungsfunktion** vergibt eine Punktzahl, überprüft aber nicht unbedingt selbst die Korrektheit. * Eine Belohnungsfunktion *kann* einen Verifizierer verwenden, aber technisch gesehen sind sie nicht dasselbe. ### **Belohnungsfunktionen verstehen** Das Hauptziel von GRPO ist es, die Belohnung zu maximieren und zu lernen, wie eine Antwort zustande kam, anstatt lediglich Antworten aus den Trainingsdaten auswendig zu lernen und wiederzugeben. * Mit jedem Trainingsschritt **passt GRPO die Modellgewichte an** um die Belohnung zu maximieren. Dieser Prozess feinjustiert das Modell schrittweise. * **Normales Fine-Tuning** (ohne GRPO) **maximiert nur die Wahrscheinlichkeit der Vorhersage des nächsten Wortes** optimiert aber nicht auf eine Belohnung. GRPO **optimiert auf eine Belohnungsfunktion** statt nur das nächste Wort vorherzusagen. * Du kannst **Daten wiederverwenden** über mehrere Epochen hinweg. * **Standard-Belohnungsfunktionen** können vordefiniert sein, um in einer Vielzahl von Anwendungsfällen verwendet zu werden, oder du kannst ChatGPT bzw. ein lokales Modell darum bitten, sie für dich zu generieren. * Es gibt keinen einzigen richtigen Weg, Belohnungsfunktionen oder Verifizierer zu entwerfen – die Möglichkeiten sind endlos. Sie müssen jedoch gut durchdacht und sinnvoll sein, da schlecht gestaltete Belohnungen die Modellleistung unbeabsichtigt verschlechtern können. ### :coin:Beispiele für Belohnungsfunktionen Du kannst dich an den folgenden Beispielen orientieren. Du kannst deine Generierungen in ein LLM wie ChatGPT 4o oder Llama 3.1 (8B) eingeben und eine Belohnungsfunktion sowie einen Verifizierer entwerfen, um sie zu bewerten. Zum Beispiel: Gib deine Generierungen in ein LLM deiner Wahl ein und lege eine Regel fest: „Wenn die Antwort zu roboterhaft klingt, ziehe 3 Punkte ab.“ Das hilft, Ausgaben anhand von Qualitätskriterien zu verfeinern #### **Beispiel #1: Einfache Rechenaufgabe** * **Frage:** `"2 + 2"` * **Antwort:** `"4"` * **Belohnungsfunktion 1:** * Wenn eine Zahl erkannt wird → **+1** * Wenn keine Zahl erkannt wird → **-1** * **Belohnungsfunktion 2:** * Wenn die Zahl der richtigen Antwort entspricht → **+3** * Wenn falsch → **-3** * **Gesamtbelohnung:** *Summe aller Belohnungsfunktionen* #### **Beispiel #2: Aufgabe zur E-Mail-Automatisierung** * **Frage:** Eingehende E-Mail * **Antwort:** Ausgehende E-Mail * **Belohnungsfunktionen:** * Wenn die Antwort ein erforderliches Schlüsselwort enthält → **+1** * Wenn die Antwort genau der idealen Antwort entspricht → **+1** * Wenn die Antwort zu lang ist → **-1** * Wenn der Name des Empfängers enthalten ist → **+1** * Wenn ein Signaturblock (Telefon, E-Mail, Adresse) vorhanden ist → **+1** ### Unsloth Nähe-basierte Belohnungsfunktion Wenn du dir unser [**Fortgeschrittenes GRPO-Colab-Notebook**](#grpo-notebooks)angesehen hast, wirst du bemerken, dass wir eine **benutzerdefinierte nähe-basierte Belohnungsfunktion** komplett von Grund auf neu erstellt haben, die darauf ausgelegt ist, Antworten zu belohnen, die der korrekten Antwort näher sind. Diese flexible Funktion kann auf eine breite Palette von Aufgaben angewendet werden. * In unseren Beispielen aktivieren wir Reasoning in Qwen3 (Base) und lenken es auf spezifische Aufgaben * Wende Pre-Finetuning-Strategien an, um zu vermeiden, dass GRPO standardmäßig nur das Format lernt * Erhöhe die Evaluierungsgenauigkeit mit Regex-basierter Übereinstimmung * Erstelle benutzerdefinierte GRPO-Vorlagen jenseits generischer Prompts wie `think`, z. B. `` * Wende eine nähe-basierte Bewertung an – Modelle erhalten mehr Belohnung für näher liegende Antworten (z. B. ist das Vorhersagen von 9 statt 10 besser als 3), während Ausreißer bestraft werden #### GSM8K-Belohnungsfunktionen In unseren anderen Beispielen verwenden wir bestehende GSM8K-Belohnungsfunktionen von [@willccbb](https://x.com/willccbb) die populär sind und sich als ziemlich effektiv erwiesen haben: * **correctness\_reward\_func** – Belohnt exakte Label-Übereinstimmungen. * **int\_reward\_func** – Fördert Antworten nur mit ganzen Zahlen. * **soft\_format\_reward\_func** – Prüft die Struktur, erlaubt aber kleinere Abweichungen bei Zeilenumbrüchen. * **strict\_format\_reward\_func** – Stellt sicher, dass die Antwortstruktur dem Prompt entspricht, einschließlich Zeilenumbrüchen. * **xmlcount\_reward\_func** – Stellt sicher, dass jedes XML-Tag genau einmal in der Antwort vorkommt. ## :abacus:vLLM verwenden Du kannst jetzt [vLLM](https://github.com/vllm-project/vllm/) direkt in deinem Fine-Tuning-Stack verwenden, was viel mehr Durchsatz ermöglicht und dir erlaubt, das Modell gleichzeitig zu feinabstimmen und Inferenz durchzuführen! Auf 1x A100 40GB kannst du mit Unsloths dynamischer 4-Bit-Quantisierung von Llama 3.2 3B Instruct etwa 4000 Tokens/s erwarten. Auf einer 16GB Tesla T4 (kostenlose Colab-GPU) kannst du 300 Tokens/s erreichen.\ \ Wir haben außerdem magisch den doppelten Speicherverbrauch beim gemeinsamen Laden von vLLM und Unsloth entfernt, was Einsparungen von etwa 5 GB für Llama 3.1 8B und 3 GB für Llama 3.2 3B ermöglicht. Unsloth konnte ursprünglich Llama 3.3 70B Instruct auf 1x 48GB-GPU feinabstimmen, wobei die Gewichte von Llama 3.3 70B 40 GB VRAM beanspruchten. Wenn wir die doppelte Speichernutzung nicht entfernen, benötigen wir beim gemeinsamen Laden von Unsloth und vLLM >= 80 GB VRAM.\ \ Mit Unsloth kannst du jedoch weiterhin feinabstimmen und die Vorteile schneller Inferenz in einem Paket unter 48 GB VRAM erhalten! Um schnelle Inferenz zu nutzen, installiere zuerst vllm und instanziiere Unsloth mit fast\_inference: ```python # pip install unsloth vllm from unsloth import FastLanguageModel model, tokenizer = FastLanguageModel.from_pretrained( model_name = "unsloth/Llama-3.2-3B-Instruct", fast_inference = True, ) ``` ## :white\_check\_mark:GRPO-Anforderungsrichtlinien Wenn du Unsloth für GRPO verwendest, reduzieren wir die VRAM-Nutzung durch mehrere Tricks intelligent um über 90 % im Vergleich zu Standardimplementierungen mit Flash Attention 2! Bei 20K-Kontextlängen und z. B. 8 Generierungen pro Prompt verwendet Unsloth nur **54,3 GB VRAM für Llama 3.1 8B**, während Standardimplementierungen **510,8 GB (90 % weniger für Unsloth)**. 1. Für GRPOs **GPU-VRAM-Anforderungen für QLoRA 4-Bit**gilt allgemein: Die Modellparameter = die Menge an VRAM, die du benötigst (du kannst weniger VRAM verwenden, aber das ist nur zur Sicherheit). Je mehr Kontextlänge du festlegst, desto mehr VRAM. LoRA 16-Bit benötigt mindestens 4x mehr VRAM. 2. Unsere neuen speichereffizienten linearen Kernel für GRPO reduzieren den Speicherverbrauch um das 8-Fache oder mehr. Das spart 68,5 GB Speicher und ist dank torch.compile tatsächlich schneller! 3. Wir nutzen unser intelligentes [Unsloth-Gradient-Checkpointing](https://unsloth.ai/blog/long-context) Algorithmus, den wir vor einiger Zeit veröffentlicht haben. Er lagert Zwischenaktivierungen intelligent asynchron in den Systemspeicher aus und ist dabei nur 1 % langsamer. Das spart 52 GB Speicher. 4. Unsloth verwendet außerdem denselben GPU-/CUDA-Speicherbereich wie die zugrunde liegende Inferenz-Engine (vLLM), im Gegensatz zu Implementierungen in anderen Paketen. Das spart 16 GB Speicher. | Metriken | Unsloth | Standard + FA2 | | ------------------------------------------- | ----------------------- | -------------- | | Trainingssicherspeicher-Kosten (GB) | 42 GB | 414 GB | | GRPO-Speicherkosten (GB) | 9,8 GB | 78,3 GB | | Inferenzkosten (GB) | 0 GB | 16 GB | | Inferenz-KV-Cache für 20K-Kontextlänge (GB) | 2,5 GB | 2,5 GB | | Gesamtspeicherverbrauch | 54,33 GB (90 % weniger) | 510,8 GB | In typischen Standard-GRPO-Implementierungen musst du 2 Logits der Größe (8. 20K) erzeugen, um den GRPO-Loss zu berechnen. Das benötigt 2 \* 2 Bytes \* 8 (Anzahl der Generierungen) \* 20K (Kontextlänge) \* 128256 (Vokabulargröße) = 78,3 GB VRAM. Unsloth reduziert den Speicherverbrauch für langkontextiges GRPO um das 8-Fache, sodass wir für 20K-Kontextlängen nur zusätzliche 9,8 GB VRAM benötigen! Wir müssen außerdem den KV-Cache in 16 Bit verwenden. Llama 3.1 8B hat 32 Schichten, und sowohl K als auch V haben eine Größe von 1024. Also beträgt der Speicherverbrauch für 20K-Kontextlänge = 2 \* 2 Bytes \* 32 Schichten \* 20K-Kontextlänge \* 1024 = 2,5 GB pro Batch. Wir würden die Batch-Größe für vLLM auf 8 setzen, aber für unsere Berechnungen lassen wir sie bei 1, um VRAM zu sparen. Andernfalls benötigst du 20 GB für den KV-Cache. ## 🎥 Unsloth RL 3-Stunden-Workshop-Video {% embed url="" %} ## :mortar\_board:Weiterführende Lektüre 1. Nathan Lamberts RLHF-Buch ist ein Muss! 2. Auch das GRPO-YouTube-Video von Yannic Kilcher ist ein Muss! 3. Wir haben 2025 auf der AI Engineer World's Fair einen 3-stündigen Workshop durchgeführt. Folien und weiteres Material findest du unter 4. Fortgeschrittenes GRPO-Notebook über Unsloth. 5. GRPO-Notebook von einem Basismodell: ## Video-Tutorials Hier sind einige Video-Tutorials von großartigen YouTubern, die wir fantastisch finden! {% embed url="" %} {% columns %} {% column width="50%" %} {% embed url="" %} Großartig, um zu lernen, wie du deinen Datensatz vorbereitest, sowie Erklärungen zu den Grundlagen von Reinforcement Learning + GRPO {% endembed %} {% embed url="" %} {% endcolumn %} {% column width="50%" %} {% embed url="" %} {% embed url="" %} Lokales GRPO auf deinem eigenen Gerät {% endembed %} {% endcolumn %} {% endcolumns %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.