> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md).

# Vision-Reinforcement-Learning (VLM RL)

Trainiere Vision-/Multimodal-Modelle mit GRPO und RL mit Unsloth!

Unsloth unterstützt jetzt Vision-/Multimodal-RL mit [Qwen3-VL](/docs/de/modelle/tutorials/qwen3-how-to-run-and-fine-tune/qwen3-vl-how-to-run-and-fine-tune.md), [Gemma 3](/docs/de/modelle/tutorials/gemma-3-how-to-run-and-fine-tune.md) und mehr. Aufgrund von Unsloths einzigartigem [Gewichteteilung](/docs/de/loslegen/reinforcement-learning-rl-guide.md#what-unsloth-offers-for-rl) und benutzerdefinierten Kernels macht Unsloth VLM-RL **1,5–2× schneller,** verwendet **90 % weniger VRAM**, und ermöglicht **15× längeren Kontext** Längen als FA2-Setups, ohne Genauigkeitsverlust. Dieses Update führt außerdem Quenns [GSPO](#gspo-rl) Algorithmus ein.

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 benötigt neuere GPUs als T4, da vLLM [auf Bfloat16 beschränkt](/docs/de/modelle/tutorials/gemma-3-how-to-run-and-fine-tune.md#unsloth-fine-tuning-fixes)ist, daher empfehlen wir NVIDIA L4 auf Colab. Unsere Notebooks lösen numerische Matheaufgaben mit Bildern und Diagrammen:

* **Qwen-3 VL-8B** (vLLM-Inferenz)**:** [Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_VL_\(8B\)-Vision-GRPO.ipynb)
* **Qwen-2.5 VL-7B** (vLLM-Inferenz)**:** [Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen2_5_7B_VL_GRPO.ipynb) •[ Kaggle](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Qwen2_5_7B_VL_GRPO.ipynb\&accelerator=nvidiaTeslaT4)
* **Gemma-3-4B** (Unsloth-Inferenz): [Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\)-Vision-GRPO.ipynb)

Wir haben außerdem die vLLM-VLM-Integration nativ in Unsloth eingebaut, sodass Sie zur Verwendung der vLLM-Inferenz nur den `fast_inference=True` Schalter beim Initialisieren des Modells aktivieren müssen. Besonderen Dank an [Sinoué GAD](https://github.com/unslothai/unsloth/pull/2752) für das Bereitstellen des [ersten Notebooks](https://github.com/GAD-cell/vlm-grpo/blob/main/examples/VLM_GRPO_basic_example.ipynb) das die Integration von VLM-RL erleichtert hat!

Diese VLM-Unterstützung integriert außerdem unser neuestes Update für noch speichereffizienteres + schnelleres RL, einschließlich unserer [Standby-Funktion](/docs/de/loslegen/reinforcement-learning-rl-guide/memory-efficient-rl.md#unsloth-standby), die die Geschwindigkeitsverschlechterung im Vergleich zu anderen Implementierungen auf einzigartige Weise begrenzt.

{% hint style="info" %}
Sie können `fast_inference` nur für VLMs verwenden, die von vLLM unterstützt werden. Einige Modelle, wie Llama 3.2 Vision, können daher nur ohne vLLM ausgeführt werden, funktionieren in Unsloth aber dennoch.
{% endhint %}

```python
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, damit das Bild in den Kontext passt
    load_in_4bit = True, # False für LoRA 16bit
    fast_inference = True, # vLLM-Schnellinferenz aktivieren
    gpu_memory_utilization = 0.8, # Verringern, wenn der Speicher ausgeht
)
```

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

```python
# LoRA-Adapter zum Modell hinzufügen für parametereffizientes Fine-Tuning
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 fine-getunt werden sollen
    finetune_attention_modules = True, # False, wenn die Attention-Schichten nicht fine-getunt werden sollen
    finetune_mlp_modules       = True, # False, wenn die MLP-Schichten nicht fine-getunt werden sollen

    r = lora_rank, # Beliebige Zahl > 0 wählen! Empfohlen 8, 16, 32, 64, 128
    lora_alpha = lora_rank*2, # *2 beschleunigt das Training
    use_gradient_checkpointing = "unsloth", # Reduziert den Speicherverbrauch
    random_state = 3407,
)
```

## :butterfly:Probleme und Eigenheiten beim Vision-RL mit Qwen 2.5 VL

Während des RL für Qwen 2.5 VL könnte die folgende Inferenz-Ausgabe erscheinen:

{% code overflow="wrap" %}

```
 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\n addCriterion\n\n automatisch generiert\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
```

{% endcode %}

Dies wurde [ebenfalls](https://github.com/QwenLM/Qwen2.5-VL/issues/759) auch bei der Ausgabe von Qwen2.5-VL-7B-Instruct als unerwartetes Ergebnis "addCriterion" gemeldet. Tatsächlich sehen wir das ebenfalls! Wir haben sowohl nicht-Unsloth-, bfloat16- und float16-Maschinen als auch andere Dinge ausprobiert, aber es scheint weiterhin aufzutreten. Zum Beispiel ist Element 165, also `train_dataset[165]` aus dem [AI4Math/MathVista](https://huggingface.co/datasets/AI4Math/MathVista) Datensatz unten:

{% code overflow="wrap" %}

```
Die Abbildung zeigt eine Draufsicht auf die Strecke, die ein Rennfahrer zurücklegt, während sein Wagen mit der Streckenbegrenzung kollidiert. Unmittelbar vor dem Aufprall fährt er mit der Geschwindigkeit $v_i=70 \mathrm{~m} / \mathrm{s}$ auf einer geraden Linie in einem Winkel von $30^{\circ}$ zur Wand. Unmittelbar nach dem Aufprall fährt er mit der Geschwindigkeit $v_f=50 \mathrm{~m} / \mathrm{s}$ auf einer geraden Linie in einem Winkel von $10^{\circ}$ zur Wand. Seine Masse $m$ beträgt $80 \mathrm{~kg}$. Der Aufprall dauert $14 \mathrm{~ms}$. Wie groß ist die mittlere Kraft auf den Fahrer während des Aufpralls?
```

{% endcode %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-61a659529171fcc10ed6398a15912b21d6b1a076%2FUntitled.png?alt=media" alt="" width="128"><figcaption></figcaption></figure>

Und dann erhalten wir die obige unverständliche Ausgabe. Man könnte eine Belohnungsfunktion hinzufügen, um die Verwendung von addCriterion zu bestrafen, oder unverständliche Ausgaben bestrafen. Der andere Ansatz besteht jedoch darin, es länger zu trainieren. Zum Beispiel sehen wir erst nach etwa 60 Schritten, dass das Modell tatsächlich per RL lernt:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-5f34f66f0ac6508fd28343b16592c59b889ec5ca%2Fimage.webp?alt=media" alt=""><figcaption></figcaption></figure>

{% hint style="success" %}
Erzwingen `<|assistant|>` während der Generierung reduziert erwartungsgemäß das Auftreten dieser unverständlichen Ergebnisse, da es sich um ein Instruct-Modell handelt; dennoch ist es am besten, eine Belohnungsfunktion hinzuzufügen, um schlechte Generierungen zu bestrafen, wie im nächsten Abschnitt beschrieben.
{% endhint %}

## :medal:Belohnungsfunktionen zur Reduzierung von Unverständlichkeit

Um `addCriterion` und unverständliche Ausgaben zu bestrafen, haben wir die Belohnungsfunktion so angepasst, dass zu viel `addCriterion` und Zeilenumbrüche bestraft werden.

```python
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

        # addCriterion-Probleme beheben
        # Siehe https://docs.unsloth.ai/new/vision-reinforcement-learning-vlm-rl#qwen-2.5-vl-vision-rl-issues-and-quirks
        # Bei übermäßigem addCriterion und Zeilenumbrüchen bestrafen
        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
```

## :checkered\_flag:GSPO-Reinforcement-Learning

Dieses Update fügt außerdem GSPO ([Group Sequence Policy Optimization](https://arxiv.org/abs/2507.18071)) hinzu, eine von der Qwen-Team bei Alibaba entwickelte Variante von GRPO. Sie stellten fest, dass GRPO implizit zu Wichtigkeitsgewichten für jedes Token führt, obwohl die Advantages ausdrücklich nicht mit jedem Token skalieren oder sich ändern.

Dies führte zur Entwicklung von GSPO, das nun die Wichtigkeit auf die Sequenz-Wahrscheinlichkeit statt auf die einzelnen Token-Wahrscheinlichkeiten der Tokens legt. Der Unterschied zwischen diesen beiden Algorithmen ist unten zu sehen, jeweils aus dem GSPO-Paper von Qwen und Alibaba:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-45d743dd5dcd590626777ce09cfab61808aa8c24%2Fimage.png?alt=media" alt="" width="563"><figcaption><p>GRPO-Algorithmus, Quelle: <a href="https://arxiv.org/abs/2507.18071">Qwen</a></p></figcaption></figure>

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-ee755850cbe17482ce240dde227d55c62e9a3e64%2Fimage.png?alt=media" alt="" width="563"><figcaption><p>GSPO-Algorithmus, Quelle: <a href="https://arxiv.org/abs/2507.18071">Qwen</a></p></figcaption></figure>

In Gleichung 1 ist zu sehen, dass die Advantages jede der Zeilen in die Token-Logprobs skalieren, bevor dieser Tensor summiert wird. Im Wesentlichen erhält jedes Token dieselbe Skalierung, obwohl diese Skalierung für die gesamte Sequenz und nicht für jedes einzelne Token vergeben wurde. Ein einfaches Diagramm dazu ist unten zu sehen:

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-b3c944808a15dde0a7ff45782f9f074993304bf1%2FCopy%20of%20GSPO%20diagram%20(1).jpg?alt=media" alt="" width="286"><figcaption><p>GRPO-Logprob-Verhältnis zeilenweise mit Advantages skaliert</p></figcaption></figure>

Gleichung 2 zeigt, dass die Logprob-Verhältnisse für jede Sequenz summiert und exponentiert werden, nachdem die Logprob-Verhältnisse berechnet wurden, und erst die daraus resultierenden Sequenzverhältnisse anschließend zeilenweise mit den Advantages multipliziert werden.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-62fc5b50921e79cce155d2794201c9b96faf941e%2FGSPO%20diagram%20(1).jpg?alt=media" alt="" width="313"><figcaption><p>GSPO-Sequenzverhältnis zeilenweise mit Advantages skaliert</p></figcaption></figure>

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

```python
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 nach 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 usw.
    loss_type = "dr_grpo",
)
```

Insgesamt ermöglicht Unsloth jetzt mit VLM-vLLM-Schnellinferenz sowohl 90 % reduzierten Speicherverbrauch als auch 1,5-2x schnellere Geschwindigkeit mit GRPO und GSPO!

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

[Reinforcement Learning](/docs/de/loslegen/reinforcement-learning-rl-guide.md)

***Autoren:** Ein riesiges Dankeschön an* [*Keith*](https://www.linkedin.com/in/keith-truongcao-7bb84a23b/) *und* [*Datta*](https://www.linkedin.com/in/datta0/) *für seinen Beitrag zu diesem Artikel!*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide/vision-reinforcement-learning-vlm-rl.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
