> 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/notions-de-base/entrainez-votre-propre-modele-de-decision-avec-unsloth.md).
# Entraînez votre propre modèle de décision avec Unsloth
Affinez des LLM comme Qwen et Gemma pour prendre des décisions avec des probabilités calibrées.
Vous pouvez désormais entraîner votre propre modèle de décision comme **Jev**, **Laya** et **Clef** avec Unsloth. Découvrez comment affiner [Qwen3.8](/docs/fr/modeles/qwen3.8.md) et [Gemma 4](/docs/fr/modeles/gemma-4.md) les LLM, concevoir des formats de jeux de données efficaces et les transformer en [de prise de décision](/docs/fr/modeles/decision-laya.md) des modèles qui **prennent des décisions** au lieu de générer du texte. Le modèle affiné lit votre entrée, attribue un score aux options que vous fournissez et renvoie un choix avec une probabilité.
Guide d'entraînementGuide des jeux de donnéesGuide de l'API Decisions + de mise en service
Voir le tableau des résultats après l'entraînement :
| Modèle | typed-decisions | BANKING77 | CLINC150 | Précision de validation |
| ------------ | --------------- | ------------- | -------------- | ----------------------- |
| Qwen3.5-0.8B | 36% -> **73%** | 7% -> **74%** | 19% -> **76%** | 78% |
| Qwen3.5-2B | 33% -> **78%** | 1% -> 58% | 1% -> 62% | 81% |
{% columns %}
{% column %}
Nous avons affiné des LLM avec une tête Clef en utilisant LoRA (r=64) pendant un seul epoch, faisant passer la précision en aval de 30–37 % (ce qui correspond à peu près au niveau du hasard) à **jusqu'à 78 %**.
L'entraînement utilise le même format de jeu de données que Laya et Clef. Les jeux de test ont été **décontaminés** par rapport aux données d'entraînement.
{% endcolumn %}
{% column %}
{% embed url="" %}
{% endcolumn %}
{% endcolumns %}
**Tous les modèles** fonctionnent aussi bien - et vous pouvez aussi **davantage** affiner davantage des modèles de décision comme Laya / Clef.
| Modèle | Précision de test | VRAM | Temps d'entraînement |
| ----------------- | ----------------- | ------ | -------------------- |
| Qwen3.5-0.8B | 78% | 4GB | 42 min |
| Qwen3.5-2B | 81% | 8GB | 40 min |
| Llama 3.2 3B | 79% | 4.1GB | 30 min |
| Gemma 4 E4B | 77% | 14.4GB | 49 min |
| Laya (fine-tuned) | 77% | 2.5GB | 10 min |
Nous avons utilisé un mélange de **12 sources**, plus `typed-decisions`: `ag_news`, `arc`, `banking77`, `boolq`, `clinc150`, `commonsense_qa`, `mmlu`, `mnli`, `prompt_injections`, `snli`, `sst5` et `wanli`. Le **jeu de test contenait 3 000 lignes**: 2 000 de typed-decisions, 500 de BANKING77 et 500 de CLINC150.
### 🦥 Entraînez dans Unsloth
{% stepper %}
{% step %}
#### **Configurer Unsloth**
Le moyen le plus simple de commencer est de télécharger l' [application de bureau Unsloth](/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).
Télécharger Unsloth
Ou, si vous préférez l'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 %}
#### **Sélectionnez votre modèle et votre jeu de données**
Ouvrez l'onglet Train et choisissez un LLM, comme `unsloth/Qwen3.5-4B`. Ensuite, définissez **Entraîner en tant que** en **Modèle de décision**. Unsloth renseigne des paramètres qui fonctionnent bien. Pour obtenir nos résultats, réglez le nombre d'epochs à 2, le rang LoRA à 16 et le taux d'apprentissage à 2e-4.
Téléchargez un fichier ou choisissez un jeu de données depuis Hugging Face, au format de jeu de données. Pour typed-decisions, définissez **Sous-ensemble** en `tout`.
{% endstep %}
{% step %}
#### **Démarrer l'entraînement**
Cliquez sur **Démarrer l'entraînement**. Unsloth affiche la précision sur les décisions mises de côté avant et après l'entraînement, et calibre la confiance du modèle.
{% endstep %}
{% step %}
#### **Exécutez-le dans l'API Decisions**
Cliquez sur **Utiliser dans l'API Decisions**. Les requêtes qui utilisent `laya`, `par défaut` ou `jev-latest` accèdent désormais à votre modèle.
Votre modèle apparaît également sous son nom d'exécution dans Paramètres → API, sous API Decisions → Modèle.
{% endstep %}
{% step %}
Vous pouvez aussi essayer le modèle de décision entraîné via l'option « Try It » dans l'API Decisions :
{% endstep %}
{% endstepper %}
### 📒 Utilisez nos notebooks gratuits
Vous pouvez entraîner votre propre modèle de décision entièrement gratuitement grâce à nos notebooks Google Colab ou Kaggle. Colab et Kaggle offrent tous deux un calcul GPU gratuit généreux tant que vous avez un compte Google. Dans ces notebooks, vous trouverez un workflow étape par étape à suivre, et nous vous montrons comment préparer les données, entraîner le modèle lui-même (dans ce cas Qwen3.5-4B) et l'exporter.
* Affinez Qwen3.5-4B en un modèle de décision via nos notebooks gratuits :
| [**Google Colab** notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_\(4B\)-Decision.ipynb) | [**Kaggle** notebook](https://www.kaggle.com/notebooks/welcome?src=https://github.com/unslothai/notebooks/blob/main/nb/Kaggle-Qwen3_5_\(4B\)-Decision.ipynb\&accelerator=nvidiaTeslaT4) |
| ------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
Vous pouvez aussi utiliser notre notebook gratuit Unsloth Studio pour entraîner un modèle de décision avec une interface graphique :
{% embed url="" %}
### 📈 Guide des jeux de données
Les jeux de données de modèles de décision contiennent une entrée, des questions sur cette entrée et les réponses correctes. Chaque ligne utilise trois champs :
| Champ | Ce qu'il contient |
| ------------------ | -------------------------------------------------------------------------------- |
| `état` | L'entrée, par exemple un message client. |
| `questions` | Ce que le modèle doit décider, avec des instructions et les options disponibles. |
| `réponse correcte` | La bonne réponse à chaque question. |
Chaque ligne peut contenir plusieurs questions. `questions` et `réponse correcte` peuvent être des dictionnaires Python ou des chaînes encodées en JSON.
**Types de questions**
| Type | Ce qu'elle fait | Réponse correcte |
| ------- | --------------------------------------------------------- | -------------------------------------------------------- |
| `choix` | Sélectionne une option parmi `critères`. | La clé de l'option, par exemple `"billing"`. |
| `noul` | Répond par oui ou non. | `True` ou `False` en Python ; `true` ou `false` en JSON. |
| `score` | Sélectionne un niveau dans une `critères` liste ordonnée. | L'index du niveau, en commençant à `0`. |
**Exemple : tickets d'assistance**
Cet exemple utilise les questions de tickets d'assistance de notre [notebook de modèle de décision](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_5_%284B%29-Decision.ipynb), avec des étiquettes d'entraînement et deux tickets d'exemple supplémentaires.
{% code expandable="true" %}
```python
questions = {
"team": {
"type": "choice",
"instructions": "Quelle équipe doit traiter cela ?",
"criteria": {
"billing": "factures, paiements, remboursements",
"technical": "bogues, pannes, erreurs",
"sales": "tarifs, nouveaux forfaits",
},
},
"refund": {
"type": "noul",
"instructions": "Le client demande-t-il un remboursement ?",
},
"urgency": {
"type": "score",
"instructions": "Quel est le degré d'urgence ?",
"criteria": ["pas urgent", "bientôt", "aujourd'hui"],
},
}
rows = [
{
"state": "Bonjour, j'ai été facturé deux fois pour la facture #4411. Veuillez rembourser le doublon aujourd'hui.",
"questions": questions,
"gold": {"team": "billing", "refund": True, "urgency": 2},
},
{
"state": "Le tableau de bord affiche une erreur lorsque j'exporte un rapport. Merci de m'aider dans les prochains jours.",
"questions": questions,
"gold": {"team": "technical", "refund": False, "urgency": 1},
},
{
"state": "Pouvez-vous envoyer les tarifs de votre offre professionnelle ? Nous faisons des recherches pour l'année prochaine ; pas d'urgence.",
"questions": questions,
"gold": {"team": "sales", "refund": False, "urgency": 0},
},
]
```
{% endcode %}
Chaque question nécessite une réponse correspondante dans `réponse correcte`. Les réponses de type choix doivent correspondre à une clé dans `critères`. Les étiquettes de score commencent à `0`, donc `"urgency": 2` signifie `"aujourd'hui"`.
Conservez les entrées dans `état` et les réponses dans `réponse correcte`. Ces lignes illustrent le format ; ajoutez davantage d'exemples couvrant votre cas d'usage avant l'entraînement.
### 🎯 Prenez des décisions
Fournissez `predict` une entrée et les questions à décider, dans le même format que votre jeu de données :
{% code expandable="true" %}
```python
FastDecisionModel.for_inference(model)
answers = FastDecisionModel.predict(
model,
tokenizer,
"Bonjour, j'ai été facturé deux fois pour la facture #4411. Veuillez rembourser le doublon aujourd'hui.",
{
"team": {
"type": "choice",
"instructions": "Quelle équipe doit traiter cela ?",
"criteria": {
"billing": "factures, paiements, remboursements",
"technical": "bogues, pannes, erreurs",
"sales": "tarifs, nouveaux forfaits",
},
},
"refund": {"type": "noul", "instructions": "Le client demande-t-il un remboursement ?"},
"urgency": {
"type": "score",
"instructions": "Quel est le degré d'urgence ?",
"criteria": ["pas urgent", "bientôt", "aujourd'hui"],
},
},
)
for name, result in answers.items():
print(name, result["answer"], {k: round(v, 3) for k, v in result["probabilities"].items()})
```
{% endcode %}
`réponse` est la clé de l'option pour choix, `True` ou `False` pour noul, et le numéro du niveau pour score. Chaque réponse possède également les mêmes champs qu'une réponse de l'API Decisions.
Pour vérifier la précision sur un jeu de test étiqueté, utilisez `evaluate`:
```python
test = load_dataset("LocalLLaMA/typed-decisions", "all", split = "test")
test_items, _ = FastDecisionModel.build_dataset(test, tokenizer, model)
print(FastDecisionModel.evaluate(model, tokenizer, test_items))
```
### Utilisez-le dans l'API Decisions
Vous pouvez [lire notre guide détaillé](/docs/fr/modeles/decision-laya.md) pour déployer/exécuter des modèles de décision ; sinon, lisez ce qui suit pour un bref résumé. Les modèles que vous entraînez dans Unsloth apparaissent dans Paramètres → API. Pour un modèle que vous avez entraîné avec du code, démarrez Unsloth avec le dossier fusionné que vous avez enregistré :
```bash
UNSLOTH_SYSTEMONE_MODEL=/path/to/qwen-decisions-merged unsloth studio -H 0.0.0.0 -p 8888
```
Activez l'API Decisions dans Paramètres → API. Les requêtes qui utilisent `laya`, `par défaut` ou `jev-latest` s'adressent désormais à votre modèle, et les réponses ont le même format que celles de Laya. Le modèle nécessite un GPU et se charge à la première requête, ce qui peut prendre quelques minutes. Pendant qu'une exécution d'entraînement utilise le GPU, l'API Decisions attend et recommence à répondre lorsque l'exécution se termine.
#### Comment ça marche
Unsloth place votre entrée dans un seul prompt, suivi de chaque question et de ses options. Le LLM le lit une seule fois. Une petite tête, sur le même design que Clef de Cloudflare, examine la sortie du LLM pour chaque question et option et attribue un score à chaque option, en décidant de toutes les questions ensemble. Elle n'écrit jamais de texte, donc elle n'utilise pas de mémoire pour les prédictions de mots du LLM.
### 🐍 Entraînez avec du code
Installez ou mettez à jour Unsloth avec `pip install --upgrade unsloth`, puis utilisez le code suivant pour entraîner votre propre modèle de décision.
{% code expandable="true" %}
```python
from unsloth import FastDecisionModel, DecisionTrainer, is_bfloat16_supported()
from datasets import load_dataset
from transformers import TrainingArguments
model, tokenizer = FastDecisionModel.from_pretrained(
model_name = "unsloth/Qwen3.5-4B",
max_seq_length = 2048,
load_in_4bit = True,
)
model = FastDecisionModel.get_peft_model(
model,
r = 16,
lora_alpha = 16,
lora_dropout = 0,
use_gradient_checkpointing = "unsloth",
random_state = 3407,
)
dataset = load_dataset("LocalLLaMA/typed-decisions", "all", split = "train")
items, report = FastDecisionModel.build_dataset(dataset, tokenizer, model)
print(f"Ignoré {report['skipped']} décisions sur {report['total']}")
train_items, eval_items = FastDecisionModel.split_holdout(items, seed = 3407)
print(f"{len(train_items)} lignes d'entraînement, {len(eval_items)} mises de côté")
from transformers import TrainingArguments
trainer = DecisionTrainer(
model = model,
processing_class = tokenizer,
train_dataset = train_items,
eval_dataset = eval_items,
args = TrainingArguments(
per_device_train_batch_size = 2,
gradient_accumulation_steps = 4, # Utilisez l'accumulation de gradients pour imiter la taille du lot !
warmup_steps = 10,
# num_train_epochs = 2, # Définissez cela pour une exécution d'entraînement complète.
max_steps = 240,
learning_rate = 2e-5,
lr_scheduler_type = "cosine",
weight_decay = 0.01,
bf16 = is_bfloat16_supported(),
fp16 = not is_bfloat16_supported(),
eval_strategy = "epoch",
logging_steps = 1,
output_dir = "outputs",
report_to = "none", # Utilisez TrackIO/WandB, etc.
seed = 3407,
),
)
trainer_stats = trainer.train()
```
{% endcode %}
Pour utiliser Llama ou Gemma 4, changez `model_name` en `unsloth/Llama-3.2-3B-Instruct` ou `unsloth/gemma-4-E4B-it`. Les autres LLM qu'Unsloth peut affiner devraient fonctionner de la même manière.
Pour vos propres données, consultez le format de jeu de données. Chaque ligne comporte un état, les questions à décider et les réponses correctes.
#### Calibrez et enregistrez
Calibrez sur les lignes `split_holdout` mises de côté, afin que les probabilités du modèle correspondent à la fréquence de ses bonnes réponses :
```python
metrics = FastDecisionModel.calibrate(model, tokenizer, eval_items)
print(metrics) # précision sur l'ensemble mis de côté, erreur de calibration (ECE) et perte
```
Puis enregistrez. `save_pretrained` enregistre les adaptateurs LoRA et la tête. `save_pretrained_merged` enregistre un modèle complet en 16 bits :
```python
model.save_pretrained("qwen-decisions")
model.save_pretrained_merged("qwen-decisions-merged")
# model.push_to_hub("hf_username/qwen-decisions", token = "hf_...")
```
Rechargez-le de la même manière que vous avez chargé le modèle de base :
```python
model, tokenizer = FastDecisionModel.from_pretrained("qwen-decisions", load_in_4bit = True)
```
### ⚙️ Paramètres recommandés
* Commencez avec LoRA en 4 bits au rang 16 et un taux d'apprentissage de 2e-4. La nouvelle tête s'entraîne à 1e-4 par défaut. Vous pouvez modifier cela avec `head_learning_rate` dans `DecisionTrainer`.
* Nous avons utilisé 2 epochs sur typed-decisions. Avec moins de données, essayez 3 ou 4.
* Pour un essai rapide, définissez `max_steps = 60`. Qwen3.5-4B a atteint 76 % en 10 minutes sur une L4.
* Si vous manquez de mémoire, divisez la taille du lot par deux et doublez l'accumulation de gradients.
* `max_seq_length` définit l'entrée la plus longue pendant l'entraînement. Les entrées longues conservent la question et les options, et coupent la fin de l'entrée pour tenir. Les prédictions lisent jusqu'à 16 384 jetons.
---
# 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/notions-de-base/entrainez-votre-propre-modele-de-decision-avec-unsloth.md?ask=&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.
