⚡Tutorial: Trainiere dein eigenes Reasoning-Modell mit GRPO

Installieren Sie Unsloth

Wenn Sie unser Colab-Notizbuch verwenden, klicken Sie Runtime > Run all. Wir empfehlen dringend, vorher unser Fine-tuning Guide durchzulesen, bevor Sie beginnen.

Wenn Sie lokal installieren, stellen Sie sicher, dass Sie die richtigen Abhängigkeiten haben und verwenden pip install unsloth unter Linux oder folgen Sie unserer Windows-Installation Anleitung.

Erfahren Sie mehr über GRPO & Belohnungsfunktionen

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

Sie benötigen außerdem ausreichend VRAM. Im Allgemeinen gilt: Modellparameter = Menge an VRAM, die Sie benötigen. In Colab verwenden wir ihre kostenlosen 16GB-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 für Sie ausgewählt, und Sie können das Modell auf eines der in unseren unterstützten Modelleaufgelisteten Modelle ändern. Wenn Sie Anfänger sind, empfehlen wir nicht, andere Einstellungen zu ändern.

Datenvorbereitung

Wir haben OpenAIs GSM8K Datensatz vorausgewählt, der Grundschul-Mathematikaufgaben enthält, aber Sie können ihn durch Ihren eigenen oder jeden öffentlichen Datensatz auf Hugging Face ersetzen. Mehr über Datensätze hier.

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

Wir strukturieren die Daten so, dass das Modell dazu angeregt wird, seine Begründung darzulegen, bevor es eine Antwort liefert. Zuerst legen wir ein klares Format für Aufforderungen und Antworten fest.

# Definieren Sie den System-Prompt, der 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, zur Vorbereitung des Datensatzes:

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.

Belohnungsfunktionen/Verifizierer

Belohnungsfunktionen/Verifizierer teilt uns mit, ob das Modell gut arbeitet oder nicht, basierend auf dem von Ihnen bereitgestellten Datensatz. Jeder Generierungslauf wird danach bewertet, wie er im Vergleich zum Durchschnitt der übrigen Generierungen abschneidet. Sie können eigene Belohnungsfunktionen erstellen; wir haben sie jedoch bereits für Sie mit Will's GSM8K Belohnungsfunktionen vorausgewählt. Damit haben wir 5 verschiedene Möglichkeiten, wie wir jede Generierung bewerten können.

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

Beispiel für eine Belohnungsfunktion für eine 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

Trainieren Sie Ihr Modell

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

Die 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 Vervollständigungen an.

• max_steps: 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. Manche können Schritte, XML-Tags, Versuche usw. enthalten, und die Idee ist, dass es mit dem Training immer besser wird, weil es höhere Bewertungen erhält, bis wir die gewünschten Ausgaben mit langen Begründungsketten erreichen.

Starten & Bewerten Sie Ihr Modell

Starten Sie Ihr Modell, indem Sie auf die Wiedergabetaste 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, die wir gerade mit GRPO trainiert haben, speichern mit:

model.save_lora("grpo_saved_lora")

Dann laden wir die LoRA und testen sie. Unser Reasoning-Modell ist viel 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 Belohnungsfunktion/Verifizierer war nicht optimal.

Speichern Sie Ihr Modell hier

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

Speicherung in 16-Bit-Präzision

Sie können das Modell mit 16-Bit-Präzision mit folgendem Befehl speichern:
# In 16-Bit-Präzision speichern

model.save_pretrained_merged("model", tokenizer, save_method="merged_16bit")

Zum Hugging Face Hub pushen Um Ihr Modell zu teilen, pushen wir es zum Hugging Face Hub mit der push_to_hub_merged

Methode. Dadurch kann das Modell in mehreren Quantisierungsformaten gespeichert werden.
# Push zum Hugging Face Hub (erfordert ein Token)
    model.push_to_hub_merged(
)

"your-username/model-name", tokenizer, save_method="merged_16bit", token="your-token"

Speicherung im GGUF-Format für llama.cpp GGUF-FormatUnsloth unterstützt auch das Speichern in llama.cpp und Ollama.

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

token="your-token", llama.cpp Sobald im GGUF-Format gespeichert, kann das Modell in leichtgewichtigen Umgebungen einfach bereitgestellt werden mit