# Commencez avec Unsloth Studio Unsloth Studio est une interface graphique locale, basée sur le navigateur, pour affiner des LLM sans écrire de code. Elle enveloppe le pipeline d’entraînement dans une interface claire qui gère le chargement du modèle, le formatage du jeu de données, la configuration des hyperparamètres et le suivi en direct de l’entraînement. Studio Recette de données Exporter Chat #### Configurer Unsloth Studio D’abord, lancez Unsloth Studio en utilisant soit une installation locale, soit une option cloud. Suivez les [instructions d’installation](/docs/fr/nouveau/studio/install.md) pour votre configuration, ou utilisez notre [notebook Colab gratuit](/docs/fr/nouveau/studio.md#google-colab-notebook) . Pour une configuration locale, exécutez : ```bash unsloth studio -H 0.0.0.0 -p 8888 ``` {% columns %} {% column %} Ouvrez le navigateur de votre choix et tapez `http://127.0.0.1:8888` dans la barre d’URL. Si c’est la première fois que vous installez Unsloth, vous serez redirigé vers la page `http://127.0.0.1:8888/change-password` . C’est là que vous devrez créer un nouveau mot de passe. Vous pourrez toujours changer votre mot de passe plus tard. {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} ## Chat - Démarrage rapide [Unsloth Studio Chat](/docs/fr/nouveau/studio/chat.md) vous permet d’exécuter des modèles 100 % hors ligne sur votre ordinateur. Exécutez des formats de modèle comme GGUF et safetensors depuis Hugging Face ou depuis vos fichiers locaux. * **Télécharger + Exécuter** n’importe quel modèle comme des GGUF, des adaptateurs affinés, des safetensors, etc. * [**Comparer** modèle différent](#model-arena) résultats côte à côte * **Télécharger** des documents, des images et de l’audio dans vos prompts * [**Régler** les paramètres](#generation-settings) d’inférence comme : température, top-p, top-k et prompt système

Vous pouvez lire ici notre tutoriel / guide détaillé sur l’exécution de modèles avec Unsloth Studio : {% content-ref url="/pages/02de109936ce31121bffae3333822baa85a115f0" %} [Studio Chat](/docs/fr/nouveau/studio/chat.md) {% endcontent-ref %} ### Guide de chargement du modèle Avant d’utiliser l’API, vous devez **charger le modèle** que vous souhaitez utiliser dans **Unsloth.** Ouvrez le **Select model** menu déroulant dans le coin supérieur gauche de la page de chat.

{% hint style="info" %} Sur une autre page ? Utilisez la barre latérale de gauche et cliquez sur `New Chat` pour revenir à la page de chat. {% endhint %} {% columns %} {% column width="50%" %} #### Sélectionner un modèle Utilisez la barre de recherche pour trouver le modèle que vous souhaitez charger dans Unsloth. Parcourez les modèles recommandés, recherchez directement des modèles Hugging Face ou définissez un répertoire de modèle personnalisé. Les modèles entraînés localement et exportés peuvent être chargés depuis l’onglet \`Fine-tuned\`. {% endcolumn %} {% column width="50%" %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Sélection GGUF Les dépôts de modèles contiennent plusieurs quantifications. Sélectionnez la quantification la mieux adaptée à votre RAM / VRAM disponible.\ \ Dans ce guide, nous utiliserons `unsloth/gemma-4-26B-A4B-it-GGUF` et sélectionnerons la variante `UD-Q4_K_XL` recommandée {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} #### Téléchargement du modèle {% columns %} {% column %} Recherchez le modèle que vous souhaitez utiliser, puis **cliquez dessus** pour commencer à le télécharger et à le charger. Après avoir sélectionné une variante de modèle, Unsloth commencera à télécharger et à charger le modèle en mémoire. Une fois le chargement terminé, vous verrez la confirmation suivante : {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Le modèle est chargé et prêt à être utilisé. Vous pouvez maintenant discuter directement avec le modèle dans Unsloth ou le connecter à des outils tels que [Claude Code](/docs/fr/bases/claude-code.md) et [Codex](/docs/fr/bases/codex.md).

## Studio - Démarrage rapide La page d’accueil d’Unsloth Studio comporte 4 zones principales : [Modèle](#id-1.-select-model-and-method), [Jeu de données](#id-2.-dataset), [Paramètres](#id-3.-hyperparameters), et [Entraînement/Configuration](#id-4.-training-and-config) * **Configuration facile des modèles et des données** depuis Hugging Face ou des fichiers locaux * **Choix d’entraînement flexibles** comme QLoRA, LoRA ou l’affinage complet, avec des valeurs par défaut déjà renseignées * **Outils de configuration utiles** pour les découpages, le mappage des colonnes, les hyperparamètres et les configurations YAML * **Excellente visibilité de l’entraînement** avec progression en direct, statistiques GPU, graphiques, état de démarrage

### 1. Sélectionner le modèle et la méthode #### **Type de modèle** Sélectionnez la modalité qui correspond à votre cas d’utilisation : | Type | Cas d’utilisation | | -------------- | --------------------------------------- | | **Texte** | Chat, suivi d’instructions, complétion | | **Vision** | Image + texte (VLMs) | | **Audio** | Compréhension de la parole / de l’audio | | **Embeddings** | Embeddings de phrases, récupération | #### **Méthode d’entraînement** Trois méthodes sont disponibles, activées à l’aide d’un sélecteur en forme de pilule : | Méthode | Description | VRAM | | -------------------- | ------------------------------------------------------ | -------------- | | **QLoRA** | Modèle de base quantifié en 4 bits + adaptateur LoRA | La plus faible | | **LoRA** | Modèle de base en précision complète + adaptateur LoRA | Moyenne | | **Affinage complet** | Tous les poids sont entraînés | La plus élevée | Tapez n’importe quel nom de modèle Hugging Face ou recherchez directement sur le Hub depuis la zone combinée. Les modèles locaux stockés dans `~/.unsloth/studio/models` et votre cache Hugging Face apparaissent également dans la liste. {% hint style="warning" %} Les modèles au format GGUF sont exclus de l’entraînement — ils servent uniquement à l’inférence. {% endhint %} Lorsque vous choisissez un modèle, Studio récupère automatiquement sa configuration depuis le backend et pré-remplit des valeurs par défaut pertinentes pour tous les hyperparamètres. **Jeton HuggingFace** Collez ici votre jeton d’accès Hugging Face si le modèle est restreint (par ex. Llama, Gemma). Le jeton est validé en temps réel et une erreur est affichée en ligne s’il n’est pas valide. ### 2. Jeu de données {% columns %} {% column %} Passez entre deux onglets pour choisir l’origine de vos données : * **HuggingFace Hub** - recherche en direct sur le Hub. La date de dernière mise à jour est affichée pour chaque résultat. * **Local** - glisser-déposer ou cliquer pour téléverser un fichier non structuré ou des fichiers structurés comme : `PDF`, `DOCX`, `JSONL`, `JSON`, `CSV`, ou `Parquet` . Les jeux de données précédemment téléversés apparaissent dans une liste qui se rafraîchit automatiquement. Vous pouvez consulter notre [guide détaillé des jeux de données ici](/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide.md). Prompt Studio pour interpréter et formater vos données : {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} | Format | Quand l’utiliser | | ---------- | -------------------------------------------------- | | `auto` | Laisser Unsloth détecter automatiquement le format | | `alpaca` | `instruction` / `input` / `output` colonnes | | `chatml` | style OpenAI `messages` tableau | | `sharegpt` | conversations de style ShareGPT | **Découpes et sous-ensembles** * **Sous-ensemble** - renseigné automatiquement à partir de la carte du jeu de données. * **Découpage entraînement / découpage évaluation** - choisissez quels découpages utiliser. La définition d’un découpage d’évaluation active le **perte d’évaluation** graphique pendant l’entraînement. * **Segment du jeu de données** - permet éventuellement de limiter l’entraînement à une plage de lignes (index de début / index de fin) pour des expériences rapides. **Mappage des colonnes** Si Studio ne peut pas associer automatiquement les colonnes de votre jeu de données aux bons rôles, une **boîte de dialogue d’aperçu du jeu de données** s’ouvre. Elle affiche des lignes d’exemple et vous permet d’assigner chaque colonne à `instruction`, `input`, `output`, `image`etc. Les mappages suggérés sont préremplis lorsque c’est possible. ### 3. Hyperparamètres Les paramètres sont regroupés en sections repliables. Vous pouvez consulter notre [guide des hyperparamètres LoRA](/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide.md) détaillé ici : {% content-ref url="/pages/f4254d24125c1e7ad4d5ad30f1a9c8f7d36e7c4d" %} [Hyperparameters Guide](/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide.md) {% endcontent-ref %} | Paramètre | Par défaut | Notes | | ------------------------ | ---------- | -------------------------------------------- | | **Nombre max. d’étapes** | `0` | `0` signifie utiliser des époques à la place | | **Longueur du contexte** | `2048` | Options : 512 → 32768 | | **Taux d’apprentissage** | `2e-4` | | **Paramètres LoRA** *(Masqué lorsque l’affinage complet est sélectionné)* | Paramètre | Par défaut | Notes | | ------------------ | ------------ | --------------------------------------------------------------------------- | | **Rang** | `16` | Curseur 4–128 | | **Alpha** | `32` | Curseur 4–256 | | **Dropout** | `0.05` | | | **Variante LoRA** | `LoRA` | `LoRA` / `RS-LoRA` / `LoftQ` | | **Modules cibles** | Tous activés | `q_proj`, `k_proj`, `v_proj`, `o_proj`, `gate_proj`, `up_proj`, `down_proj` | Pour **Vision** les modèles avec un jeu de données d’images, quatre cases à cocher supplémentaires apparaissent. Affiner : | Couches de vision | Couches de langage | Modules d’attention | Modules MLP | | ----------------- | ------------------ | ------------------- | ----------- | **Hyperparamètres d’entraînement** Organisés en trois onglets : {% tabs %} {% tab title="Optimisation" %} | Paramètre | Par défaut | | ------------------------- | ------------ | | Époques | 3 | | Taille de lot | 4 | | Accumulation de gradients | 8 | | Régularisation du poids | 0.01 | | Optimiseur | AdamW 8 bits | {% endtab %} {% tab title="Planification" %} | Paramètre | Par défaut | | ----------------------------- | ---------- | | Planificateur de LR | linéaire | | Étapes de montée en charge | 5 | | Checkpointing des gradients | unsloth | | Graine aléatoire | 3407 | | Étapes d’enregistrement | 0 | | Étapes d’évaluation | 0 | | Packing | faux | | Entraîner sur les complétions | faux | | {% endtab %} | | {% tab title="Journalisation" %} | Paramètre | Par défaut | | --------------------------- | -------------- | | Activer W\&B | faux | | Projet W\&B | llm-finetuning | | Activer TensorBoard | faux | | Répertoire TensorBoard | runs | | Fréquence de journalisation | 10 | | {% endtab %} | | | {% endtabs %} | | {% hint style="info" %} [**Checkpointing des gradients Unsloth**](/docs/fr/blog/500k-context-length-fine-tuning.md#unsloth-gradient-checkpointing-enhancements)**: `unsloth`** utilise l’implémentation personnalisée d’Unsloth, économe en mémoire, qui peut réduire de manière significative l’utilisation de la VRAM par rapport à l’option standard de PyTorch. C’est la valeur par défaut recommandée. {% endhint %} ### 4. Entraînement et configuration La carte en bas à droite contient trois boutons de gestion de configuration et le bouton **Lancer l’entraînement** . | Bouton | Action | | ----------------- | ------------------------------------------------------------- | | **Télécharger** | Charger un `.yaml` fichier de configuration | | **Enregistrer** | Exporter la configuration actuelle en YAML | | **Réinitialiser** | Rétablir tous les paramètres aux valeurs par défaut du modèle | Le bouton Lancer l’entraînement reste désactivé tant qu’un modèle et un jeu de données ne sont pas tous deux configurés. Les erreurs de validation s’affichent en ligne — par exemple, définir des étapes d’évaluation sans choisir de découpage d’évaluation, ou associer un modèle texte seul à un jeu de données vision. #### Écran de chargement {% columns %} {% column %} Après avoir cliqué sur **Lancer l’entraînement**, une superposition plein écran apparaît pendant que le backend prépare tout.

{% endcolumn %} {% column %} La superposition affiche un terminal animé avec des mises à jour de phase en direct : * Bleu : téléchargement du modèle / jeu de données * Ambre : chargement du modèle / jeu de données * Bleu : configuration * Vert : entraînement Vous pouvez annuler à tout moment en utilisant le bouton **×** dans le coin. Une boîte de dialogue de confirmation apparaîtra avant que quoi que ce soit ne soit arrêté. {% endcolumn %} {% endcolumns %} ### Progression de l’entraînement et observabilité Une fois que la première étape d’entraînement arrive, la superposition se ferme et la vue d’entraînement en direct s’affiche. Le processus d’affinage est terminé lorsque les étapes atteignent 100 % sur la barre de progression. Vous pouvez voir le temps écoulé et les jetons.

{% columns %} {% column %} #### Panneau d’état La colonne de gauche affiche : * **Époque** - époque fractionnaire actuelle (par ex. `Époque 1.23`) * **Barre de progression** - basée sur les étapes, avec pourcentage * **Métriques clés**: * **Perte** - perte d’entraînement à 4 décimales * **TR** - taux d’apprentissage actuel en notation scientifique * **Norme du gradient** - norme du gradient * **Modèle** - le modèle en cours d’entraînement * **Méthode** - `QLoRA` / `LoRA` / `Complet` * **Ligne de temps** - temps écoulé, ETA, étapes par seconde et nombre total de jetons traités {% endcolumn %} {% column %} #### Moniteur GPU La colonne de droite affiche les statistiques GPU en direct interrogées toutes les quelques secondes : * **Utilisation** - barre de pourcentage * **Température** - barre °C * **VRAM** - utilisé / total en Go * **Puissance** - consommation / limite en watts #### Arrêt de l’entraînement Utilisez le bouton **Arrêter l’entraînement** en haut à droite de la carte de progression. Une boîte de dialogue vous offre deux choix : * **Arrêter et enregistrer** - enregistre un point de contrôle avant l’arrêt * **Annuler** - s’arrête immédiatement sans point de contrôle {% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Graphiques Quatre graphiques en direct se mettent à jour au fur et à mesure que l’entraînement progresse : 1. **Perte d’entraînement** - valeurs brutes plus une ligne lissée EMA et une ligne de référence de moyenne mobile 2. **Taux d’apprentissage** - la courbe du planificateur de LR 3. **Norme du gradient** - norme du gradient au fil des étapes 4. **perte d’évaluation** - affiché uniquement lorsque vous avez configuré un découpage d’évaluation {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} {% columns %} {% column %} Chaque graphique dispose de paramètres (icône engrenage) avec : | Option | Par défaut | | ------------------------------- | ------------------------------ | | Fenêtre d’affichage | Curseur des N dernières étapes | | Lissage EMA | `0.6` | | Afficher les brutes | Activé | | Afficher lissé | Activé | | Afficher la ligne de moyenne | Activé | | Échelle (par série) | Linéaire / Log | | Écrêtage des valeurs aberrantes | Pas d’écrêtage / p99 / p95 | | {% endcolumn %} | | {% column %}

{% endcolumn %} {% endcolumns %} #### Fichiers de configuration {% columns %} {% column %} Toutes les configurations d’entraînement peuvent être enregistrées et rechargées sous forme de fichiers YAML. Les fichiers sont nommés automatiquement comme suit : ``` {model}_{method}_{dataset}_{timestamp}.yaml ``` {% endcolumn %} {% column %}

{% endcolumn %} {% endcolumns %} Le YAML est structuré en trois sections : {% code expandable="true" %} ```yaml training: max_steps: 0 num_train_epochs: 3 per_device_train_batch_size: 4 ... lora: r: 16 lora_alpha: 32 ... logging: report_to: none ... ``` {% endcode %} Cela facilite la reproduction des exécutions, le partage des configurations ou la gestion de versions de vos expériences. ## Recettes de données - Démarrage rapide [Unsloth Data Recipes](/docs/fr/nouveau/studio/data-recipe.md) vous permet de téléverser des documents comme des PDF ou des fichiers CSV et de les transformer en jeux de données exploitables. Créez et modifiez visuellement des jeux de données via un flux de travail en nœuds de graphe. La page des recettes est le point d’entrée principal. Les recettes sont stockées localement dans le navigateur, vous pouvez donc revenir plus tard aux travaux enregistrés. À partir de là, vous pouvez créer une recette vierge ou ouvrir une recette d’apprentissage guidé.

Data Recipes suit le même chemin de base. Vous ouvrez la page des recettes, créez ou choisissez une recette, construisez le flux de travail dans l’éditeur, validez-le, exécutez un aperçu, puis lancez le jeu de données complet une fois que le résultat semble correct. Ajoutez des données d’amorçage et des blocs de génération, validez le flux de travail, prévisualisez un échantillon de sortie, puis lancez une génération complète du jeu de données. Unsloth Data Recipes est alimenté par NVIDIA [DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner). À première vue, un flux de travail habituel devrait ressembler à ceci : 1. Ouvrir la page des recettes. 2. Créer une nouvelle recette ou en ouvrir une existante. 3. Ajouter des blocs pour définir le flux de travail de votre jeu de données. 4. Cliquez sur **Valider** pour détecter tôt les problèmes de configuration. 5. Exécuter un aperçu pour inspecter rapidement des lignes d’exemple. 6. Lancer une génération complète du jeu de données lorsque la recette est prête. 7. Consulter la progression et la sortie en direct dans le graphe ou dans la vue **Exécutions** pour plus de détails sur le mode. 8. Sélectionnez le jeu de données résultant dans **Studio** et affinez un modèle. ## Export - Démarrage rapide Utilisez « Export » dans Unsloth Studio pour exporter, enregistrer ou convertir des modèles en GGUF, Safetensors ou LoRA pour le déploiement, le partage ou l’inférence locale dans Unsloth, llama.cpp, Ollama, vLLM, et plus encore. Exportez un checkpoint entraîné ou convertissez n’importe quel modèle existant.

Vous pouvez lire ici notre tutoriel / guide détaillé sur l’exportation de modèles avec Unsloth Studio : {% content-ref url="/pages/817a1275219e1e8d86fe100d223ac4b0862ab3a1" %} [Model Export](/docs/fr/nouveau/studio/export.md) {% endcontent-ref %} ## Tutoriel vidéo {% hint style="warning" %} Les versions d’Unsloth Studio montrées dans les vidéos sont anciennes et ne reflètent pas la version actuelle. {% endhint %} {% columns fullWidth="true" %} {% column %} {% embed url="" %} Voici un tutoriel vidéo créé par NVIDIA pour vous aider à démarrer avec Studio : {% endcolumn %} {% column %} {% embed url="" %} Comment installer Unsloth Studio - Tutoriel vidéo {% endcolumn %} {% endcolumns %} ## Paramètres avancés ### Commandes CLI L’interface en ligne de commande Unsloth (`cli.py`) fournit les commandes suivantes : ``` Utilisation : cli.py [COMMANDE] Commandes : train Affiner un modèle inference Exécuter une inférence sur un modèle entraîné export Exporter un adaptateur entraîné list-checkpoints Lister les points de contrôle enregistrés ui Lancer l’interface web d’Unsloth Studio studio Lancer le studio (alias) ``` ### Structure du projet {% code expandable="true" %} ``` new-ui-prototype/ ├── cli.py # Point d’entrée de la CLI ├── cli/ # Commandes CLI Typer │ └── commands/ │ ├── train.py │ ├── inference.py │ ├── export.py │ ├── ui.py │ └── studio.py ├── setup.sh # Script de bootstrap (Linux / WSL / Colab) ├── setup.ps1 # Script de bootstrap (Windows natif) ├── setup.bat # Wrapper pour lancer setup.ps1 par double-clic ├── install_python_stack.py # Installateur de dépendances Python multiplateforme └── studio/ ├── backend/ │ ├── main.py # Application FastAPI et middleware │ ├── run.py # Lanceur de serveur (uvicorn) │ ├── auth/ # Stockage de l’authentification et logique JWT │ ├── routes/ # Gestionnaires des routes API │ │ ├── training.py │ │ ├── models.py │ │ ├── inference.py │ │ ├── datasets.py │ │ └── auth.py │ ├── models/ # Schémas de requête/réponse Pydantic │ ├── core/ # Moteur d’entraînement et configuration │ ├── utils/ # Détection du matériel, utilitaires │ └── requirements.txt ├── frontend/ │ ├── src/ │ │ ├── features/ # Modules de fonctionnalités │ │ │ ├── auth/ # Flux de connexion / inscription │ │ │ ├── training/ # Configuration et surveillance de l’entraînement │ │ │ ├── studio/ # Espace de travail principal du studio │ │ │ ├── chat/ # Interface de chat pour l’inférence │ │ │ ├── export/ # Flux d’export du modèle │ │ │ └── onboarding/# Assistant d’onboarding │ │ ├── components/ # Composants UI partagés (shadcn) │ │ ├── hooks/ # Hooks React personnalisés │ │ ├── stores/ # Stores d’état Zustand │ │ └── types/ # Définitions de types TypeScript │ ├── package.json │ └── vite.config.ts └── tests/ # Suite de tests du backend ``` {% endcode %} ### Référence de l’API Tous les points de terminaison nécessitent un JWT valide `Authorization: Bearer ` en-tête (sauf `/api/auth/*` et `/api/health`). | Méthode | Point de terminaison | Description | | ------- | --------------------- | ------------------------------------------------------------------------------- | | `GET` | `/api/health` | Vérification de l’état de santé | | `GET` | `/api/system` | Informations système (GPU, CPU, mémoire) | | `POST` | `/api/auth/signup` | Créer un compte (nécessite un jeton de configuration lors du premier lancement) | | `POST` | `/api/auth/login` | Se connecter et recevoir des jetons JWT | | `POST` | `/api/auth/refresh` | Actualiser un jeton d’accès expiré | | `GET` | `/api/auth/status` | Vérifier si l’authentification est initialisée | | `POST` | `/api/train/start` | Démarrer une tâche d’entraînement | | `POST` | `/api/train/stop` | Arrêter une tâche d’entraînement en cours | | `POST` | `/api/train/reset` | Réinitialiser l’état de l’entraînement | | `GET` | `/api/train/status` | Obtenir l’état actuel de l’entraînement | | `GET` | `/api/train/metrics` | Obtenir les métriques d’entraînement (loss, LR, étapes) | | `GET` | `/api/train/stream` | Flux SSE de la progression de l’entraînement en temps réel | | `GET` | `/api/models/` | Lister les modèles disponibles | | `POST` | `/api/inference/chat` | Envoyer un message de chat pour l’inférence | | `GET` | `/api/datasets/` | Lister / gérer les ensembles de données | --- # Agent Instructions: 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: ``` GET https://unsloth.ai/docs/fr/nouveau/studio/start.md?ask= ``` The question should be specific, self-contained, and written in natural language. 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.