Guide de fine-tuning Qwen3.5

Apprenez à fine-tuner les LLM Qwen3.5 avec Unsloth.

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

• Unsloth rend l’entraînement de Qwen3.5 1,5× plus rapide et utilise 50 % de VRAM en moins que les configurations FA2.

• Utilisation de la VRAM LoRA bf16 pour Qwen3.5 : 0.8B : 3GB • 2B : 5GB • 4B : 10GB • 9B : 22GB • 27B : 56GB

• Affiner 0.8B, 2B et 4B LoRA bf16 via nos gratuits carnets Google Colab:

Qwen3.5-0.8B	Qwen3.5-2B	Qwen3.5-4B	Qwen3.5-4B GRPO

• Si vous souhaitez préserver la capacité de raisonnement vous pouvez mélanger des exemples de style raisonnement avec des réponses directes (conservez au minimum 75 % de raisonnement). Sinon, vous pouvez l’émettre complètement.

• L’affinage complet (FFT) fonctionne aussi. Notez qu’il utilisera 4x plus de VRAM.

• Qwen3.5 est puissant pour l’affinage multilingue car il prend en charge 201 langues.

• Après l’affinage, vous pouvez exporter vers GGUF (pour llama.cpp/Ollama/LM Studio/etc.) ou Cette configuration fonctionne avec des fournisseurs hébergés, des points de terminaison auto-hébergés,

• Apprentissage par renforcement (RL) pour Qwen3.5 VLM RL fonctionne aussi via l’inférence Unsloth.

• Nous disposons de A100 carnets Colab pour Qwen3.5‑27B et Qwen3.5‑35B‑A3B.

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

Veuillez utiliser transformers v5 pour Qwen3.5. Les versions plus anciennes ne fonctionneront pas. Unsloth utilise automatiquement transformers v5 par défaut maintenant (sauf pour les environnements Colab).

Si l’entraînement semble plus lent que d’habitude, c’est parce que Qwen3.5 utilise des noyaux Mamba Triton personnalisés. La compilation de ces noyaux peut prendre plus de temps que la normale, en particulier sur les GPU T4.

Il n’est pas recommandé de faire de l’entraînement QLoRA (4 bits) sur les modèles Qwen3.5, que ce soit MoE ou dense, en raison de différences de quantification supérieures à la normale.

Affinage MoE (35B, 122B)

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

• Vous pouvez utiliser notre Qwen3.5‑35B‑A3B (A100) carnet d’affinage

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

• Il est préférable d’utiliser des configurations bf16 (par ex. LoRA ou affinage complet) (MoE QLoRA 4‑bits non 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 changer avec UNSLOTH_MOE_BACKEND.

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

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

Démarrage rapide

Ci‑dessous 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é), donc assurez‑vous d’avoir les dépendances vision habituelles installées (torchvision, pillow) si nécessaire, et gardez Transformers à jour. Utilisez la dernière version de Transformers pour Qwen3.5.

Si vous souhaitez faire GRPO, cela fonctionne dans Unsloth si vous désactivez l’inférence vLLM rapide et utilisez l’inférence Unsloth à la place. Suivez nos Vision RL exemples de carnet.

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 ça fonctionne

# Exemple de dataset (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,     # MoE QLoRA non recommandé, dense 27B est acceptable
    load_in_16bit = True,     # LoRA bf16/16-bit
    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é à des contextes très longs + réduction 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 avez un OOM :

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

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

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

Affinage vision

Unsloth prend en charge affinage vision pour les modèles multimodaux Qwen3.5. Utilisez les carnets Qwen3.5 ci‑dessous et changez les noms de modèles respectifs par le modèle Qwen3.5 souhaité.

Qwen3.5-0.8B	Qwen3.5-2B	Qwen3.5-4B	Qwen3.5-9B

• Carnet Qwen3-VL GRPO/GSPO RL (changez le nom du modèle en Qwen3.5-4B etc.)

Désactivation de l’affinage Vision / Texte uniquement :

Pour affiner les modèles vision, nous vous permettons désormais de sélectionner quelles parties du modèle affiner. Vous pouvez choisir d’affiner seulement 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 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 supportons 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",
    ],
)

Pour affiner ou entraîner Qwen3.5 avec plusieurs images, consultez notre guide vision multi-image.

Apprentissage par renforcement (RL)

Vous pouvez désormais entraîner Qwen3.5 avec RL, GSPO, GRPO etc avec notre carnet gratuit:

Google Colabcolab.research.google.com

Vous pouvez exécuter RL sur Qwen3.5 avec Unsloth même s’il n’est pas pris en charge par vLLM, en définissant fast_inference=False lors du chargement du modèle :

from unsloth import FastLanguageModel

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

Enregistrement / export du modèle affiné

Vous pouvez consulter nos guides spécifiques d’inférence / déploiement pour llama.cpp, Cette configuration fonctionne avec des fournisseurs hébergés, des points de terminaison auto-hébergés,, 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 des GGUF sur 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 courante : mauvais template de chat / token EOS au moment de l’inférence (vous devez utiliser le même template de chat avec lequel vous avez entraîné).

Enregistrer pour vLLM

la version vLLM 0.16.0 ne prend pas en charge Qwen3.5. Attendez jusqu’à 0.170 ou essayez la release Nightly.

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 et déploiementGGUF & llama.cpp

vLLMDépannage de l'inférence