> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/qwen3.8/train.md).

# Guide de fine-tuning Qwen3.8

Découvrez comment 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](https://github.com/unslothai/unsloth). C'est un modèle multimodal unifié dense de 27B avec prise en charge native du texte, des images et de la vidéo, des contrôles de réflexion et une fenêtre de contexte de 262K.

* Unsloth entraîne Qwen3.8 **\~1,5x plus vite** par **\~50 % de VRAM en moins** que les configurations FA2 (sans perte de précision)
* Affinez Qwen3.8-27B via nos **gratuits** **Notebooks Kaggle**:

| [**Conversationnel**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Qwen3.8_\(27B\)-Conversational.ipynb\&accelerator=nvidiaTeslaT4) (vous pouvez activer la vision) | [**RL GRPO**](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Muse_Glimmer_\(30B\)-GRPO.ipynb\&accelerator=nvidiaTeslaT4) |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

* **QLoRA fonctionne avec 24 Go** et LoRA nécessite >36 Go
* Vous pouvez également entraîner Qwen3.8 avec [l’apprentissage par renforcement](#reinforcement-learning-rl) (RL) gratuitement ou sur 24 Go de VRAM.
* **Le fine-tuning complet (FFT)** fonctionne aussi, mais il utilisera 4 fois 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`](https://huggingface.co/unsloth/Qwen3.8-27B-unsloth-bnb-4bit) pour QLoRA en 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 l' `qwen3_5` architecture. La première exécution peut prendre plus de temps pendant la compilation des noyaux Gated DeltaNet.

{% hint style="success" %}
Pour un fine-tuning gratuit de Qwen3.8-27B via [Unsloth](https://github.com/unslothai/unsloth), nous fournissons 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 fournit un moyen pratique d'exécuter des workflows de fine-tuning sans avoir besoin de votre propre matériel GPU.
{% endhint %}

### 🦥 Guide Unsloth

{% columns %}
{% column %}
Qwen3.8 peut être exécuté et affiné dans [Unsloth](/docs/fr/nouveau/studio.md) 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 sur Intel, MLX et AMD arrive ce mois-ci.
{% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FD7qpbGJLY5YMv0E0QgrB%2Ftrainingrun_LLM-unsloth.gif?alt=media&amp;token=feb766a7-1a7b-4f47-b5f4-b38e3a0d1470" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Installer Unsloth

La façon la plus simple de commencer est de télécharger l' [application Unsloth Desktop](/docs/fr/desktop.md). Fonctionne sur [macOS](/docs/fr/commencer/install/mac.md), [Windows](/docs/fr/commencer/install/windows-installation.md)et [Linux](/docs/fr/commencer/install/linux.md).

<a href="https://unsloth.ai/download" class="button primary" data-icon="down-to-bracket">Télécharger Unsloth</a>

* <i class="fa-apple">:apple:</i> [Télécharger pour macOS](https://unsloth.ai/download/mac)
* <i class="fa-windows">:windows:</i> [Télécharger pour Windows](https://unsloth.ai/download/windows)
* <i class="fa-linux">:linux:</i> [Télécharger pour Linux](https://unsloth.ai/download/linux)

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

MacOS, Linux, WSL :

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

Windows PowerShell :

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

{% endstep %}

{% step %}

#### 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 le jeu de données souhaités. Ensuite, ajustez vos hyperparamètres et la longueur de contexte comme souhaité.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FD7qpbGJLY5YMv0E0QgrB%2Ftrainingrun_LLM-unsloth.gif?alt=media&amp;token=feb766a7-1a7b-4f47-b5f4-b38e3a0d1470" alt=""><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### 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é.
{% endstep %}

{% step %}

#### Exporter votre modèle ajusté finement

Une fois terminé, Unsloth Studio vous permet d'exporter le modèle aux formats GGUF, safetensor, etc.
{% endstep %}

{% step %}

#### Comparer le modèle ajusté finement avec le modèle original

Cliquez sur `Mode comparaison` pour comparer l'adaptateur LoRA et le modèle original.
{% endstep %}
{% endstepper %}

### Recette SFT

Ci-dessous se trouve une recette SFT minimale pour un fine-tuning texte uniquement. Votre jeu de données a besoin d'une `texte` colonne déjà formatée avec le gabarit de chat Qwen.

```python
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 en RAM la grande embedding d'entrée non liée. Unsloth le désactive automatiquement sur les plateformes non prises en charge.

Si vous manquez de mémoire, réduisez `max_seq_length` et conservez une taille de lot de 1 avec `"unsloth"` le gradient checkpointing.

### Fine-tuning vision

Qwen3.8 prend en charge en natif les entrées image et vidéo. Pour l'entraînement multimodal, activez les couches vision et utilisez un jeu de données de vision conversationnelle avec `UnslothVisionDataCollator`.

```python
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 jeu de données est uniquement textuel.

### Apprentissage par renforcement (RL)

Qwen3.8 utilise le même `qwen3_5` architecture, donc utilisez le même chemin RL Unsloth que pour Qwen3.5 et désactivez l'inférence rapide vLLM :

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

### Sauvegarde / export du modèle ajusté finement

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

**Enregistrer au format GGUF**

```python
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**

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

Pour enregistrer uniquement les adaptateurs LoRA :

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/modeles/qwen3.8/train.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.