Qwen3.5 Leitfaden zur Feinabstimmung

Lerne, wie man Qwen3.5-LLMs mit Unsloth feinabstimmt.

Du kannst jetzt Qwen3.5 Modellfamilie (0,8B, 2B, 4B, 9B, 27B, 35B‑A3B, 122B‑A10B) mit Unslothfeinabstimmen. Unterstützt werden sowohl Vision- als auch Text- und RL -Feinabstimmung. Qwen3.5‑35B‑A3B - bf16 LoRA funktioniert auf 74 GB VRAM.

• Unsloth macht das Training von Qwen3.5 1,5× schneller und nutzt 50 % weniger VRAM als FA2-Setups.

• VRAM-Nutzung für Qwen3.5 bf16 LoRA: 0,8B: 3 GB • 2B: 5 GB • 4B: 10 GB • 9B: 22 GB • 27B: 56 GB

• Feinabstimmen 0,8B, 2B und 4B bf16 LoRA über unsere kostenlosen Google Colab-Notebooks:

Qwen3.5-0,8B	Qwen3.5-2B	Qwen3.5-4B	Qwen3.5-4B GRPO

• Wenn du Schlussfolgern erhalten möchtest, kannst du Beispiele im Stil des Schlussfolgerns mit direkten Antworten mischen (mindestens 75 % Schlussfolgern beibehalten). Andernfalls kannst du es vollständig ausgeben.

• Full Fine-Tuning (FFT) funktioniert ebenfalls. Beachte, dass es 4x mehr VRAM verwendet.

• Qwen3.5 ist leistungsstark für mehrsprachige Feinabstimmung, da es 201 Sprachen unterstützt.

• Nach der Feinabstimmung kannst du exportieren nach GGUF (für llama.cpp/Ollama/usw.) oder vLLM

• Reinforcement Learning (RL) für Qwen3.5 VLM-RL funktioniert auch über die Unsloth-Inferenz.

• Wir haben A100 Colab-Notebooks für Qwen3.5‑27B und Qwen3.5‑35B‑A3B.

Wenn du eine ältere Version verwendest (oder lokal feinabstimmst), aktualisiere zuerst:

Unsloth Studio:

unsloth studio update

Unsloth codebasiert:

pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo

Bitte verwende transformers v5 für Qwen3.5. Ältere Versionen funktionieren nicht. Unsloth verwendet jetzt standardmäßig automatisch transformers v5 (außer in Colab-Umgebungen).

Wenn das Training langsamer als üblicherscheint, liegt das daran, dass Qwen3.5 benutzerdefinierte Mamba-Triton-Kernel verwendet. Das Kompilieren dieser Kernel kann länger dauern als normal, besonders auf T4-GPUs.

Es wird nicht empfohlen, QLoRA-Training (4-Bit) auf den Qwen3.5-Modellen durchzuführen, unabhängig davon, ob MoE oder dicht, aufgrund stärker als normaler Quantisierungsunterschiede.

MoE-Fine-Tuning (35B, 122B)

Für MoE-Modelle wie Qwen3.5‑35B‑A3B / 122B‑A10B / 397B‑A17B:

• kannst du unser Qwen3.5‑35B‑A3B (A100) Feinabstimmungs-Notebook

• nutzen. Unterstützt unser jüngstes ~12x schnelleres MoE-Trainings-Update mit >35 % weniger VRAM und ~6x längerem Kontext

• Am besten bf16-Setups verwenden (z. B. LoRA oder Full Fine-Tuning) (MoE QLoRA 4‑Bit wird aufgrund von BitsandBytes-Einschränkungen nicht empfohlen).

• Die MoE-Kernel von Unsloth sind standardmäßig aktiviert und können verschiedene Backends verwenden; du kannst wechseln mit UNSLOTH_MOE_BACKEND.

• Das Feinabstimmen der Router-Schicht ist standardmäßig aus Stabilitätsgründen deaktiviert.

• Qwen3.5‑122B‑A10B - bf16 LoRA funktioniert auf 256 GB VRAM. Wenn du Multi-GPUs verwendest, füge hinzu device_map = "balanced" oder folge unserem MultiGPU-Leitfaden.

Schnellstart

🦥 Unsloth Studio-Leitfaden

Qwen3.5 kann ausgeführt und feinabgestimmt werden in Unsloth Studiounserer neuen Open-Source-Web-UI für lokale KI. Mit Unsloth Studio kannst du Modelle lokal ausführen auf MacOS, Windows, Linux und:

• LLMs trainieren 2x schneller mit 70 % weniger VRAM

• Suchen, herunterladen, GGUFs ausführen und Safetensor-Modelle

• Selbstheilende Tool-Aufrufe + Websuche

• Code-Ausführung (Python, Bash)

• Automatische Inferenz Parameterabstimmung (Temp, Top-p usw.)

• Schnelle CPU- + GPU-Inferenz über llama.cpp

1

Unsloth installieren

Im Terminal ausführen:

MacOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell:

irm https://unsloth.ai/install.ps1 | iex

Die Installation geht schnell und dauert ca. 1–2 Min.

2

Unsloth starten

MacOS, Linux, WSL und Windows:

unsloth studio -H 0.0.0.0 -p 8888

Öffnen Sie dann http://localhost:8888 in Ihrem Browser.

3

Qwen3.5 trainieren

Beim ersten Start musst du ein Passwort erstellen, um dein Konto zu sichern, und dich später erneut anmelden. Danach siehst du einen kurzen Einrichtungsassistenten, um ein Modell, einen Datensatz und grundlegende Einstellungen auszuwählen. Du kannst ihn jederzeit überspringen.

Suche in der Suchleiste nach Qwen3.5 und wähle dein gewünschtes Modell und den Datensatz aus. Passe anschließend deine Hyperparameter und die Kontextlänge nach Wunsch an.

4

Trainingsfortschritt überwachen

Nachdem du auf Training starten geklickt hast, kannst du den Trainingsfortschritt des Modells überwachen und beobachten. Der Trainingsverlust sollte stetig abnehmen. Sobald der Vorgang abgeschlossen ist, wird das Modell automatisch gespeichert.

5

Feinabgestimmtes Modell exportieren

Sobald fertig, ermöglicht dir Unsloth Studio, das Modell in GGUF-, Safetensor- usw.-Formate zu exportieren.

Unsloth Core (codebasiert) Leitfaden:

Unten ist ein minimales SFT-Rezept (funktioniert für „nur Text“-Feinabstimmung). Siehe auch unseren Vision-Feinabstimmungs Abschnitt.

Qwen3.5 ist ein „Causal Language Model with Vision Encoder“ (es ist ein vereinheitlichtes VLM), also stelle sicher, dass die üblichen Vision-Abhängigkeiten installiert sind (torchvision, pillow) falls nötig, und halte Transformers auf dem neuesten Stand. Verwende die neueste Transformers-Version für Qwen3.5.

Wenn du GRPOmöchtest, funktioniert es in Unsloth, wenn du die schnelle vLLM-Inferenz deaktivierst und stattdessen die Unsloth-Inferenz verwendest. Folge unseren Vision-RL Notebook-Beispielen.

from unsloth import FastLanguageModel
import torch
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig

max_seq_length = 2048  # zunächst klein anfangen; nach erfolgreichem Test erhöhen

# Beispiel-Datensatz (ersetze durch deinen). Benötigt eine "text"-Spalte.
url = "https://huggingface.co/datasets/laion/OIG/resolve/main/unified_chip2.jsonl"
dataset = load_dataset("json", data_files={"train": url}, split="train")

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "Qwen/Qwen3.5-27B",
    max_seq_length = max_seq_length,
    load_in_4bit = False,     # MoE QLoRA nicht empfohlen, dichtes 27B ist in Ordnung
    load_in_16bit = True,     # bf16/16-Bit LoRA
    full_finetuning = False,
)

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = [
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    # "unsloth"-Checkpointing ist für sehr langen Kontext + geringeren VRAM gedacht
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
    max_seq_length = max_seq_length,
)

trainer = SFTTrainer(
    model = model,
    train_dataset = dataset,
    tokenizer = tokenizer,
    args = SFTConfig(
        max_seq_length = max_seq_length,
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        warmup_steps = 10,
        max_steps = 100,
        logging_steps = 1,
        output_dir = "outputs_qwen35",
        optim = "adamw_8bit",
        seed = 3407,
        dataset_num_proc = 1,
    ),
)

trainer.train()

Wenn du OOM bekommst:

• Reduziere per_device_train_batch_size zu 1 und/oder verringere max_seq_length.

• Lass use_gradient_checkpointing="unsloth" aktiv (es ist dafür ausgelegt, die VRAM-Nutzung zu reduzieren und die Kontextlänge zu erweitern).

Beispiel-Loader für MoE (bf16 LoRA):

import os
import torch
from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/Qwen3.5-35B-A3B",
    max_seq_length = 2048,
    load_in_4bit = False,     # MoE QLoRA nicht empfohlen, dichtes 27B ist in Ordnung
    load_in_16bit = True,     # bf16/16-Bit LoRA
    full_finetuning = False,
)

Sobald geladen, fügst du LoRA-Adapter hinzu und trainierst ähnlich wie im obigen SFT-Beispiel.

Vision-Feinabstimmung

Unsloth unterstützt Vision-Feinabstimmungs für die multimodalen Qwen3.5-Modelle. Verwende die untenstehenden Qwen3.5-Notebooks und ändere die jeweiligen Modellnamen zu deinem gewünschten Qwen3.5-Modell.

Qwen3.5-0,8B	Qwen3.5-2B	Qwen3.5-4B	Qwen3.5-9B

• Qwen3-VL GRPO/GSPO RL-Notebook (Modellnamen zu Qwen3.5-4B usw. ändern)

Vision deaktivieren / Nur-Text-Feinabstimmung:

Um Vision-Modelle feinabzustimmen, erlauben wir dir jetzt auszuwählen, welche Teile des Modells du feinabstimmen möchtest. Du kannst nur die Vision-Schichten, oder die Sprachschichten, oder die Attention-/MLP-Schichten feinabstimmen! Standardmäßig sind alle aktiviert!

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False, wenn keine Vision-Schichten feinabgestimmt werden
    finetune_language_layers   = True, # False, wenn keine Sprachschichten feinabgestimmt werden
    finetune_attention_modules = True, # False, wenn keine Attention-Schichten feinabgestimmt werden
    finetune_mlp_modules       = True, # False, wenn keine MLP-Schichten feinabgestimmt werden

    r = 16,                           # Je größer, desto höher die Genauigkeit, könnte aber überanpassen
    lora_alpha = 16,                  # Empfohlen: alpha == r mindestens
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Wir unterstützen rank-stabilisiertes LoRA
    loftq_config = None,               # Und LoftQ
    target_modules = "all-linear",    # Jetzt optional! Kann bei Bedarf eine Liste angegeben werden
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)

Um Qwen3.5 mit mehreren Bildern feinabzustimmen oder zu trainieren, sieh dir unseren Leitfaden für Multi-Bild-Vision.

Reinforcement Learning (RL)

Du kannst Qwen3.5 jetzt mit RL, GSPO, GRPO usw. trainieren mit unserem kostenlosen Notebook:

Google Colabcolab.research.google.com

Du kannst Qwen3.5 RL mit Unsloth ausführen, obwohl es von vLLM nicht unterstützt wird, indem du fast_inference=False beim Laden des Modells setzt:

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Qwen3.5-4B",
    fast_inference=False,
)

Feinabgestimmtes Modell speichern / exportieren

Du kannst unsere speziellen Inferenz-/Bereitstellungsleitfäden ansehen für Unsloth Studio, llama.cpp, vLLM, llama-server, Ollama.

In GGUF speichern

Unsloth unterstützt das direkte Speichern in GGUF:

model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q4_k_m")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "q8_0")
model.save_pretrained_gguf("directory", tokenizer, quantization_method = "f16")

Oder GGUFs auf Hugging Face hochladen:

model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q4_k_m")
model.push_to_hub_gguf("hf_username/directory", tokenizer, quantization_method = "q8_0")

Wenn sich das exportierte Modell in einer anderen Laufzeitumgebung schlechter verhält, nennt Unsloth die häufigste Ursache: falsche Chat-Vorlage / EOS-Token zur Inferenzzeit (du musst dieselbe Chat-Vorlage verwenden, mit der du trainiert hast).

In vLLM speichern

vLLM-Version 0.16.0 unterstützt Qwen3.5 nicht. Warte bis 0.170 oder probiere die Nightly-Version.

Um für vLLM in 16-Bit zu speichern, verwende:

model.save_pretrained_merged("finetuned_model", tokenizer, save_method = "merged_16bit")
## ODER um zu HuggingFace hochzuladen:
model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "")

Um nur die LoRA-Adapter zu speichern, verwende entweder:

model.save_pretrained("finetuned_lora")
tokenizer.save_pretrained("finetuned_lora")

Oder verwende unsere eingebaute Funktion:

model.save_pretrained_merged("finetuned_model", tokenizer, save_method = "lora")
## ODER um zu HuggingFace hochzuladen
model.push_to_hub_merged("hf/model", tokenizer, save_method = "lora", token = "")

Für weitere Details lies unsere Inferenzleitfäden:

🖥️Inferenz & BereitstellungGGUF & llama.cpp

Model ExportvLLM