Guide de fine-tuning de Qwen3.5

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

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

• Unsloth permet d’entraîner Qwen3.5 1,5× plus vite et utilise 50 % de VRAM en moins que les configurations FA2.

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

• Affiner 0.8B, 2B et 4B LoRA bf16 via notre gratuits notebooks Google Colab:

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

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

• L’affinage complet (FFT) fonctionne aussi. Notez que cela utilisera 4 fois 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/etc.) ou vLLM

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

• Nous avons A100 des notebooks Colab pour Qwen3.5‑27B et Qwen3.5‑35B‑A3B.

Si vous utilisez une version plus ancienne (ou si vous affinez localement), mettez d’abord à jour :

Unsloth Studio :

unsloth studio update

Unsloth basé sur le code :

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 désormais automatiquement transformers v5 par défaut (sauf pour les environnements Colab).

Si l’entraînement semble plus lent que d’habitude, c’est parce que Qwen3.5 utilise des noyaux Triton Mamba 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é d’effectuer un entraînement QLoRA (4 bits) sur les modèles Qwen3.5, qu’il s’agisse de MoE ou de 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) notebook d’affinage

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

• Mieux vaut utiliser des configurations bf16 (par ex. LoRA ou affinage complet) (le 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 routeur est désactivé par défaut pour des raisons de stabilité.

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

Démarrage rapide

🦥 Guide d’Unsloth Studio

Qwen3.5 peut être exécuté et affiné dans Unsloth Studio, notre nouvelle interface web open source pour l’IA locale. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur MacOS, Windows, Linux et :

• Entraîner des LLM 2x plus vite avec 70 % de VRAM en moins

• Rechercher, télécharger, exécuter des GGUF et des modèles safetensor

• Auto-réparation appel d’outils + recherche web

• Exécution de code (Python, Bash)

• Inférence automatique réglage des paramètres (temp, top-p, etc.)

• Inférence CPU + GPU rapide via llama.cpp

1

Installer Unsloth

Exécutez dans votre terminal :

MacOS, Linux, WSL :

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

Windows PowerShell :

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

L’installation sera rapide et prendra environ 1 à 2 minutes.

2

Lancer Unsloth

MacOS, Linux, WSL et Windows :

unsloth studio -H 0.0.0.0 -p 8888

Puis ouvrez http://localhost:8888 dans votre navigateur.

3

Entraîner Qwen3.5

Au premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d’intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment.

Recherchez Qwen3.5 dans la barre de recherche et sélectionnez le modèle et le jeu de données souhaités. Ensuite, ajustez vos hyperparamètres et la longueur du contexte selon vos besoins.

4

Surveiller la progression de l’entraînement

Après avoir cliqué sur démarrer l’entraînement, vous pourrez surveiller et observer la progression de l’entraînement du modèle. La perte d’entraînement devrait diminuer régulièrement. Une fois terminé, le modèle sera automatiquement enregistré.

5

Exporter votre modèle affiné

Une fois terminé, Unsloth Studio vous permet d’exporter le modèle vers GGUF, safetensor, etc.

Guide Unsloth Core (basé sur le code) :

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

Qwen3.5 est « Causal Language Model with Vision Encoder » (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 rapide vLLM et utilisez à la place l’inférence Unsloth. Suivez nos exemples de notebooks Vision RL .

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 d’exemple (remplacez-le 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é, le 27B dense 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 + VRAM réduite
    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 VRAM et étendre la longueur du contexte).

Exemple de chargeur 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é, le 27B dense convient
    load_in_16bit = True,     # LoRA bf16/16 bits
    full_finetuning = False,
)

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

Affinage visuel

Unsloth prend en charge d’affinage vision pour les modèles multimodaux Qwen3.5. Utilisez les notebooks Qwen3.5 ci-dessous et remplacez 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

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

Désactivation de la vision / affinage texte seul :

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

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False si les couches de vision ne sont pas affinées
    finetune_language_layers   = True, # False si les couches de langage ne sont pas affinées
    finetune_attention_modules = True, # False si les couches d’attention ne sont pas affinées
    finetune_mlp_modules       = True, # False si les couches MLP ne sont pas affinées

    r = 16,                           # Plus la valeur est grande, plus la précision est élevée, mais cela peut surapprendre
    lora_alpha = 16,                  # alpha recommandé = r au moins
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Nous prenons en charge le 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.

Apprentissage par renforcement (RL)

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

Google Colabcolab.research.google.com

Vous pouvez exécuter Qwen3.5 RL 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 Unsloth Studio, llama.cpp, vLLM, llama-server, Ollama.

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 environnement d’exécution, Unsloth signale la cause la plus fréquente : mauvais modèle de conversation / jeton EOS au moment de l’inférence (vous devez utiliser le même modèle de conversation que celui avec lequel vous avez entraîné).

Enregistrer vers vLLM

version de vLLM 0.16.0 ne prend pas en charge Qwen3.5. Attendez jusqu’à 0.170 ou essayez la version 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 vers 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 vers 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

Model ExportvLLM