⚡Tutorial: Trainiere dein eigenes Reasoning-Modell mit GRPO

Unsloth installieren

Wenn Sie unser Colab-Notebook verwenden, klicken Sie Runtime > Run all. Wir empfehlen dringend, dass Sie sich unser Feinabstimmungsanleitung ansehen, bevor Sie beginnen.

Wenn Sie lokal installieren, stellen Sie sicher, dass Sie die richtigen Anforderungen haben und verwenden Sie Beachten Sie, dass unter Linux oder folgen Sie unserer Windows-Installations- Anleitung.

Erfahren Sie mehr über GRPO & Reward-Funktionen

Bevor wir beginnen, wird empfohlen, mehr über GRPO, Reward-Funktionen und deren Funktionsweise zu lernen. Lesen Sie mehr darüber einschließlich Tipps & Tricks hier.

Sie benötigen außerdem ausreichend VRAM. Allgemein gilt: Modellparameter = benötigte Menge VRAM. In Colab verwenden wir deren kostenlose 16-GB-VRAM-GPUs, mit denen jedes Modell bis zu 16B Parametern trainiert werden kann.

Gewünschte Einstellungen konfigurieren

Wir haben bereits optimale Voreinstellungen für die besten Ergebnisse ausgewählt, und Sie können das Modell auf eines der in unseren unterstützten Modelleändern. Wir empfehlen Anfängern nicht, andere Einstellungen zu verändern.

Datenvorbereitung

Wir haben OpenAIs vorgewähltes GSM8K Datensatz ausgewählt, der Schulmatheaufgaben enthält, aber Sie können ihn durch Ihren eigenen oder einen öffentlichen auf Hugging Face ersetzen. Mehr über Datensätze hier.

Ihr Datensatz sollte weiterhin mindestens 2 Spalten für Frage- und Antwortpaare enthalten. Die Antwort darf jedoch nicht die Begründung offenlegen, wie sie aus der Frage abgeleitet wurde. Siehe unten ein Beispiel:

Wir strukturieren die Daten so, dass das Modell aufgefordert wird, seine Begründung zu formulieren, bevor es eine Antwort liefert. Zuerst legen wir ein klares Format für Prompts und Antworten fest.

# Definieren Sie das System-Prompt, das das Modell anweist, ein bestimmtes Format zu verwenden
SYSTEM_PROMPT = """
Antworten Sie im folgenden Format:
<reasoning>
...
</reasoning>
<answer>
...
</answer>
"""

XML_COT_FORMAT = """\
<reasoning>
{reasoning}
</reasoning>
<answer>
{answer}
</answer>
"""

Nun, um den Datensatz vorzubereiten:

import re
from datasets import load_dataset, Dataset


# Hilfsfunktionen zum Extrahieren von Antworten aus verschiedenen Formaten
def extract_xml_answer(text: str) -> str:
    answer = text.split("<answer>")[-1]
    answer = answer.split("</answer>")[0]
    return answer.strip()


def extract_hash_answer(text: str) -> str | None:
    if "####" not in text:
        return None
    return text.split("####")[1].strip()


# Funktion zur Vorbereitung des GSM8K-Datensatzes
def get_gsm8k_questions(split="train") -> Dataset:
    data = load_dataset("openai/gsm8k", "main")[split]
    data = data.map(
        lambda x: {
            "prompt": [
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": x["question"]},
            ],
            "answer": extract_hash_answer(x["answer"]),
        }
    )
    return data


dataset = get_gsm8k_questions()

Der Datensatz wird vorbereitet, indem die Antworten extrahiert und als strukturierte Strings formatiert werden.

Reward-Funktionen/Verifier

Reward-Funktionen/Verifier teilen uns mit, ob das Modell anhand des bereitgestellten Datensatzes gut arbeitet oder nicht. Jeder Generierungslauf wird danach bewertet, wie er im Vergleich zum Durchschnitt der übrigen Generierungen abschneidet. Sie können eigene Reward-Funktionen erstellen, jedoch haben wir sie bereits für Sie mit Will's GSM8K Reward-Funktionen vorausgewählt. Damit haben wir 5 verschiedene Möglichkeiten, jede Generierung zu bewerten.

Sie können Ihre Generierungen in ein LLM wie ChatGPT 4o oder Llama 3.1 (8B) einspeisen und eine Reward-Funktion sowie einen Verifier entwerfen, um sie zu bewerten. Zum Beispiel: Geben Sie Ihre Generierungen in ein LLM Ihrer Wahl und setzen Sie eine Regel: "Wenn die Antwort zu robotisch klingt, ziehe 3 Punkte ab." Das hilft, die Ausgaben anhand von Qualitätskriterien zu verfeinern. Siehe Beispiele wie sie aussehen können hier.

Beispiel für eine Reward-Funktion für eine E-Mail-Automatisierungsaufgabe:

• Frage: Eingehende E-Mail

• Antwort: Ausgehende E-Mail

• Reward-Funktionen:

  • 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

Trainiere dein Modell

Wir haben Hyperparameter für die optimalen Ergebnisse voreingestellt, aber Sie können sie ändern. Lesen Sie alles über Parameter hier. Für erweiterte GRPO Dokumentation zu Batch-Verarbeitung, Generierung und Trainingsparametern, lesen Sie unseren Leitfaden!

Der GRPOConfig definiert wichtige Hyperparameter für das Training:

• use_vllm: Aktiviert schnelle Inferenz mit vLLM.

• learning_rate: Bestimmt die Lernrate des Modells.

• num_generations: Gibt die Anzahl der pro Prompt generierten Abschlüsse an.

• max_steps = 60, # num_train_epochs = 1,: Legt die Gesamtanzahl der Trainingsschritte fest.

epsilon=0.2,
epsilon_high=0.28, # einseitig
delta=1.5 # zweiseitig

loss_type='bnpo',
# oder:
loss_type='grpo',
# oder:
loss_type='dr_grpo',
# oder:
loss_type='dapo',

mask_truncated_completions=True,

Sie sollten sehen, wie die Belohnung im Laufe der Zeit steigt. Wir empfehlen, mindestens 300 Schritte zu trainieren, was etwa 30 Minuten dauern kann. Für optimale Ergebnisse sollten Sie jedoch länger trainieren.

Sie werden auch Beispielantworten sehen, die zeigen, wie das Modell lernt. Einige können Schritte, XML-Tags, Versuche usw. enthalten. Die Idee ist, dass das Training das Modell kontinuierlich verbessert, weil es höher bewertet wird, bis wir die gewünschten Ausgaben mit langen Begründungsketten erhalten.

Modell ausführen & bewerten

Führen Sie Ihr Modell aus, indem Sie den Play-Button klicken. Im ersten Beispiel gibt es normalerweise keine Begründung in der Antwort, und um die Begründung zu sehen, müssen wir zuerst die LoRA-Gewichte speichern, die wir gerade mit GRPO trainiert haben, mit:

model.save_lora("grpo_saved_lora")

Dann laden wir die LoRA und testen sie. Unser Reasoning-Modell ist deutlich besser – es ist nicht immer korrekt, da wir es nur etwa eine Stunde trainiert haben – es wird besser, wenn wir die Sequenzlänge verlängern und länger trainieren!

Sie können Ihr Modell dann in GGUF, Ollama usw. speichern, indem Sie unserer Anleitung hier.

folgen. Wenn Sie immer noch keine Begründungen erhalten, haben Sie möglicherweise zu wenige Schritte trainiert oder Ihre Reward-Funktion/Verifier war nicht optimal.

Speichern Sie Ihr Modell

Wir haben mehrere Optionen zum Speichern Ihres feinabgestimmten Modells, konzentrieren uns hier jedoch auf die einfachsten und beliebtesten Ansätze, über die Sie mehr lesen können hier

Speichern mit 16-Bit-Präzision

Sie können das Modell mit 16-Bit-Präzision mit dem folgenden Befehl speichern:

# In 16-Bit-Präzision speichern
model.save_pretrained_merged("model", tokenizer, save_method="merged_16bit")

Auf Hugging Face Hub pushen

Um Ihr Modell zu teilen, pushen wir es auf den Hugging Face Hub mit der push_to_hub_merged Methode. Dies ermöglicht das Speichern des Modells in mehreren Quantisierungsformaten.

# Auf Hugging Face Hub pushen (erfordert ein Token)
model.push_to_hub_merged(
    "your-username/model-name", tokenizer, save_method="merged_16bit", token="your-token"
)

Speichern im GGUF-Format für llama.cpp

Unsloth unterstützt auch das Speichern im GGUF-Format, wodurch es kompatibel mit llama.cpp und Ollama.

model.push_to_hub_gguf(
    "your-username/model-name",
    tokenizer,
    quantization_method=["q4_k_m", "q8_0", "q5_k_m"],
    token="your-token",
)

Sobald im GGUF-Format gespeichert, kann das Modell einfach in leichten Umgebungen bereitgestellt werden mit llama.cpp oder in anderen Inferenz-Engines verwendet werden.