💡Leitfaden für Reinforcement Learning (RL)
Erfahre alles über Reinforcement Learning (RL) und wie du mit Unsloth und GRPO dein eigenes DeepSeek-R1-Reasoning-Modell trainierst. Ein kompletter Leitfaden vom Anfänger bis zum Fortgeschrittenen.
Reinforcement Learning ist, wenn ein „Agent“ durch Interaktion mit einer Umgebung Entscheidungen lernt zu treffen und dabei Feedback in Form von Belohnungen oder Strafen.
Aktion: Was das Modell erzeugt (z. B. ein Satz).
Belohnung: Ein Signal, das anzeigt, 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. Beantwortung einer Benutzerfrage).
🦥Was du lernen wirst
Was ist RL? RLVR? PPO? GRPO? RLHF? RFT? Ist „Glück ist alles, was du brauchst?“ für RL?
Was ist eine Umgebung? Agent? Aktion? Belohnungsfunktion? Belohnungen?
Dieser Artikel behandelt alles (von Anfänger- bis Fortgeschrittenenlevel), was du über GRPO, Reinforcement Learning (RL) und Belohnungsfunktionen wissen musst, zusammen mit Tipps und den Grundlagen zur Verwendung von GRPO mit Unsloth. Wenn du nach einem Schritt-für-Schritt-Tutorial zur Verwendung von GRPO suchst, siehe unseren Leitfaden hier.
Update 15. Jan 2026: RL mit ultra-langen Kontexten ist da! Trainiere gpt-oss mit einem Kontextfenster von 380K.
Update 26. Nov 2025: Wir führen FP8-Präzisions-RL und GRPO in Unsloth ein! Blog lesen
❓Was ist Reinforcement Learning (RL)?
Das Ziel von RL ist:
Die Wahrscheinlichkeit zu erhöhen, „gute“ Ergebnisse zu sehen.
Die Wahrscheinlichkeit zu verringern, „schlechte“ Ergebnisse zu sehen.
Das war's! Es gibt Feinheiten darin, was „gut“ und „schlecht“ bedeutet, wie wir es „erhöhen“ oder „verringern“ können oder was überhaupt „Ergebnisse“ bedeutet.
Zum Beispiel in der Pacman-Spiel:
Die Umgebung ist die Spielwelt.
Die Aktionen die du ausführen kannst, sind OBEN, LINKS, RECHTS und UNTEN.
Die Belohnungen sind gut, wenn du einen Keks isst, oder schlecht, wenn du einen der gezackten Gegner triffst.
Im RL kannst du die „beste Aktion“, die du ausführen kannst, nicht kennen, aber du kannst Zwischenzustände oder den endgültigen Spielzustand (Sieg oder Niederlage) beobachten
Ein weiteres Beispiel: Stell dir vor, dir wird die Frage gestellt: „Was ist 2 + 2?“ (4) Ein nicht ausgerichtetes Sprachmodell wird 3, 4, C, D, -10, buchstäblich irgendetwas ausspucken.
Zahlen sind besser als C oder D, oder?
3 zu erhalten ist besser als zum Beispiel 8, oder?
4 zu erhalten ist definitiv korrekt.
Wir haben gerade eine Belohnungsfunktion!
🏃Von RLHF, PPO zu GRPO und RLVR
OpenAI hat das Konzept von RLHF (Reinforcement Learning from Human Feedback) popularisiert, bei dem wir einen „Agenten“ trainieren, Ausgaben auf eine Frage (den Zustand) zu erzeugen, die von Menschen als nützlicher bewertet werden.
Die Daumen hoch und runter in ChatGPT können zum Beispiel im RLHF-Prozess verwendet werden.
Der clip(..., 1-e, 1+e)-Term wird verwendet, um PPO daran zu hindern, zu große Änderungen vorzunehmen. Es gibt außerdem einen KL-Term mit beta > 0, um das Modell daran zu hindern, sich zu stark zu entfernen.
Um RLHF durchzuführen, wurde PPO (Proximal Policy Optimization) entwickelt. Der Agent ist in diesem Fall das Sprachmodell. Tatsächlich besteht es aus 3 Systemen:
Die Generierende Policy (aktuell trainiertes Modell)
Die Referenz-Policy (ursprüngliches Modell)
Die Value-Modell (Schätzer des durchschnittlichen Rewards)
Wir verwenden das Reward Model 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-Vortrag den wir 2025 über RL gehalten haben, für tiefere mathematische Herleitungen zu PPO.
DeepSeek entwickelte GRPO (Group Relative Policy Optimization) zum Trainieren ihrer R1-Reasoning-Modelle. Die wichtigsten Unterschiede zu PPO sind:
Die Das Value-Modell wird entfernt, ersetzt durch Statistiken aus mehrfachen Aufrufen des Reward-Modells.
Die Das Reward-Modell wird entfernt und ersetzt durch nur eine benutzerdefinierte Belohnungsfunktion, die für RLVR verwendet werden kann.
Das bedeutet, dass GRPO extrem effizient ist. Zuvor musste PPO mehrere Modelle trainieren – jetzt können wir durch das Entfernen des Reward-Modells und des Value-Modells Speicher sparen und alles beschleunigen.
RLVR (Reinforcement Learning mit verifizierbaren Belohnungen) ermöglicht es, das Modell basierend auf Aufgaben mit leicht verifizierbaren Lösungen zu belohnen. Zum Beispiel:
Mathematische Gleichungen lassen sich leicht verifizieren. Z.B. 2+2 = 4.
Code-Ausgaben können dahingehend überprüft werden, ob sie korrekt ausgeführt wurden oder nicht.
Das Entwerfen verifizierbarer Belohnungsfunktionen kann schwierig sein, daher sind die meisten Beispiele Mathematik oder Code.
Anwendungsfälle für GRPO sind nicht nur für Code oder Mathematik – sein Reasoning-Prozess kann Aufgaben wie E-Mail-Automatisierung, Datenbankabfragen, Recht und Medizin verbessern und die Genauigkeit stark erhöhen, je nach deinem Datensatz und der Belohnungsfunktion – der Trick ist, ein Bewertungsschema - z. B. eine Liste kleinerer verifizierbarer Belohnungen, und nicht eine finale alles verzehrende einzelne Belohnung. OpenAI hat dies zum Beispiel in ihrem Angebot für Reinforcement Learning-Finetuning (RFT) popularisiert.
Warum „Group Relative“?
GRPO entfernt das Value-Modell vollständig, aber wir müssen immer noch den „durchschnittlichen Reward“ für den aktuellen Zustand schätzen.
Die Der Trick ist, das LLM zu sampeln! Wir berechnen dann den durchschnittlichen Reward durch Statistiken des Sampling-Prozesses über mehrere verschiedene Fragen.
Zum Beispiel für „Was ist 2+2?“ sampeln wir 4-mal. Wir könnten 4, 3, D, C erhalten. Wir berechnen dann die Belohnung für jede dieser Antworten und berechnen anschließend den durchschnittlichen Reward und Standardabweichung, dann Z-Score standardisieren dies!
Das erzeugt die Vorteile A, die wir anstelle des Value-Modells verwenden werden. Das spart viel Speicher!
🤞Glück (nun Geduld) ist alles, was du brauchst
Der Trick des RL ist: Du brauchst nur 2 Dinge:
Eine Frage oder Anweisung z. B. „Was ist 2+2?“ „Erstelle ein Flappy Bird-Spiel in Python“
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 wird ein untrainiertes schlechtes Sprachmodell für „Was ist 2+2?“ ausgeben:
0, Katze, -10, 1928, 3, A, B, 122, 17, 182, 172, A, C, BAHS, %$, #, 9, -192, 12.31**** und dann plötzlich 4.
Das Belohnungssignal war 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0**** und dann plötzlich 1.
Also durch Glück und Zufall schaffte es RL, über mehrere Rolloutsdie richtige Antwort zu finden. Unser Ziel ist, die gute Antwort 4 häufiger zu sehen und die anderen (die schlechten Antworten) deutlich seltener.
Das Ziel von RL ist also Geduld – im Grenzfall, wenn die Wahrscheinlichkeit der korrekten Antwort mindestens eine kleine Zahl (nicht null) ist, ist es nur ein Warten-Spiel – du wirst mit Sicherheit im Grenzwert die korrekte Antwort begegnen.
Deshalb nenne ich es gern „Glück ist alles, was du brauchst“ für RL.
Eine bessere Formulierung ist jedoch „Geduld ist alles, was du brauchst“ für RL.
RL bietet uns im Grunde einen Trick – anstatt einfach auf die Unendlichkeit zu warten, erhalten wir „schlechte Signale“, also schlechte Antworten, und wir können das Modell im Wesentlichen „leiten“, bereits keine schlechten Lösungen zu generieren. Das bedeutet, obwohl du sehr lange auf das Auftauchen einer „guten“ Antwort gewartet hast, wurde das Modell bereits verändert, sodass 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**** und dann plötzlich 4.
Da wir schlechte Antworten erhalten haben, wird RL das Modell beeinflussen, NICHT mehr schlechte Antworten auszugeben. Das bedeutet, dass wir im Laufe der Zeit sorgfältig die Ausgabeverteilung des Modells von schlechten Antworten „beschneiden“ oder wegbewegen. Das heißt, RL ist effizient, da wir nicht einfach auf die Unendlichkeit warten, sondern aktiv versuchen, das Modell so weit wie möglich in den „korrekten Antwortraum“ zu „drücken“.
Wenn die Wahrscheinlichkeit immer 0 ist, wird RL niemals funktionieren. Deshalb machen Leute RL häufig von einem bereits instruktion-feinabgestimmten Modell aus, das Anweisungen teilweise vernünftig folgen kann – das erhöht die Wahrscheinlichkeit sehr wahrscheinlich über 0.
🦥Was Unsloth für RL bietet
Mit 15 GB VRAM ermöglicht Unsloth dir, jedes Modell 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/multimodale Modelle!
Mindestanforderung: Nur 5 GB VRAM reichen aus, um lokal dein eigenes Reasoning-Modell zu trainieren (für jedes Modell mit 1,5B Parametern oder weniger)
Für erweiterte GRPO Dokumentation zu Batching, Generierung und Trainingsparametern, lesen Sie unseren Leitfaden!
GRPO-Notebooks:
Wir unterstützen GSPO und die meisten anderen neuen GRPO-Techniken. Du kannst mit den folgenden Argumenten in GRPOConfig spielen, um zu aktivieren:
Wenn du kein Reasoning bekommst, stelle sicher, dass du genügend Trainingsschritte hast und überprüfe, ob deine Belohnungsfunktion/Verifizierer funktioniert. Wir stellen Beispiele für Belohnungsfunktionen bereit hier.
Frühere Demonstrationen zeigen, dass du deinen eigenen „Aha“-Moment mit Qwen2.5 (3B) erreichen könntest – aber es benötigte 2x A100 GPUs (160GB VRAM). Jetzt, mit Unsloth, kannst du denselben „Aha“-Moment mit nur einer einzigen 5GB-VRAM-GPU erreichen.
Früher wurde GRPO nur für Full Fine-Tuning unterstützt, aber wir haben es so angepasst, dass es mit QLoRA und LoRA funktioniert
Bei 20K Kontextlängen 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, dies ist nicht das Fine-Tuning von DeepSeeks R1-distillierten Modellen oder die Verwendung distillierter R1-Daten zum Abstimmen, was Unsloth bereits unterstützte. Es geht darum, ein Standardmodell mithilfe von GRPO in ein vollwertiges Reasoning-Modell zu konvertieren.
In einem Testbeispiel, obwohl wir Phi-4 nur mit 100 Schritten unter Verwendung von GRPO trainierten, sind die Ergebnisse bereits deutlich. Das Modell ohne GRPO hat nicht das Thinking-Token, während das mit GRPO trainierte Modell es hat und außerdem die richtige Antwort liefert.
💻Training mit GRPO
Für ein Tutorial, wie man jedes offene LLM mit Unsloth & GRPO in ein Reasoning-Modell verwandelt, siehe hier.
Für erweiterte GRPO Dokumentation zu Batching, Generierung und Trainingsparametern, lesen Sie unseren Leitfaden!
Wie GRPO ein Modell trainiert
Für jedes Frage-Antwort-Paar generiert das Modell mehrere mögliche Antworten (z. B. 8 Variationen).
Jede Antwort wird mit Belohnungsfunktionen bewertet.
Trainingsschritte:
Wenn du 300 Datenzeilen hast, sind das 300 Trainingsschritte (oder 900 Schritte bei 3 Epochen).
Du kannst die Anzahl der generierten Antworten pro Frage erhöhen (z. B. von 8 auf 16).
Das Modell lernt, indem es seine Gewichte bei jedem Schritt aktualisiert.
Wenn Ihr GRPO-Modell nicht lernt, empfehlen wir dringend die Verwendung unserer Advanced GRPO notebooks da diese eine deutlich bessere Belohnungsfunktion haben und Sie schneller und häufiger Ergebnisse sehen sollten.
Grundlagen/Tipps
Warte mindestens 300 Schritte damit die Belohnung tatsächlich steigt. Um brauchbare Ergebnisse zu erzielen, musst du möglicherweise mindestens 12 Stunden investieren (so funktioniert GRPO), aber beachte, dass dies nicht obligatorisch ist, da du jederzeit stoppen kannst.
Für optimale Ergebnisse solltest du mindestens 500 Datenzeilenhaben. Du kannst es auch mit nur 10 Datenzeilen versuchen, aber mehr ist besser.
Jeder Trainingslauf wird immer unterschiedlich sein, abhängig von deinem Modell, den Daten, der Belohnungsfunktion/Verifizierer usw. Daher sind zwar 300 Schritte als Minimum angegeben, manchmal können es 1000 Schritte oder mehr sein. Es hängt also von verschiedenen Faktoren ab.
Wenn du GRPO lokal mit Unsloth verwendest, führe bitte zusätzlich „pip install diffusers“ aus, 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 für QLoRA 4-bit, gilt die allgemeine Regel: Die Modellparameter = die Menge an VRAM, die du benötigen wirst (du kannst weniger VRAM verwenden, dies ist aber nur eine Sicherheitsannahme). Je mehr Kontextlänge du einstellst, desto mehr VRAM wird benötigt. LoRA in 16-Bit benötigt mindestens das 4-fache an VRAM.
Kontinuierliches Fine-Tuning ist möglich und du kannst GRPO einfach im Hintergrund laufen lassen.
In den Beispielnotebooks verwenden wir das GSM8K-Dataset, die aktuell populärste Wahl für R1-ähnliches 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 so viele Daten brauchst. Alles, was du brauchst, ist eine großartige Belohnungsfunktion/Verifizierer und je mehr Zeit du mit dem Training verbringst, desto besser wird dein Modell. Erwarte, dass sich Belohnung vs. Schritte im Laufe der Zeit so erhöht:
Die Verfolgung des Trainingsverlusts für GRPO ist jetzt direkt in Unsloth integriert, wodurch externe Tools wie wandb usw. entfallen. Es enthält jetzt vollständige Protokollierungsdetails für alle Belohnungsfunktionen, einschließlich der aggregierten Gesamtbelohnungsfunktion selbst.
RL auf nicht unterstützten Modellen:
Du kannst RL mit Unsloth auch auf Modellen ausführen, die nicht von vLLM unterstützt werden, wie z. B. Qwen3.5. Setze einfach Sie können Qwen3.5 RL mit Unsloth ausführen, obwohl es von vLLM nicht unterstützt wird, indem Sie setzen beim Laden des Modells.
📋Belohnungsfunktionen / Verifizierer
Im Reinforcement Learning dienen eine Belohnungsfunktion und ein Verifizierer unterschiedlichen Rollen bei der Bewertung der Ausgabe eines Modells. Im Allgemeinen kannst du sie als dasselbe interpretieren; technisch sind sie es jedoch nicht, aber das spielt weniger eine Rolle, da sie normalerweise zusammen verwendet werden.
Verifizierer:
Bestimmt, ob die generierte Antwort korrekt oder inkorrekt ist.
Weist keine numerische Punktzahl zu – es verifiziert lediglich die Korrektheit.
Beispiel: Wenn ein Modell „5“ für „2+2“ generiert, prüft der Verifizierer und kennzeichnet es als „falsch“ (da die korrekte Antwort 4 ist).
Verifizierer können auch Code ausführen (z. B. in Python), um Logik, Syntax und Korrektheit zu validieren, ohne manuelle Auswertung zu benötigen.
Belohnungsfunktion:
Wandelt Verifikationsergebnisse (oder andere Kriterien) in eine numerische Bewertung um.
Beispiel: Wenn eine Antwort falsch ist, könnte eine Strafe (-1, -2 usw.) zugewiesen werden, während eine korrekte Antwort eine positive Punktzahl (+1, +2) erhalten könnte.
Sie kann auch basierend auf Kriterien jenseits der Korrektheit bestrafen, wie z. B. übermäßige Länge oder schlechte Lesbarkeit.
Hauptunterschiede:
Ein Verifizierer prüft Korrektheit, aber vergibt keine Punktzahl.
Ein Belohnungsfunktion weist eine Punktzahl zu, prüft jedoch nicht unbedingt selbst die Korrektheit.
Eine Belohnungsfunktion kann einen Verifizierer nutzen, technisch sind sie aber nicht dasselbe.
Verstehen von Belohnungsfunktionen
GRPOs Hauptziel ist es, die Belohnung zu maximieren und zu lernen, wie eine Antwort abgeleitet wurde, statt einfach Antworten aus seinen Trainingsdaten auswendig zu lernen und zu reproduzieren.
Mit jedem Trainingsschritt passt GRPO die Modellgewichte an um die Belohnung zu maximieren. Dieser Prozess fine-tuned das Modell schrittweise.
Reguläres Fine-Tuning (ohne GRPO) maximiert nur die Wahrscheinlichkeit der Vorhersage des nächsten Wortes optimiert aber nicht für eine Belohnung. GRPO optimiert für eine Belohnungsfunktion anstatt nur das nächste Wort vorherzusagen.
Du musst normalerweise einen Datensatz mit 2 Spalten erstellen – Frage und Antwort. Qualität und Menge spiegeln weitgehend das Endergebnis deines Fine-Tunings wider, daher ist es entscheidend, diesen Teil richtig zu machen. Wiederverwendung von Daten über mehrere Epochen hinweg.
Standard-Belohnungsfunktionen können vordefiniert sein, um in einer Vielzahl von Anwendungsfällen verwendet zu werden, oder du kannst ChatGPT/lokales Modell 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.
🪙Beispiele für Belohnungsfunktionen
Du kannst dich auf die folgenden Beispiele beziehen. Du kannst deine Generierungen in ein LLM wie ChatGPT 4o oder Llama 3.1 (8B) einspeisen und eine Belohnungsfunktion und einen Verifizierer entwerfen, um sie zu bewerten. Zum Beispiel: Füttere deine Generierungen in ein LLM deiner Wahl und setze eine Regel: „Wenn die Antwort zu roboterhaft klingt, ziehe 3 Punkte ab.“ Das hilft, Ausgaben anhand von Qualitätskriterien zu verfeinern.
Beispiel #1: Einfache arithmetische Aufgabe
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 korrekten 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
Unsloth proximitätsbasierte Belohnungsfunktion
Wenn du unser Advanced GRPO Colab Notebookangeschaut hast, wirst du bemerken, dass wir eine benutzerdefinierte proximitätsbasierte Belohnungsfunktion vollständig von Grund auf erstellt haben, die darauf ausgelegt ist, Antworten zu belohnen, die der korrekten näher sind. Diese flexible Funktion kann auf eine Vielzahl von Aufgaben angewendet werden.
In unseren Beispielen aktivieren wir Reasoning in Qwen3 (Base) und leiten es in Richtung spezifischer Aufgaben
Wende Pre-Finetuning-Strategien an, um GRPOs Tendenz zu vermeiden, nur Formatierung zu lernen
Steigere die Bewertungsgenauigkeit mit regex-basierter Zuordnung
Erstelle benutzerdefinierte GRPO-Vorlagen über generische Prompts wie
think, z. B.<start_working_out></end_working_out>Wende proximitätsbasierte Bewertung an — Modelle erhalten mehr Belohnung für näher liegende Antworten (z. B. ist die Vorhersage 9 statt 10 besser als 3), während Ausreißer bestraft werden
GSM8K-Belohnungsfunktionen
In unseren anderen Beispielen verwenden wir vorhandene GSM8K-Belohnungsfunktionen von @willccbb die beliebt sind und sich als recht effektiv erwiesen haben:
correctness_reward_func – Belohnt exakte Übereinstimmung mit Labels.
int_reward_func – Fördert ausschließlich ganzzahlige Antworten.
soft_format_reward_func – Prüft Struktur, erlaubt aber geringfügige Newline-Abweichungen.
strict_format_reward_func – Stellt sicher, dass die Antwortstruktur mit dem Prompt übereinstimmt, einschließlich Zeilenumbrüchen.
xmlcount_reward_func – Stellt sicher, dass genau ein Exemplar jedes XML-Tags in der Antwort vorhanden ist.
🧮Verwendung von vLLM
Du kannst jetzt vLLM direkt in deinem Finetuning-Stack verwenden, was viel höheren Durchsatz ermöglicht und es dir erlaubt, das Modell gleichzeitig zu finetunen und Inferenz durchzuführen! Auf 1x A100 40GB sind mit Unslo-ths dynamischer 4-Bit-Quantisierung von Llama 3.2 3B Instruct etwa 4000 Token/s zu erwarten. Auf einer 16GB Tesla T4 (kostenlose Colab-GPU) kannst du etwa 300 Token/s erreichen. Wir haben außerdem magisch die doppelte Speicherverwendung beim gleichzeitigen Laden von vLLM und Unsloth entfernt, wodurch Einsparungen von etwa 5 GB für Llama 3.1 8B und 3 GB für Llama 3.2 3B möglich sind. Unsloth konnte ursprünglich Llama 3.3 70B Instruct auf 1x 48GB GPU fine-tunen, wobei die Llama 3.3 70B-Gewichte 40GB VRAM beanspruchten. Wenn wir die doppelte Speicherverwendung nicht entfernen würden, bräuchten wir >= 80GB VRAM beim gleichzeitigen Laden von Unsloth und vLLM. Mit Unsloth kannst du jedoch weiterhin fine-tunen und die Vorteile schneller Inferenz in einem Paket unter 48GB VRAM nutzen! Um schnelle Inferenz zu verwenden, installiere zuerst vllm und instanziiere Unsloth mit fast_inference:
✅GRPO-Anforderungsrichtlinien
Wenn du Unsloth für GRPO verwendest, reduzieren wir den VRAM-Verbrauch im Vergleich zu Standardimplementierungen mit Flash Attention 2 durch mehrere Tricks um über 90%! Bei 20K Kontextlängen mit 8 Generierungen pro Prompt verwendet Unsloth zum Beispiel nur 54,3 GB VRAM für Llama 3.1 8B, während Standardimplementierungen 510,8 GB (90% weniger für Unsloth).
Für GRPOs GPU-VRAM-Anforderungen für QLoRA 4-bit, gilt die allgemeine Regel: Die Modellparameter = die Menge an VRAM, die du benötigen wirst (du kannst weniger VRAM verwenden, dies ist aber nur eine Sicherheitsannahme). Je mehr Kontextlänge du einstellst, desto mehr VRAM wird benötigt. LoRA in 16-Bit benötigt mindestens das 4-fache an VRAM.
Unsere neuen speichereffizienten linearen Kernel für GRPO reduzieren den Speicherverbrauch um das 8-fache oder mehr. Das spart 68,5 GB Speicher, während es durch die Hilfe von torch.compile tatsächlich schneller ist!
Wir nutzen unser intelligentes Unsloth Gradient-Checkpointing Algorithmus, den wir vor einiger Zeit veröffentlicht haben. Er lagert Zwischenaktivierungen asynchron in den Systemspeicher aus und ist dabei nur 1% langsamer. Das spart 52 GB Speicher.
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.
Trainingsspeicherkosten (GB)
42GB
414GB
GRPO-Speicherkosten (GB)
9,8GB
78,3GB
Inferenzkosten (GB)
0GB
16GB
Inference KV-Cache für 20K Kontextlänge (GB)
2,5GB
2,5GB
Gesamtspeichernutzung
54,33GB (90% weniger)
510,8GB
In typischen Standard-GRPO-Implementierungen musst du 2 Logits der Größe (8, 20K) erstellen, um den GRPO-Loss zu berechnen. Das benötigt 2 * 2 Bytes * 8 (Anzahl Generierungen) * 20K (Kontextlänge) * 128256 (Vokabulargröße) = 78,3GB VRAM.
Unsloth reduziert die Speichernutzung für GRPO mit langem Kontext um das 8-fache, sodass wir für 20K Kontextlängen nur zusätzliche 9,8GB 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 sind in der Größe 1024. Also ist die Speichernutzung für 20K Kontextlänge = 2 * 2 Bytes * 32 Schichten * 20K Kontextlänge * 1024 = 2,5GB pro Batch. Wir würden die Batchgröße für vLLM auf 8 setzen, aber wir belassen sie für unsere Berechnungen auf 1, um VRAM zu sparen. Andernfalls bräuchtest du 20GB für den KV-Cache.
🎥 Unsloth RL 3-Stunden-Workshop-Video
🎓Weiterführende Lektüre
Nathan Lamberts RLHF-Buch ist ein Muss! https://rlhfbook.com/c/11-policy-gradients.html
Yannic Kilchers GRPO-YouTube-Video ist ebenfalls ein Muss! https://www.youtube.com/watch?v=bAWV_yrqx4w
Wir haben 2025 einen 3-stündigen Workshop auf der AI Engineer World's Fair gehalten. Folien und weiteres Material sind unter https://docs.unsloth.ai/ai-engineers-2025
Advanced GRPO-Notebook via Unsloth. https://docs.unsloth.ai/basics/reinforcement-learning-guide/tutorial-train-your-own-reasoning-model-with-grpo
GRPO-von-einem-Basismodell-Notebook: https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb
oder in anderen Inferenz-Engines verwendet werden.
Video-Tutorials
Zuletzt aktualisiert
War das hilfreich?