💡Leitfaden zu Reinforcement Learning (RL)
Lerne alles über Reinforcement Learning (RL) und wie du mit Unsloth und GRPO dein eigenes DeepSeek-R1-Reasoning-Modell trainierst. Ein vollständiger Leitfaden von Anfänger bis Fortgeschrittene.
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).
🦥Was du lernen wirst
Was ist RL? RLVR? PPO? GRPO? RLHF? Ist „Luck is All You Need?“ für RL?
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. Wenn du nach einem Schritt-für-Schritt-Tutorial zur Verwendung von GRPO suchst, sieh dir unseren Leitfaden hier.
Update vom 15. Jan. 2026: Ultra-langer Kontext RL 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
❓Was ist Reinforcement Learning (RL)?
Das Ziel von RL ist es,
die Wahrscheinlichkeit zu erhöhen, „gute“ Ergebnisse zu sehen.
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.
Zum Beispiel im Pacman-Spiel:
ist die Umgebung die Spielwelt.
ist die Aktionen die du ausführen kannst, sind OBEN, LINKS, RECHTS und UNTEN.
ist die Belohnungen sind gut, wenn du einen Keks isst, oder schlecht, wenn du einen der schlängelnden Gegner triffst.
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).
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.
Zahlen sind besser als C oder D, oder?
3 zu bekommen ist besser als zum Beispiel 8, oder?
4 zu bekommen ist definitiv korrekt.
Wir haben gerade eine Belohnungsfunktion!
🏃Von RLHF, PPO bis GRPO und RLVR
OpenAI machte das Konzept von RLHF (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.
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.
Um RLHF durchzuführen, PPO (Proximal Policy Optimization) wurde entwickelt. Der Agent ist in diesem Fall das Sprachmodell. Tatsächlich besteht es aus 3 Systemen:
ist die Generierende Policy (aktuell trainiertes Modell)
ist die Referenz-Policy (ursprüngliches Modell)
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 den wir 2025 über RL gehalten haben, für ausführlichere mathematische Herleitungen zu PPO.
DeepSeek entwickelte GRPO (Group Relative Policy Optimization), um ihre R1-Reasoning-Modelle zu trainieren. Die wichtigsten Unterschiede zu PPO sind:
ist die Das Wertemodell wird entfernt, ersetzt durch Statistiken aus mehrfachen Aufrufen des Belohnungsmodells.
ist die Das Belohnungsmodell wird entfernt und durch eine nur benutzerdefinierte Belohnungsfunktion ersetzt, die RLVR verwenden kann.
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:
Mathematische Gleichungen lassen sich leicht überprüfen. Z. B. 2+2 = 4.
Code-Ausgaben können darauf überprüft werden, ob sie korrekt ausgeführt wurden oder nicht.
Verifizierbare Belohnungsfunktionen zu entwerfen kann schwierig sein, daher sind die meisten Beispiele Mathematik oder Code.
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) Angebot zum Beispiel.
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.
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!
🤞Glück (naja, Geduld) ist alles, was du brauchst
Der Trick bei RL ist, dass du nur 2 Dinge brauchst:
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 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 Rolloutsgefunden. 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.
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.
🦥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- 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)
Für fortgeschrittenes GRPO Dokumentation zu Batching, Generierung und Trainingsparametern, lies unseren Leitfaden!
GRPO-Notebooks:
Wir unterstützen GSPO und die meisten anderen neuen GRPO-Techniken. Du kannst in GRPOConfig mit den folgenden Argumenten spielen, um zu aktivieren:
Wenn du kein Reasoning bekommst, stelle sicher, dass du genügend Trainingsschritte hast und dass deine Belohnungsfunktion/dein Verifizierer funktioniert. Wir stellen Beispiele für Belohnungsfunktionen bereit hier.
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 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.
💻Training mit GRPO
Für ein Tutorial dazu, wie du jedes offene LLM mit Unsloth & GRPO in ein Reasoning-Modell verwandelst, sieh hier.
Für fortgeschrittenes GRPO Dokumentation zu Batching, Generierung und Trainingsparametern, lies unseren Leitfaden!
Wie GRPO ein Modell trainiert
Für jedes Frage-Antwort-Paar generiert das Modell mehrere mögliche Antworten (z. B. 8 Varianten).
Jede Antwort wird mithilfe von Belohnungsfunktionen bewertet.
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).
Das Modell lernt, indem es seine Gewichte bei jedem Schritt aktualisiert.
Wenn dein GRPO-Modell nicht lernt und du Probleme hast, empfehlen wir dir dringend, unsere Fortgeschrittenen GRPO-Notebooks zu verwenden, da sie eine deutlich bessere Belohnungsfunktion haben und du Ergebnisse viel schneller und häufiger sehen solltest.
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 Datenzeilenverwenden. 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 für QLoRA 4-Bitgilt 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, 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. Setze einfach fast_inference=False beim Laden des Modells.
📋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.
🪙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-Notebookangesehen 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.<start_working_out></end_working_out>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 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.
🧮vLLM verwenden
Du kannst jetzt 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:
✅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).
Für GRPOs GPU-VRAM-Anforderungen für QLoRA 4-Bitgilt 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.
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!
Wir nutzen unser intelligentes Unsloth-Gradient-Checkpointing 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.
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.
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
🎓Weiterführende Lektüre
Nathan Lamberts RLHF-Buch ist ein Muss! https://rlhfbook.com/c/11-policy-gradients.html
Auch das GRPO-YouTube-Video von Yannic Kilcher ist ein Muss! https://www.youtube.com/watch?v=bAWV_yrqx4w
Wir haben 2025 auf der AI Engineer World's Fair einen 3-stündigen Workshop durchgeführt. Folien und weiteres Material findest du unter https://docs.unsloth.ai/ai-engineers-2025
Fortgeschrittenes GRPO-Notebook über Unsloth. https://docs.unsloth.ai/basics/reinforcement-learning-guide/tutorial-train-your-own-reasoning-model-with-grpo
GRPO-Notebook von einem Basismodell: https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_(4B)-GRPO.ipynb
Video-Tutorials
Hier sind einige Video-Tutorials von großartigen YouTubern, die wir fantastisch finden!
Zuletzt aktualisiert
War das hilfreich?