Qwen3.5 : Guide d'affinage

Apprenez à affiner Qwen3.5 avec Unsloth.

Vous pouvez désormais affiner le Qwen3.5 famille de modèles (27B, 35B‑A3B, 122B‑A10B, 397B‑A17B) avec Unsloth. La prise en charge inclut à la fois l’affinage vision et texte. Qwen3.5‑35B‑A3B - LoRA bf16 fonctionne sur 74Go de VRAM.

• Qwen3.5‑27B - LoRA bf16 fonctionne sur 56Go de VRAM et QLoRA 4 bits sur 28Go

• Prend en charge notre récente mise à jour d’entraînement MoE ~12x plus rapide mise à jour MoE avec >35% de VRAM en moins et un contexte ~6x plus long

Notebooks Colab d’affinage Qwen3.5 :

Qwen3.5‑35B‑A3B (A100)	Qwen3.5‑27B (A100)	Les petits arrivent bientôt...

• Si vous voulez préserver la capacité de raisonnement, vous pouvez mélanger des exemples de type raisonnement avec des réponses directes (conserver au minimum 75% de raisonnement). Sinon vous pouvez l’émettre entièrement.

• Après l’affinage, vous pouvez exporter vers GGUF (pour llama.cpp/Ollama/LM Studio/etc.) ou vLLM

Si vous êtes sur une version plus ancienne (ou affinez localement), mettez d’abord à jour :

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

Affinage MoE

Pour les modèles MoE comme Qwen3.5‑35B‑A3B / 122B‑A10B / 397B‑A17B:

• Il est préférable d’utiliser des configurations bf16 (par ex. LoRA ou affinage complet) (MoE QLoRA 4 bits n’est pas recommandé en raison des limitations de BitsandBytes).

• Les noyaux MoE d’Unsloth sont activés par défaut et peuvent utiliser différents backends ; vous pouvez basculer avec UNSLOTH_MOE_BACKEND.

• L’affinage de la couche de routage est désactivé par défaut pour la stabilité.

• Qwen3.5‑122B‑A10B - LoRA bf16 fonctionne sur 256Go de VRAM. Si vous utilisez plusieurs GPUs, ajoutez device_map = "balanced" ou suivez notre Guide multiGPU.

Démarrage rapide

Ci‑dessous se trouve une recette SFT minimale (fonctionne pour l’affinage « texte uniquement »). Voir aussi notre affinage vision section.

Qwen3.5 est un « modèle de langage causal avec encodeur vision » (c’est un VLM unifié), assurez‑vous donc d’avoir les dépendances vision habituelles installées (torchvision, pillow) si nécessaire, et maintenez Transformers à jour. Utilisez les derniers Transformers pour Qwen3.5.

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

max_seq_length = 2048  # commencez petit ; augmentez après que cela fonctionne

# Jeu de données exemple (remplacez par le vôtre). Nécessite une colonne "text".
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,     # QLoRA MoE non recommandé, dense 27B convient
    load_in_16bit = True,     # LoRA bf16/16 bits
    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",
    # le checkpointing "unsloth" est destiné aux contextes très longs + moins de VRAM
    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()

Si vous manquez de mémoire (OOM) :

• Réduisez per_device_train_batch_size à 1 et/ou réduisez max_seq_length.

• Conservez use_gradient_checkpointing="unsloth" activé (il est conçu pour réduire l’utilisation de la VRAM et étendre la longueur du contexte).

Exemple de loader pour MoE (LoRA bf16) :

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,     # QLoRA MoE non recommandé, dense 27B convient
    load_in_16bit = True,     # LoRA bf16/16 bits
    full_finetuning = False,
)

Une fois chargé, vous attacherez des adaptateurs LoRA et entraînerez de manière similaire à l’exemple SFT ci‑dessus.

Affinage vision

Unsloth prend en charge affinage vision pour les modèles multimodaux Qwen3.5. Vous pouvez lire / utiliser notre guide Qwen3-VL à titre de référence. Utilisez les notebooks Qwen3-VL ci‑dessous et changez les noms de modèles respectifs par le modèle Qwen3.5 souhaité.

• Notebook d’affinage SFT normal Qwen3-VL

• Notebook RL Qwen3-VL GRPO/GSPO

Désactivation Vision / Affinage texte uniquement :

Pour affiner des modèles vision, nous vous permettons désormais de sélectionner quelles parties du modèle affiner. Vous pouvez choisir d’affiner uniquement les couches vision, ou les couches langage, ou les couches attention / MLP ! Nous les activons toutes par défaut !

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False si vous n’affinez pas les couches vision
    finetune_language_layers   = True, # False si vous n’affinez pas les couches langage
    finetune_attention_modules = True, # False si vous n’affinez pas les couches d’attention
    finetune_mlp_modules       = True, # False si vous n’affinez pas les couches MLP

    r = 16,                           # Plus grand = meilleure précision, mais risque de surapprentissage
    lora_alpha = 16,                  # Alpha recommandé == r au minimum
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Nous prenons en charge LoRA à rang stabilisé
    loftq_config = None,               # Et LoftQ
    target_modules = "all-linear",    # Optionnel maintenant ! Peut spécifier une liste si nécessaire
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)

Afin d’affiner ou d’entraîner Qwen3.5 avec plusieurs images, consultez notre guide vision multi‑images.

Enregistrement / export du modèle affiné

Vous pouvez consulter nos guides spécifiques d’inférence / déploiement pour llama.cpp, vLLM, llama-server, Ollama, LM Studio ou SGLang.

Enregistrer en GGUF

Unsloth prend en charge l’enregistrement direct en 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")

Ou poussez les GGUF vers Hugging Face :

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")

Si le modèle exporté se comporte moins bien dans un autre runtime, Unsloth signale la cause la plus fréquente : mauvais modèle de chat / token EOS au moment de l’inférence (vous devez utiliser le même modèle de chat avec lequel vous avez entraîné).

Enregistrer pour vLLM

Pour enregistrer en 16 bits pour vLLM, utilisez :

model.save_pretrained_merged("finetuned_model", tokenizer, save_method = "merged_16bit")
## OU pour téléverser sur HuggingFace :
model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "")

Pour enregistrer uniquement les adaptateurs LoRA, utilisez soit :

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

Ou utilisez notre fonction intégrée :

model.save_pretrained_merged("finetuned_model", tokenizer, save_method = "lora")
## OU pour téléverser sur HuggingFace
model.push_to_hub_merged("hf/model", tokenizer, save_method = "lora", token = "")

Pour plus de détails, lisez nos guides d’inférence :

🖥️Inférence & DéploiementGGUF & llama.cpp

vLLMDépannage de l'inférence