Qwen3.8-Leitfaden zur Feinabstimmung

Lerne, wie du Qwen3.8-27B mit Unsloth feinabstimmst.

Qwen3.8-27B kann jetzt per Feinabstimmung und Reinforcement Learning (RL) über Unsloth. Es ist ein dichtes, einheitliches Vision-Sprachmodell mit 27B, nativer Unterstützung für Text, Bilder und Videos, Denksteuerungen und einem Kontextfenster von 262K.

• Unsloth trainiert Qwen3.8 ca. 1,5× schneller mit ca. 50 % weniger VRAM als FA2-Setups (kein Genauigkeitsverlust)

• Qwen3.8-27B feinabstimmen über unsere kostenlosen Kaggle-Notebooks:

Dialogorientiert (du kannst Vision aktivieren)	RL GRPO

• QLoRA funktioniert mit 24 GB und LoRA benötigt >36 GB

• Du kannst Qwen3.8 auch mit Reinforcement Learning (RL) kostenlos oder mit 24 GB VRAM trainieren.

• Vollständiges Fine-Tuning (FFT) funktioniert ebenfalls, aber es verwendet 4× mehr VRAM.

• Unsloth nutzt Flash-Linear-Attention-Kernels für effizientes Qwen3.8-Training

• Verwende Qwen3.8-27B-unsloth-bnb-4bit für 4-Bit-QLoRA, dann exportieren zu NVFP4, FP8, GGUF usw.

• Wenn du die Denkfähigkeit erhalten möchtest, mische Beispiele im Denkstil mit direkten Antworten und halte mindestens 75 % Denkdaten vor.

Bitte verwende die neueste Transformers v5. Qwen3.8 verwendet die qwen3_5 Architektur. Der erste Durchlauf kann länger dauern, während die Gated-DeltaNet-Kernels kompiliert werden.

Für kostenloses Qwen3.8-27B-Feintuning über Unsloth, stellen wir mehrere Kaggle-Notebooks bereit, die 30 Stunden kostenlose GPU-Nutzung mit 2× Tesla-T4-GPUs bieten. Kaggle ist ein Google-Produkt, ähnlich wie Google Colab, und bietet eine bequeme Möglichkeit, Finetuning-Workflows auszuführen, ohne eigene GPU-Hardware zu benötigen.

🦥 Unsloth-Leitfaden

Qwen3.8 kann in Unsloth Desktop, unserer neuen Open-Source-Web-UI für lokale KI, ausgeführt und feinabgestimmt werden.

Mit Unsloth Studio kannst du Modelle lokal auf MacOS, Windows, Linux ausführen und NVIDIA-GPUs trainieren. Unterstützung für Intel-, MLX- und AMD-Training kommt noch diesen Monat.

1

Unsloth installieren

Der einfachste Einstieg ist das Herunterladen der Unsloth-Desktop-App. Funktioniert auf macOS, Windows, und Linux.

Unsloth herunterladen

• Für macOS herunterladen

• Für Windows herunterladen

• Für Linux herunterladen

Oder, wenn du lieber manuell installieren möchtest:

MacOS, Linux, WSL:

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

Windows PowerShell:

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

2

Qwen3.8 trainieren

Gehe zum Reiter Trainieren, suche dann in der Suchleiste nach Qwen3.8-27B und wähle dein gewünschtes Modell und Datensatz aus. Passe anschließend deine Hyperparameter und die Kontextlänge nach Wunsch an.

3

Trainingsfortschritt überwachen

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

4

Dein feinabgestimmtes Modell exportieren

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

5

Feinabgestimmtes Modell mit Originalmodell vergleichen

Klicke auf Vergleichsmodus um den LoRA-Adapter und das Originalmodell zu vergleichen.

SFT-Rezept

Unten findest du ein minimales SFT-Rezept für reines Text-Feintuning. Dein Datensatz benötigt eine Text Spalte, die bereits mit der Qwen-Chatvorlage gerendert wurde.

from unsloth import FastModel
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig

max_seq_length = 2048

dataset = load_dataset(
    "json",
    data_files = "train.jsonl",
    split = "train",
)

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/Qwen3.8-27B-unsloth-bnb-4bit",
    max_seq_length = max_seq_length,
    load_in_4bit = True,
    full_finetuning = False,
    offload_embedding = True,
)

model = FastModel.get_peft_model(
    model,
    finetune_vision_layers     = False,
    finetune_language_layers   = True,
    finetune_attention_modules = True,
    finetune_mlp_modules       = True,

    r = 16,
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
    use_rslora = False,
    loftq_config = None,
)

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    args = SFTConfig(
        dataset_text_field = "text",
        max_seq_length = max_seq_length,
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        warmup_steps = 10,
        max_steps = 100,
        learning_rate = 2e-4,
        logging_steps = 1,
        optim = "adamw_8bit",
        output_dir = "outputs_qwen38",
        seed = 3407,
        dataset_num_proc = 1,
        report_to = "none",
    ),
)

trainer.train()

offload_embedding=True ist optional und reduziert den belegten VRAM, indem das große, nicht gemeinsam genutzte Eingabe-Embedding im RAM gehalten wird. Unsloth deaktiviert es auf nicht unterstützten Plattformen automatisch.

Wenn du OOM bekommst, reduziere max_seq_length und behalte die Batchgröße 1 mit "unsloth" Gradient Checkpointing.

Vision-Feintuning

Qwen3.8 unterstützt native Eingaben für Bilder und Videos. Für multimodales Training aktiviere die Vision-Schichten und verwende einen konversationellen Vision-Datensatz mit UnslothVisionDataCollator.

model = FastModel.get_peft_model(
    model,
    finetune_vision_layers     = True,
    finetune_language_layers   = True,
    finetune_attention_modules = True,
    finetune_mlp_modules       = True,

    r = 16,
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
    use_rslora = False,
    loftq_config = None,
)

Setze finetune_vision_layers=False wenn dein Datensatz nur aus Text besteht.

Reinforcement Learning (RL)

Qwen3.8 verwendet dieselbe qwen3_5 Architektur, verwende also den Qwen3.5-Unsloth-RL-Pfad und deaktiviere die schnelle vLLM-Inferenz:

from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/Qwen3.8-27B-unsloth-bnb-4bit",
    max_seq_length = 2048,
    load_in_4bit = True,
    fast_inference = False,
)

Speichern / exportieren des feinabgestimmten Modells

Verwende bei der Bereitstellung dieselbe Chatvorlage und denselben EOS-Token, die du beim Training verwendet hast.

Als GGUF speichern

model.save_pretrained_gguf(
    "qwen38_gguf",
    tokenizer,
    quantization_method = "q4_k_m",
)

# model.push_to_hub_gguf(
#     "hf_username/qwen38_gguf",
#     tokenizer,
#     quantization_method = "q4_k_m",
# )

Als vLLM speichern

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

Zum Speichern nur der LoRA-Adapter:

model.save_pretrained("qwen38_lora")
tokenizer.save_pretrained("qwen38_lora")