Guide de fine-tuning de Qwen3.8

Apprenez à fine-tuner Qwen3.8-27B avec Unsloth.

Qwen3.8-27B peut désormais être affiné et entraîné avec l’apprentissage par renforcement (RL) via Unsloth. C’est un modèle dense unifié vision-langage de 27B avec prise en charge native du texte, des images et des vidéos, des contrôles de réflexion et une fenêtre de contexte de 262K.

• Unsloth entraîne Qwen3.8 ~1,5x plus rapide avec ~50 % de VRAM en moins que les configurations FA2 (sans perte de précision)

• Affinez Qwen3.8-27B via nos gratuits notebooks Kaggle:

Conversationnel (vous pouvez activer Vision)	RL GRPO

• QLoRA fonctionne avec 24 Go et LoRA nécessite >36 Go

• Vous pouvez également entraîner Qwen3.8 avec l’apprentissage par renforcement (RL) gratuitement ou sur 24 Go de VRAM.

• L’affinage complet (FFT) fonctionne également, mais utilisera 4x plus de VRAM.

• Unsloth utilise des noyaux Flash Linear Attention pour un entraînement efficace de Qwen3.8

• Utilisez Qwen3.8-27B-unsloth-bnb-4bit pour QLoRA 4 bits, puis exporter vers NVFP4, FP8, GGUF, etc.

• Si vous souhaitez préserver la capacité de raisonnement, mélangez des exemples de style raisonnement avec des réponses directes et conservez au moins 75 % de données de raisonnement.

Veuillez utiliser la dernière version de Transformers v5. Qwen3.8 utilise la qwen3_5 architecture. La première exécution peut prendre plus de temps pendant la compilation des noyaux Gated DeltaNet.

Pour un affinage gratuit de Qwen3.8-27B via Unsloth, nous proposons plusieurs notebooks Kaggle qui offrent 30 heures d’utilisation gratuite du GPU avec 2× GPU Tesla T4. Kaggle est un produit Google, similaire à Google Colab, et offre un moyen pratique d’exécuter des workflows d’affinage sans avoir besoin de votre propre matériel GPU.

🦥 Guide Unsloth

Qwen3.8 peut être exécuté et affiné dans Unsloth Desktop, 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 GPU NVIDIA. La prise en charge de l’entraînement Intel, MLX et AMD arrive ce mois-ci.

1

Installer Unsloth

La façon la plus simple de commencer est de télécharger l’ application Unsloth Desktop. Fonctionne sur macOS, Windows, et Linux.

Télécharger Unsloth

• Télécharger pour macOS

• Télécharger pour Windows

• Télécharger pour Linux

Ou, si vous préférez installer manuellement :

MacOS, Linux, WSL :

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

Windows PowerShell :

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

2

Entraîner Qwen3.8

Allez dans l’onglet Entraîner, puis recherchez Qwen3.8-27B dans la barre de recherche et sélectionnez le modèle et l’ensemble de données souhaités. Ensuite, ajustez vos hyperparamètres et la longueur de contexte comme souhaité.

3

Surveiller la progression de l’entraînement

Après avoir cliqué sur démarrer l’entraînement, vous pourrez suivre 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é.

4

Exporter votre modèle affiné

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

5

Comparer le modèle affiné au modèle original

Cliquez sur Mode de comparaison pour comparer l’adaptateur LoRA et le modèle original.

Recette SFT

Voici une recette SFT minimale pour un affinage uniquement textuel. Votre ensemble de données a besoin d’un texte colonne déjà rendue avec le modèle de chat Qwen.

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 est facultatif et réduit la VRAM résidente en conservant la grande embedding d’entrée non liée en RAM. Unsloth le désactive automatiquement sur les plateformes non prises en charge.

Si vous êtes à court de mémoire (OOM), réduisez max_seq_length et conservez une taille de lot de 1 avec "unsloth" le gradient checkpointing.

Affinage vision

Qwen3.8 prend en charge nativement les entrées image et vidéo. Pour l’entraînement multimodal, activez les couches de vision et utilisez un ensemble de données de vision conversationnelle avec 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,
)

Définissez finetune_vision_layers=False lorsque votre ensemble de données est uniquement textuel.

Apprentissage par renforcement (RL)

Qwen3.8 utilise la même qwen3_5 architecture, utilisez donc le chemin RL Unsloth de Qwen3.5 et désactivez l’inférence rapide vLLM :

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

Enregistrement / export du modèle affiné

Utilisez le même modèle de chat et le jeton EOS lors du déploiement que ceux utilisés pendant l’entraînement.

Enregistrer en GGUF

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

Enregistrer pour vLLM

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

Pour enregistrer uniquement les adaptateurs LoRA :

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