👁️‍🗨️Vision Reinforcement Learning (VLM RL)

Trainiere Vision-/multimodale Modelle über GRPO und RL mit Unsloth!

Unsloth unterstützt jetzt Vision/Multimodal-RL mit Qwen3-VL, Gemma 3 und mehr. Aufgrund von Unsloths einzigartigem Gewichtsteilung und benutzerdefinierten Kernen macht Unsloth VLM-RL 1,5–2× schneller, verwendet 90 % weniger VRAMund ermöglicht 15× längere Kontext längen als FA2-Setups, ohne Genauigkeitsverlust. Dieses Update führt außerdem Qwens GSPO Algorithmus.

Unsloth kann Qwen3-VL-8B mit GSPO/GRPO auf einer kostenlosen Colab T4 GPU trainieren. Andere VLMs funktionieren ebenfalls, benötigen aber möglicherweise größere GPUs. Gemma erfordert neuere GPUs als T4, weil vLLM auf Bfloat16 beschränkt, daher empfehlen wir NVIDIA L4 auf Colab. Unsere Notebooks lösen numerische Mathematikaufgaben mit Bildern und Diagrammen:

• Qwen-3 VL-8B (vLLM-Inferenz): Colab

• Qwen-2.5 VL-7B (vLLM-Inferenz): Colab • Kaggle

• Gemma-3-4B (Unsloth-Inferenz): Colab

Wir haben vLLM-VLM-Integration außerdem nativ in Unsloth hinzugefügt, sodass Sie für die Verwendung der vLLM-Inferenz nur das fast_inference=True Flag beim Initialisieren des Modells aktivieren müssen. Besonderer Dank an Sinoué GAD für die Bereitstellung des ersten Notebooks das die Integration von VLM-RL erleichtert hat!

Diese VLM-Unterstützung integriert auch unser neuestes Update für noch speichereffizienteres und schnelleres RL einschließlich unserer Standby-Funktion, die im Vergleich zu anderen Implementierungen einzigartig die Geschwindigkeitsverschlechterung begrenzt.

Sie können nur fast_inference für VLMs verwenden, die von vLLM unterstützt werden. Einige Modelle, wie Llama 3.2 Vision, können daher nur ohne vLLM laufen, funktionieren aber trotzdem in Unsloth.

os.environ['UNSLOTH_VLLM_STANDBY'] = '1' # Um speichereffizientes GRPO mit vLLM zu aktivieren
model, tokenizer = FastVisionModel.from_pretrained(
    model_name = "Qwen/Qwen2.5-VL-7B-Instruct",
    max_seq_length = 16384, # Muss so groß sein, um das Bild im Kontext unterzubringen
    load_in_4bit = True, # False für LoRA 16bit
    fast_inference = True, # vLLM Fast-Inferenz aktivieren
    gpu_memory_utilization = 0.8, # Reduzieren, wenn kein Speicher verfügbar ist
)

Es ist auch wichtig zu beachten, dass vLLM LoRA für Vision-/Encoder-Schichten nicht unterstützt, setzen Sie daher finetune_vision_layers = False beim Laden eines LoRA-Adapters. Sie KÖNNEN jedoch die Vision-Schichten ebenfalls trainieren, wenn Sie Inferenz über transformers/Unsloth verwenden.

# Fügen Sie dem Modell einen LoRA-Adapter für parameter-effizientes Fine-Tuning hinzu
model = FastVisionModel.get_peft_model(
    model,

    finetune_vision_layers     = False,# fast_inference unterstützt finetune_vision_layers noch nicht :(
    finetune_language_layers   = True, # False, wenn die Sprachschichten nicht feinabgestimmt werden
    finetune_attention_modules = True, # False, wenn die Attention-Schichten nicht feinabgestimmt werden
    finetune_mlp_modules       = True, # False, wenn die MLP-Schichten nicht feinabgestimmt werden

    r = lora_rank, # Wählen Sie eine beliebige Zahl > 0! Vorgeschlagen 8, 16, 32, 64, 128
    lora_alpha = lora_rank*2, # *2 beschleunigt das Training
    use_gradient_checkpointing = "unsloth", # Reduziert den Speicherverbrauch
    random_state = 3407,
)

🦋Qwen 2.5 VL Vision RL Probleme und Eigenheiten

Während des RL für Qwen 2.5 VL könnten Sie die folgende Inferenz-Ausgabe sehen:

 addCriterion
 <tool_call>\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n\n addCriterion\n\n 自动生成\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n addCriterion\n\n\n addCriterion\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Dies wurde berichtet ebenfalls im Qwen2.5-VL-7B-Instruct-Ausgabe unerwartete Ergebnisse "addCriterion". Tatsächlich sehen wir dies auch! Wir haben sowohl Nicht-Unsloth-, bfloat16- als auch float16-Maschinen und andere Dinge ausprobiert, aber es scheint weiterhin aufzutreten. Zum Beispiel Element 165, d.h. train_dataset[165] aus dem AI4Math/MathVista Datensatz ist unten:

Die Abbildung ist eine Draufsicht auf die von einem Rennfahrer zurückgelegte Strecke, als sein Auto mit der Streckenbegrenzung kollidiert. Kurz vor der Kollision bewegt er sich mit der Geschwindigkeit v_i=70 m/s entlang einer Geraden in einem Winkel von 30° zur Wand. Kurz nach der Kollision bewegt er sich mit der Geschwindigkeit v_f=50 m/s entlang einer Geraden in einem Winkel von 10° zur Wand. Seine Masse m beträgt 80 kg. Die Kollision dauert 14 ms. Wie groß ist die Magnitude der durchschnittlichen Kraft auf den Fahrer während der Kollision?

Und dann erhalten wir die oben genannten Wirrwar-Ausgaben. Man könnte eine Belohnungsfunktion hinzufügen, um das Hinzufügen von addCriterion zu bestrafen oder wirre Ausgaben zu bestrafen. Die andere Vorgehensweise ist jedoch, länger zu trainieren. Zum Beispiel sehen wir erst nach ungefähr 60 Schritten, dass das Modell tatsächlich durch RL lernt:

Erzwingung von <|assistant|> während der Generierung wird das Auftreten dieser wirren Ergebnisse wie erwartet reduzieren, da dies ein Instruct-Modell ist; dennoch ist es am besten, eine Belohnungsfunktion hinzuzufügen, um schlechte Generierungen zu bestrafen, wie im nächsten Abschnitt beschrieben.

🏅Belohnungsfunktionen zur Reduzierung von Wirrwarr

Um addCriterion und wirre Ausgaben zu bestrafen, haben wir die Belohnungsfunktion so angepasst, dass zu viel von addCriterion und Zeilenumbrüchen bestraft wird.

def formatting_reward_func(completions,**kwargs):
    import re
    thinking_pattern = f'{REASONING_START}(.*?){REASONING_END}'
    answer_pattern = f'{SOLUTION_START}(.*?){SOLUTION_END}'

    scores = []
    for completion in completions:
        score = 0
        thinking_matches = re.findall(thinking_pattern, completion, re.DOTALL)
        answer_matches = re.findall(answer_pattern, completion, re.DOTALL)
        if len(thinking_matches) == 1:
            score += 1.0
        if len(answer_matches) == 1:
            score += 1.0

        # Beheben von addCriterion-Problemen
        # Siehe https://docs.unsloth.ai/new/vision-reinforcement-learning-vlm-rl#qwen-2.5-vl-vision-rl-issues-and-quirks
        # Bestrafe übermäßiges addCriterion und Zeilenumbrüche
        if len(completion) != 0:
            removal = completion.replace("addCriterion", "").replace("\n", "")
            if (len(completion)-len(removal))/len(completion) >= 0.5:
                score -= 2.0

        scores.append(score)
    return scores

🏁GSPO Reinforcement Learning

Dieses Update fügt zusätzlich GSPO (Group Sequence Policy Optimization) hinzu, eine Variante von GRPO, entwickelt vom Qwen-Team bei Alibaba. Sie stellten fest, dass GRPO implizit Wichtigkeitsgewichte für jedes Token erzeugt, obwohl die expliziten Vorteile nicht mit jedem Token skalieren oder sich ändern.

Dies führte zur Erstellung von GSPO, das nun die Wichtigkeit auf die Sequenzwahrscheinlichkeit anstatt auf die Einzel-Token-Wahrscheinlichkeiten der Tokens zuweist. Der Unterschied zwischen diesen beiden Algorithmen ist unten zu sehen, sowohl aus dem GSPO-Papier von Qwen und Alibaba:

GRPO-Algorithmus, Quelle: Qwen

GSPO-Algorithmus, Quelle: Qwen

In Gleichung 1 ist zu sehen, dass die Vorteile jede der Zeilen in die Token-Logprobs skalieren, bevor dieser Tensor summiert wird. Im Wesentlichen erhält jedes Token dieselbe Skalierung, obwohl diese Skalierung der gesamten Sequenz und nicht jedem einzelnen Token gegeben wurde. Ein einfaches Diagramm dazu ist unten zu sehen:

GRPO Logprob-Verhältnis zeilenweise mit Vorteilen skaliert

Gleichung 2 zeigt, dass die Logprob-Verhältnisse für jede Sequenz summiert und nach der Berechnung der Logprob-Verhältnisse exponiert werden und nur die resultierenden nun Sequenz-Verhältnisse zeilenweise mit den Vorteilen multipliziert werden.

GSPO Sequenz-Verhältnis zeilenweise mit Vorteilen skaliert

GSPO zu aktivieren ist einfach, alles, was Sie tun müssen, ist das importance_sampling_level = "sequence" Flag in der GRPO-Konfiguration zu setzen.

training_args = GRPOConfig(
    output_dir = "vlm-grpo-unsloth",
    per_device_train_batch_size = 8,
    gradient_accumulation_steps = 4,
    learning_rate = 5e-6,
    adam_beta1 = 0.9,
    adam_beta2 = 0.99,
    weight_decay = 0.1,
    warmup_ratio = 0.1,
    lr_scheduler_type = "cosine",
    optim = "adamw_8bit",
    # beta = 0.00,
    epsilon = 3e-4,
    epsilon_high = 4e-4,
    num_generations = 8,    
    max_prompt_length = 1024,
    max_completion_length = 1024,
    log_completions = False,
    max_grad_norm = 0.1,
    temperature = 0.9,
    # report_to = "none", # Auf "wandb" setzen, wenn Sie zu Weights & Biases protokollieren möchten
    num_train_epochs = 2, # Für einen schnellen Testlauf, für vollständiges Training erhöhen
    report_to = "none"
    
    # GSPO ist unten:
    importance_sampling_level = "sequence",
    
    # Dr GRPO / GAPO etc
    loss_type = "dr_grpo",
)

Insgesamt ermöglicht Unsloth jetzt mit VLM vLLM Fast-Inferenz sowohl eine um 90 % reduzierte Speichernutzung als auch eine um 1,5–2× höhere Geschwindigkeit mit GRPO und GSPO!

Wenn Sie mehr über Reinforcement Learning lesen möchten, schauen Sie sich unseren RL-Leitfaden an:

Reinforcement Learning Guide

Autoren: Ein großer Dank an Keith und Datta für seinen Beitrag zu diesem Artikel!