# Anleitung zu Reinforcement Learning (RL) Reinforcement Learning ist der Bereich, in dem ein „Agent“ durch Interaktion mit einer Umgebung und durch das Erhalten von **Feedback** in Form von **Belohnungen** oder **Strafen**. * **Aktion:** Was das Modell erzeugt (z. B. einen Satz). * **Belohnung:** Ein Signal, das angibt, wie gut oder schlecht die Aktion des Modells war (z. B. hat die Antwort die Anweisungen befolgt? War sie hilfreich?). * **Umgebung:** Das Szenario oder die Aufgabe, an der das Modell arbeitet (z. B. die Frage eines Nutzers beantworten). ### :sloth:Was Sie lernen werden 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, was Sie über GRPO, Reinforcement Learning (RL) und Belohnungsfunktionen wissen müssen – von den Grundlagen bis zu fortgeschrittenen Themen – zusammen mit Tipps und den Grundlagen zur Verwendung von GRPO mit [Unsloth](https://github.com/unslothai/unsloth). Wenn Sie nach einer Schritt-für-Schritt-Anleitung zur Verwendung von GRPO suchen, sehen Sie sich unseren Leitfaden [hier](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo). {% hint style="success" %} **Update vom 15. Januar 2026:** [Ultra-Langkontext-RL](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/grpo-long-context) ist da! Trainieren Sie gpt-oss mit einem Kontextfenster von 380K. **Update vom 26. November 2025:** Wir führen FP8-Precision-RL und GRPO in Unsloth ein! [Blog lesen](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/fp8-reinforcement-learning) {% 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, wie wir es „erhöhen“ oder „verringern“ und was „Ergebnisse“ überhaupt bedeutet. {% columns %} {% column width="50%" %} Zum Beispiel ist in der **Pacman-Spiel**: 1. Der **die Umgebung** die Spielwelt. 2. Der **Aktionen** die Sie ausführen können, sind OBEN, LINKS, RECHTS und UNTEN. 3. Der **Belohnungen** sind gut, wenn Sie einen Keks essen, oder schlecht, wenn Sie einen der zappelnden Feinde treffen. 4. In RL können Sie nicht die „beste Aktion“ kennen, die Sie ausführen können, aber Sie können Zwischenschritte oder den endgültigen Spielzustand beobachten (Sieg oder Niederlage) {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column width="50%" %}
{% endcolumn %} {% column %} Ein weiteres Beispiel: Stellen Sie sich vor, Ihnen wird die Frage gestellt: **„Was ist 2 + 2?“** (4) Ein nicht ausgerichtetes Sprachmodell würde 3, 4, C, D, -10 ausspucken, buchstäblich alles. 1. Zahlen sind besser als C oder D, oder? 2. 3 zu erhalten ist besser als sagen wir 8, oder? 3. 4 zu erhalten ist auf jeden Fall 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“** trainieren, Ausgaben zu einer Frage (dem **Zustand**) zu erzeugen, die von Menschen als hilfreicher bewertet werden. Die Daumen hoch und runter in ChatGPT können beispielsweise im RLHF-Prozess verwendet werden. {% endcolumn %} {% endcolumns %} {% columns %} {% column %}

PPO-Formel

Der Term clip(..., 1-e, 1+e) wird verwendet, um PPO zu zwingen, keine zu großen Änderungen vorzunehmen. Es gibt außerdem einen KL-Term mit beta > 0, um das Modell zu zwingen, sich nicht zu weit zu entfernen. {% 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 er aus 3 Systemen: 1. Der **Generierende Policy (aktuell trainiertes Modell)** 2. Der **Referenz-Policy (ursprüngliches Modell)** 3. Der **Value-Modell (Schätzer für die durchschnittliche Belohnung)** Wir verwenden das **Belohnungsmodell** um die Belohnung für die aktuelle Umgebung zu berechnen, und unser Ziel ist es, **diese zu maximieren**! Die Formel für PPO sieht recht kompliziert aus, weil sie auf Stabilität ausgelegt wurde. Besuchen Sie unseren [AI Engineer-Vortrag](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. Der **Das Value-Modell wird entfernt,** ersetzt durch Statistiken aus mehrfachen Aufrufen des Belohnungsmodells. 2. Der **Das Belohnungsmodell wird entfernt** und ersetzt durch eine benutzerdefinierte Belohnungsfunktion, für die **RLVR** verwendet werden kann. {% endcolumn %} {% endcolumns %} Das bedeutet, dass GRPO extrem effizient ist. Früher musste PPO mehrere Modelle trainieren – jetzt, da Belohnungsmodell und Value-Modell entfernt wurden, können wir 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 können leicht überprüft werden. Z. B. 2+2 = 4. 2. Codeausgaben können darauf überprüft werden, ob sie korrekt ausgeführt wurden oder nicht. 3. Überprüfbare 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 Denkprozess kann Aufgaben wie E-Mail-Automatisierung, Datenbankabfragen, Recht und Medizin verbessern und die Genauigkeit basierend auf Ihrem Datensatz und Ihrer Belohnungsfunktion erheblich steigern – der Trick besteht darin, eine **Bewertungsrubrik zu definieren – also eine Liste kleinerer, überprüfbarer Belohnungen, und nicht eine einzige, alles umfassende Endbelohnung.** OpenAI machte dies in ihrem [Reinforcement-Learning-Finetuning (RFT)](https://platform.openai.com/docs/guides/reinforcement-fine-tuning) Angebot beispielsweise populär. {% columns %} {% column %} **Warum „Group Relative“?** GRPO entfernt das Value-Modell vollständig, aber wir müssen dennoch die **„durchschnittliche Belohnung“** für den aktuellen Zustand schätzen. Der **Der Trick besteht darin, das LLM zu samplen**! Danach berechnen wir die durchschnittliche Belohnung anhand von Statistiken des Sampling-Prozesses über mehrere verschiedene Fragen hinweg. {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Zum Beispiel samplen wir bei „Was ist 2+2?“ 4 Mal. Wir erhalten vielleicht 4, 3, D, C. Dann berechnen wir die Belohnung für jede dieser Antworten und anschließend die **durchschnittliche Belohnung** und **Standardabweichung**, dann **Z-Score-standardisieren** wir das! Dadurch entstehen die **Vorteile A**, die wir anstelle des Value-Modells verwenden. Das spart viel Speicher! {% endcolumn %} {% column %}

GRPO-Vorteilsberechnung

{% endcolumn %} {% endcolumns %} ### :fingers\_crossed:Glück (nun ja, Geduld) ist alles, was Sie brauchen Der Trick von RL ist, dass Sie nur 2 Dinge brauchen: 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 Wesentlichen **ein Sprachmodell unendlich oft aufrufen** bis wir eine gute Antwort erhalten. Zum Beispiel würde ein untrainiertes, schlechtes Sprachmodell auf „Was ist 2+2?“ 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 richtige Antwort über mehrere **Rollouts**gefunden. Unser Ziel ist es, die gute Antwort 4 häufiger zu sehen und den Rest (die schlechten Antworten) viel seltener. **Das Ziel von RL ist also, geduldig zu sein – im Grenzfall, wenn die Wahrscheinlichkeit der richtigen Antwort mindestens eine kleine Zahl (nicht null) beträgt, ist es nur ein Wartespiel – Sie werden mit 100%iger Sicherheit im Grenzfall auf die richtige Antwort stoßen.** **Deshalb nenne ich es für RL gern „Luck Is All You Need“.** **Nun, eine bessere Formulierung 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“, d. h. schlechte Antworten, und wir können das Modell im Wesentlichen „anleiten“, bereits zu versuchen, keine schlechten Lösungen zu erzeugen. Das bedeutet: Obwohl Sie sehr lange auf das Auftauchen einer „guten“ Antwort warten, wurde das Modell bereits verändert, damit es sein Bestes versucht, 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, wird RL das Modell dazu beeinflussen, zu versuchen, KEINE schlechten Antworten auszugeben. Das bedeutet, dass wir mit der Zeit die Ausgabeverteilung des Modells vorsichtig „ausdünnen“ oder von schlechten Antworten wegbewegen. Das heißt, RL ist **effizient**, da wir NICHT einfach unendlich warten, sondern aktiv versuchen, das Modell so weit wie möglich in den „Raum der richtigen Antwort“ zu „schieben“. {% hint style="danger" %} **Wenn die Wahrscheinlichkeit immer 0 ist, wird RL niemals funktionieren**. Das ist auch der Grund, warum Leute RL oft mit einem bereits instruction-finetunten Modell durchführen, das Anweisungen bereits einigermaßen gut befolgen kann – dadurch steigt die Wahrscheinlichkeit höchstwahrscheinlich über 0. {% endhint %} ## :sloth:Was Unsloth für RL bietet * Mit 15 GB VRAM ermöglicht Unsloth, jedes Modell mit bis zu 17 Mrd. Parametern wie Llama 3.1 (8B), Phi-4 (14B), Mistral (7B) oder Qwen2.5 (7B) in ein Reasoning-Modell umzuwandeln * **Unsloth unterstützt jetzt** [**RL für Vision/Multimodal-**](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl) **Modelle!** * **Mindestanforderung:** Nur 5 GB VRAM reichen aus, um Ihr eigenes Reasoning-Modell lokal zu trainieren (für jedes Modell mit 1,5 Mrd. Parametern oder weniger) {% columns %} {% column %} {% content-ref url="reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo" %} [tutorial-train-your-own-reasoning-model-with-grpo](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo) {% endcontent-ref %} {% endcolumn %} {% column %} {% content-ref url="reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl" %} [vision-reinforcement-learning-vlm-rl](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl) {% endcontent-ref %} {% endcolumn %} {% endcolumns %} {% hint style="info" %} Für **fortgeschrittenes GRPO** Dokumentation zu Batching, Generierung und Trainingsparametern, [lesen Sie unseren Leitfaden!](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/advanced-rl-documentation) {% endhint %} ### GRPO-Notebooks: | [**Qwen3.5 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)_Vision_GRPO.ipynb) **- Vision - *****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 | | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | [gpt-oss-20b](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-GRPO.ipynb) GSPO | [DeepSeek-R1-0528-Qwen3-8B](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/DeepSeek_R1_0528_Qwen3_\(8B\)_GRPO.ipynb) | [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) | [Qwen2.5 (3B)](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen2.5_\(3B\)-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**](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/advanced-rl-documentation/gspo-reinforcement-learning) und die meisten anderen neuen GRPO-Techniken. Sie können mit den folgenden Argumenten in GRPOConfig spielen, um Folgendes 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 Sie kein Reasoning erhalten, stellen Sie sicher, dass Sie genügend Trainingsschritte haben, und vergewissern Sie sich, dass Ihre [Belohnungsfunktion/Verifizierer](#reward-functions-verifier) funktioniert. Wir stellen Beispiele für Belohnungsfunktionen bereit [hier](#reward-function-examples). * Frühere Demonstrationen zeigten, dass Sie mit Qwen2.5 (3B) Ihren eigenen „Aha“-Moment erreichen konnten – dafür waren jedoch 2x A100-GPUs (160 GB VRAM) erforderlich. Jetzt können Sie 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) benötigen**. * Bitte beachten Sie: Dies ist weder das Fine-Tuning von DeepSeeks R1-destillierten Modellen noch die Verwendung von destillierten Daten aus R1 zum Tuning, was Unsloth bereits unterstützt hat. Hier wird ein Standardmodell mithilfe von GRPO in ein vollwertiges Reasoning-Modell umgewandelt. In einem Testbeispiel sind die Ergebnisse bereits 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 Modell es hat und zudem die richtige Antwort.
## :computer:Training mit GRPO Für ein Tutorial dazu, wie Sie mit Unsloth & GRPO jedes offene LLM in ein Reasoning-Modell umwandeln, [siehe hier](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo). {% hint style="success" %} Für **fortgeschrittenes GRPO** Dokumentation zu Batching, Generierung und Trainingsparametern, [lesen Sie unseren Leitfaden!](https://unsloth.ai/docs/de/los-gehts/reinforcement-learning-rl-guide/advanced-rl-documentation) {% endhint %} ### **Wie GRPO ein Modell trainiert** 1. Für jedes Frage-Antwort-Paar erzeugt das Modell mehrere mögliche Antworten (z. B. 8 Varianten). 2. Jede Antwort wird mithilfe von Belohnungsfunktionen bewertet. 3. Trainingsschritte: * Wenn Sie 300 Datenzeilen haben, sind das 300 Trainingsschritte (oder 900 Schritte bei 3 Epochen). * Sie können 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 Sie Probleme damit haben, dass Ihr GRPO-Modell nicht lernt, empfehlen wir dringend, unsere [fortgeschrittenen GRPO-Notebooks](https://unsloth.ai/docs/de/unsloth-notebooks#grpo-reasoning-notebooks) zu verwenden, da sie eine viel bessere Belohnungsfunktion haben und Sie schneller sowie häufiger Ergebnisse sehen sollten. {% endhint %} ### Grundlagen/Tipps * Warten Sie mindestens **300 Schritte** damit sich die Belohnung tatsächlich erhöht. Um vernünftige Ergebnisse zu erzielen, müssen Sie möglicherweise mindestens 12 Stunden investieren (so funktioniert GRPO), aber beachten Sie, dass dies nicht zwingend ist, da Sie jederzeit stoppen können. * Für optimale Ergebnisse haben Sie mindestens **500 Datenzeilen**. Sie können es sogar mit 10 Datenzeilen versuchen, aber mehr ist besser. * Jeder Trainingslauf ist immer anders, abhängig von Ihrem Modell, den Daten, der Belohnungsfunktion/dem Verifizierer usw. Daher ist zwar 300 Schritte das von uns genannte Minimum, manchmal können es aber auch 1000 Schritte oder mehr sein. Es hängt also von verschiedenen Faktoren ab. * Wenn Sie GRPO lokal mit Unsloth verwenden und einen Fehler erhalten, installieren Sie bitte ebenfalls „pip install diffusers“. Bitte verwenden Sie außerdem die neueste Version von vLLM. * Es wird empfohlen, GRPO auf ein Modell mit mindestens **1,5 Mrd. Parametern** anzuwenden, um Thinking-Tokens korrekt zu erzeugen, da kleinere Modelle dies möglicherweise nicht tun. * Für die [**GPU-VRAM-Anforderungen**](#grpo-requirement-guidelines) **von QLoRA 4-bit**ist die allgemeine Regel: Modellparameter = die Menge an VRAM, die Sie benötigen werden (Sie können weniger VRAM verwenden, aber das ist nur zur Sicherheit). Je mehr Kontextlänge Sie festlegen, desto mehr VRAM. LoRA 16-bit benötigt mindestens 4x mehr VRAM. * **Kontinuierliches Fine-Tuning ist** möglich, und Sie können GRPO einfach im Hintergrund laufen lassen. * In den Beispiel-Notebooks verwenden wir das [**GSM8K-Datenset**](#gsm8k-reward-functions), die derzeit beliebteste Wahl für R1-artiges Training. * Wenn Sie ein Basis-Modell verwenden, stellen Sie sicher, dass Sie eine Chat-Vorlage haben. * Je mehr Sie mit GRPO trainieren, desto besser. Das Beste an GRPO ist, dass Sie nicht einmal so viele Daten brauchen. Alles, was Sie brauchen, ist eine großartige Belohnungsfunktion/ein großartiger Verifizierer, und je mehr Zeit Sie mit Training verbringen, desto besser wird Ihr Modell. Erwarten Sie, dass Ihr Reward-vs.-Step-Wert mit der Zeit 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: Sie können RL mit Unsloth auch auf Modellen ausführen, die von vLLM nicht unterstützt werden, wie z. B. [Qwen3.5](https://unsloth.ai/docs/de/modelle/qwen3.5/fine-tune). Setzen Sie 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 Rollen bei der Bewertung der Ausgabe eines Modells. Allgemein könnte man sie als dasselbe interpretieren, technisch sind sie es jedoch nicht, aber das ist auch nicht so wichtig, da sie normalerweise zusammen verwendet werden. **Verifizierer**: * Bestimmt, ob die erzeugte Antwort korrekt oder inkorrekt ist. * Sie vergibt keine numerische Punktzahl – sie prüft lediglich die Korrektheit. * Beispiel: Wenn ein Modell für „2+2“ „5“ erzeugt, prüft der Verifizierer dies und kennzeichnet 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 zu validieren, ohne manuelle Bewertung zu benötigen. **Belohnungsfunktion**: * Wandelt Verifizierungsergebnisse (oder andere Kriterien) in eine numerische Punktzahl um. * Beispiel: Wenn eine Antwort falsch ist, könnte sie eine Strafe (-1, -2 usw.) vergeben, während eine richtige Antwort eine positive Punktzahl (+1, +2) erhalten könnte. * Sie kann auch basierend auf Kriterien jenseits der Korrektheit bestrafen, etwa bei übermäßiger Länge oder schlechter Lesbarkeit. **Wichtige Unterschiede**: * Eine **Verifizierer** prüft die Korrektheit, vergibt aber keine Punkte. * Eine **Belohnungsfunktion** vergibt Punkte, prüft aber nicht notwendigerweise selbst die Korrektheit. * Eine Belohnungsfunktion *kann* einen Verifizierer verwenden, aber sie sind technisch nicht dasselbe. ### **Belohnungsfunktionen verstehen** Das primäre Ziel von GRPO ist es, die Belohnung zu maximieren und zu lernen, wie eine Antwort zustande kam, statt einfach Antworten aus den Trainingsdaten auswendig zu lernen und wiederzugeben. * Mit jedem Trainingsschritt **passt GRPO die Modellgewichte an** um die Belohnung zu maximieren. Dieser Prozess verfeinert 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** anstatt nur das nächste Wort vorherzusagen. * Sie können **Daten wiederverwenden** über mehrere Epochen hinweg. * **Standard-Belohnungsfunktionen** können vorab definiert werden, um in einer Vielzahl von Anwendungsfällen verwendet zu werden, oder Sie können ChatGPT/ein lokales Modell bitten, sie für Sie zu erstellen. * Es gibt keinen einzelnen richtigen Weg, Belohnungsfunktionen oder Verifizierer zu entwerfen – die Möglichkeiten sind endlos. Sie müssen jedoch gut gestaltet und sinnvoll sein, da schlecht konzipierte Belohnungen die Modellleistung unbeabsichtigt verschlechtern können. ### :coin:Beispiele für Belohnungsfunktionen Sie können sich auf die folgenden Beispiele beziehen. Sie können Ihre Generierungen in ein LLM wie ChatGPT 4o oder Llama 3.1 (8B) eingeben und eine Belohnungsfunktion sowie einen Verifizierer entwerfen, um sie zu bewerten. Geben Sie zum Beispiel Ihre Generierungen in ein LLM Ihrer Wahl ein und legen Sie eine Regel fest: „Wenn die Antwort zu robotisch klingt, ziehe 3 Punkte ab.“ Dies 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 mit der richtigen Antwort übereinstimmt → **+3** * Wenn falsch → **-3** * **Gesamtbelohnung:** *Summe aller Belohnungsfunktionen* #### **Beispiel #2: E-Mail-Automatisierungsaufgabe** * **Frage:** Eingehende E-Mail * **Antwort:** Ausgehende E-Mail * **Belohnungsfunktionen:** * Wenn die Antwort ein erforderliches Schlüsselwort enthält → **+1** * Wenn die Antwort genau mit der idealen Antwort übereinstimmt → **+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** ### Unsloths proximitätsbasierte Belohnungsfunktion Wenn Sie sich unser [**fortgeschrittenes GRPO-Colab-Notebook**](#grpo-notebooks)angesehen haben, werden Sie bemerken, dass wir eine **benutzerdefinierte proximitätsbasierte Belohnungsfunktion** von Grund auf komplett neu erstellt haben, die darauf ausgelegt ist, Antworten zu belohnen, die näher an der richtigen Lösung liegen. Diese flexible Funktion kann auf eine Vielzahl von Aufgaben angewendet werden. * In unseren Beispielen aktivieren wir Reasoning in Qwen3 (Base) und lenken es auf bestimmte Aufgaben * Wenden Sie Pre-Finetuning-Strategien an, um GRPOs Standardtendenz zu vermeiden, nur Formatierung zu lernen * Steigern Sie die Bewertungsgenauigkeit mit regex-basiertem Matching * Erstellen Sie benutzerdefinierte GRPO-Vorlagen jenseits generischer Prompts wie `think`, z. B. `` * Wenden Sie proximitätsbasiertes Scoring an — Modelle erhalten mehr Belohnung für nähere Antworten (z. B. ist die Vorhersage 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 beliebt sind und sich als sehr 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 Zeilenumbruch-Abweichungen. * **strict\_format\_reward\_func** – Stellt sicher, dass die Antwortstruktur mit dem Prompt übereinstimmt, einschließlich Zeilenumbrüchen. * **xmlcount\_reward\_func** – Stellt sicher, dass in der Antwort genau ein Vorkommen jedes XML-Tags vorhanden ist. ## :abacus:Verwendung von vLLM Sie können jetzt [vLLM](https://github.com/vllm-project/vllm/) direkt in Ihrem Finetuning-Stack verwenden, was deutlich mehr Durchsatz ermöglicht und es erlaubt, das Modell gleichzeitig zu finetunen und Inferenz darauf auszuführen! Auf 1x A100 40 GB erwarten Sie etwa 4000 Tokens/s mit Unsloths dynamischer 4-bit-Quantisierung von Llama 3.2 3B Instruct. Auf einer 16-GB Tesla T4 (kostenlose Colab-GPU) können Sie 300 Tokens/s erreichen.\ \ Wir haben außerdem die doppelte Speichernutzung beim gemeinsamen Laden von vLLM und Unsloth magisch entfernt, was Einsparungen von etwa 5 GB für Llama 3.1 8B und 3 GB für Llama 3.2 3B ermöglicht. Ursprünglich konnte Unsloth Llama 3.3 70B Instruct auf 1x 48-GB-GPU finetunen, wobei die Gewichte von Llama 3.3 70B 40 GB VRAM belegten. Wenn wir die doppelte Speichernutzung nicht entfernen, benötigen wir >= 80 GB VRAM, wenn wir Unsloth und vLLM zusammen laden.\ \ Mit Unsloth können Sie jedoch weiterhin finetunen und die Vorteile schneller Inferenz in einem Paket mit unter 48 GB VRAM erhalten! Um schnelle Inferenz zu nutzen, installieren Sie zuerst vllm und instanziieren Sie 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:Richtlinien zu GRPO-Anforderungen Wenn Sie Unsloth für GRPO verwenden, reduzieren wir den VRAM-Verbrauch durch mehrere Tricks intelligent um über 90 % im Vergleich zu Standardimplementierungen mit Flash Attention 2! Bei 20K-Kontextlängen mit 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) benötigen**. 1. Für die **GPU-VRAM-Anforderungen für QLoRA 4-bit**ist die allgemeine Regel: Modellparameter = die Menge an VRAM, die Sie benötigen werden (Sie können weniger VRAM verwenden, aber das ist nur zur Sicherheit). Je mehr Kontextlänge Sie festlegen, desto mehr VRAM. LoRA 16-bit benötigt mindestens 4x mehr VRAM. 2. Unsere neuen speichereffizienten linearen Kernel für GRPO senken den Speicherverbrauch um das 8-Fache oder mehr. Dadurch werden 68,5 GB Speicher eingespart, und durch torch.compile sind sie sogar 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 Zwischenspeicherungen intelligent und asynchron in den Systemspeicher aus, während er nur 1 % langsamer ist. Dadurch werden 52 GB Speicher eingespart. 4. Unsloth verwendet außerdem denselben GPU-/CUDA-Speicherbereich wie die zugrunde liegende Inferenz-Engine (vLLM), anders als Implementierungen in anderen Paketen. Dadurch werden 16 GB Speicher eingespart. | Metriken | Unsloth | Standard + FA2 | | ----------------------------------------------- | ----------------------- | -------------- | | Trainingsspeicherkosten (GB) | 42 GB | 414 GB | | GRPO-Speicherkosten (GB) | 9,8 GB | 78,3 GB | | Inferenzkosten (GB) | 0 GB | 16 GB | | KV-Cache der Inferenz 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 müssen Sie 2 Logits der Größe (8. 20K) erzeugen, um den GRPO-Loss zu berechnen. Dies benötigt 2 \* 2 Byte \* 8 (Anzahl der Generierungen) \* 20K (Kontextlänge) \* 128256 (Vokabulargröße) = 78,3 GB VRAM. Unsloth senkt den Speicherverbrauch bei GRPO mit langem Kontext um das 8-Fache, sodass wir für 20K-Kontextlängen nur zusätzliche 9,8 GB VRAM benötigen! Wir müssen auch den KV-Cache in 16 Bit verwenden. Llama 3.1 8B hat 32 Schichten, und sowohl K als auch V haben die Größe 1024. Daher beträgt der Speicherverbrauch für 20K Kontextlänge = 2 \* 2 Byte \* 32 Schichten \* 20K Kontextlänge \* 1024 = 2,5 GB pro Batch. Wir würden die Batch-Größe für vLLM auf 8 setzen, lassen sie für unsere Berechnungen jedoch bei 1, um VRAM zu sparen. Andernfalls benötigen Sie 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. Yannic Kilchers GRPO-YouTube-Video ist ebenfalls ein Muss! 3. Wir haben 2025 auf der AI Engineer World's Fair einen 3-stündigen Workshop gehalten. Folien und weiteres Material finden Sie unter 4. Fortgeschrittenes GRPO-Notebook über Unsloth. 5. GRPO-Notebook ausgehend von einem Basismodell: ## Video-Tutorials Hier sind einige Video-Tutorials von großartigen YouTubern, die wir für fantastisch halten! {% embed url="" %} {% columns %} {% column width="50%" %} {% embed url="" %} Großartig, um zu lernen, wie Sie Ihren Datensatz vorbereiten und die Grundlagen von Reinforcement Learning + GRPO verstehen {% endembed %} {% embed url="" %} {% endcolumn %} {% column width="50%" %} {% embed url="" %} {% embed url="" %} Lokales GRPO auf Ihrem eigenen Gerät {% endembed %} {% endcolumn %} {% endcolumns %}