> 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 d'affinage Qwen3.8

Découvrez comment affiner 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 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**](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 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.
* **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`](https://huggingface.co/unsloth/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.

{% hint style="success" %}
Pour un affinage gratuit de Qwen3.8-27B via [Unsloth](https://github.com/unslothai/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.
{% 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 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 l’ensemble 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 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é.
{% endstep %}

{% step %}

#### Exporter votre modèle affiné

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

{% step %}

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

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

### 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.

```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 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`.

```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 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 :

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

### 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**

```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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.