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

<a href="#studio-quickstart" class="button secondary" data-icon="bolt">Studio</a><a href="#data-recipes-quickstart" class="button secondary" data-icon="hat-chef">Recette de données</a><a href="#export-quickstart" class="button secondary" data-icon="box-isometric">Exporter</a><a href="#chat-quickstart" class="button secondary" data-icon="comment-dots">Chat</a><a href="#video-tutorial" class="button secondary" data-icon="video">Vidéo</a>

#### Configurer Unsloth Studio

Tout d’abord, lancez Unsloth Studio en utilisant soit une installation locale, soit une option cloud. Suivez les [instructions d’installation](https://unsloth.ai/docs/fr/nouveau/studio/install) pour votre configuration, ou utilisez notre [Colab gratuit](https://unsloth.ai/docs/fr/nouveau/studio/..#google-colab-notebook) notebook. Pour une configuration locale, exécutez :

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

Puis ouvrez `http://localhost:8888` dans votre navigateur.

{% columns %}
{% column %}
Au premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte, puis vous reconnecter plus tard.

Vous verrez ensuite un bref assistant de prise en main pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment et tout configurer manuellement.
{% 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%2FZPtRrwafzmVX54HhyyBD%2FScreenshot%202026-03-16%20at%2011.25.22%E2%80%AFPM.png?alt=media&#x26;token=9153c153-ec61-4fff-b1b9-db7f70ac2936" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

## <i class="fa-bolt">:bolt:</i> 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/Config](#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 un affinement complet, avec des valeurs par défaut déjà renseignées
* **Outils de configuration utiles** pour les partitions, le mappage des colonnes, les hyperparamètres et les configs YAML
* **Excellente visibilité de l’entraînement** avec progression en direct, statistiques GPU, graphiques et état de démarrage

<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%2FxV1PO5DbF3ksB51nE2Tw%2Fmore%20cropped%20ui%20for%20homepage.png?alt=media&#x26;token=f75942c9-3d8d-4b59-8ba2-1a4a38de1b86" alt="" width="563"><figcaption></figcaption></figure></div>

### 1. Sélectionner le modèle et la méthode

#### **Type de modèle**

Sélectionnez la modalité qui correspond à votre cas d’usage :

| Type           | Cas d’usage                            |
| -------------- | -------------------------------------- |
| **Texte**      | Chat, suivi d’instructions, complétion |
| **Vision**     | Image + texte (VLMs)                   |
| **Audio**      | Compréhension de la parole / audio     |
| **Embeddings** | Embeddings de phrases, recherche       |

#### **Méthode d’entraînement**

Trois méthodes sont disponibles, activables via 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 pleine précision + adaptateur LoRA | Moyenne        |
| **Affinement complet** | Tous les poids sont entraînés                        | La plus élevée |

Saisissez le nom de n’importe quel modèle Hugging Face ou recherchez directement sur le Hub depuis la zone de sélection. Les modèles locaux stockés dans `~/.unsloth/studio/models` ainsi que 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 sont uniquement destinés à 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 cohérentes pour tous les hyperparamètres.

**Jeton Hugging Face**

Collez ici votre jeton d’accès Hugging Face si le modèle est protégé (par ex. Llama, Gemma). Le jeton est validé en temps réel et une erreur s’affiche en ligne s’il est invalide.

### 2. Jeu de données

{% columns %}
{% column %}
Basculez 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 structuré comme : `PDF`, `DOCX`, `JSONL`, `JSON`, `CSV`, ou `Parquet` format. Les jeux de données téléversés précédemment apparaissent dans une liste qui se rafraîchit automatiquement.

Vous pouvez consulter notre [Guide des jeux de données ici](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide).

Prompt Studio pour interpréter et formater vos données :
{% 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%2FCtWUm7GdHnKbe14fUQyT%2Fupdated_dataset.webp?alt=media&#x26;token=3fcefe8d-b6a4-44c2-be9b-6dc282166095" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

| Format     | Quand l’utiliser                                   |
| ---------- | -------------------------------------------------- |
| `auto`     | Laissez 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-échantillonnage**

* **Sous-ensemble** - renseigné automatiquement à partir de la fiche du jeu de données.
* **Partition d’entraînement / partition d’évaluation** - choisissez quelles partitions utiliser. Définir une partition d’évaluation active le **graphe de perte d’évaluation** pendant l’entraînement.
* **Sous-ensemble du jeu de données** - limite éventuellement l’entraînement à une plage de lignes (indice de début / indice de fin) pour des expériences rapides.

**Mappage des colonnes**

Si Studio ne peut pas mapper automatiquement les colonnes de votre jeu de données vers les 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 quand c’est possible.

### 3. Hyperparamètres

Les paramètres sont regroupés en sections repliables. Vous pouvez consulter notre [guide des hyperparamètres LoRA](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide) détaillé ici :

{% content-ref url="../../commencer/fine-tuning-llms-guide/lora-hyperparameters-guide" %}
[lora-hyperparameters-guide](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide)
{% endcontent-ref %}

| Paramètre                   | Par défaut | Remarques                                    |
| --------------------------- | ---------- | -------------------------------------------- |
| **Nombre maximal d’étapes** | `0`        | `0` signifie utiliser les époques à la place |
| **Longueur de contexte**    | `2048`     | Options : 512 → 32768                        |
| **Taux d’apprentissage**    | `2e-4`     |                                              |

**Paramètres LoRA**

*(Masqué lorsque l’affinement complet est sélectionné)*

| Paramètre          | Par défaut   | Remarques                                                                   |
| ------------------ | ------------ | --------------------------------------------------------------------------- |
| **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            |
| Décroissance des poids    | 0.01         |
| Optimiseur                | AdamW 8 bits |

{% endtab %}

{% tab title="Planification" %}

| Paramètre                     | Par défaut |
| ----------------------------- | ---------- |
| Planificateur de LR           | linéaire   |
| Étapes de chauffe             | 5          |
| Checkpointing des gradients   | unsloth    |
| Graine aléatoire              | 3407       |
| Étapes d’enregistrement       | 0          |
| Étapes d’évaluation           | 0          |
| Empaquetage                   | 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**](https://unsloth.ai/docs/fr/blog/500k-context-length-fine-tuning#unsloth-gradient-checkpointing-enhancements)**: `unsloth`** utilise l’implémentation personnalisée économe en mémoire d’Unsloth, qui peut réduire considérablement l’utilisation de la VRAM par rapport à l’option standard de PyTorch. C’est le réglage par défaut recommandé.
{% endhint %}

### 4. Entraînement et config

La carte en bas à droite comporte trois boutons de gestion de config et le **Démarrer l’entraînement** bouton.

| Bouton            | Action                                                        |
| ----------------- | ------------------------------------------------------------- |
| **Téléverser**    | Charger un `.yaml` fichier de configuration                   |
| **Enregistrer**   | Exporter la config actuelle en YAML                           |
| **Réinitialiser** | Rétablir tous les paramètres aux valeurs par défaut du modèle |

Le bouton Démarrer 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 partition d’évaluation, ou associer un modèle texte uniquement à un jeu de données vision.

#### Écran de chargement

{% columns %}
{% column %}
Après avoir cliqué sur **Démarrer l’entraînement**, une superposition plein écran apparaît pendant que le backend prépare tout.

<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%2FYtsUxHI0szGw8ZPxCHep%2Fimage.png?alt=media&#x26;token=1701f4af-ef35-48da-80e7-4aba4e80f4d4" alt="" width="375"><figcaption></figcaption></figure></div>
{% 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 toute interruption.
{% 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 apparaît. Le processus d’affinement est terminé lorsque les étapes atteignent 100 % sur la barre de progression. Vous pouvez voir le temps écoulé et le nombre de jetons.&#x20;

<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%2Fah3G1rYgRaDNY8Ay6Uw7%2Fimage.png?alt=media&#x26;token=0528c15e-7a4b-4028-8070-95dc0871da5d" alt="" width="563"><figcaption></figcaption></figure></div>

{% 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
* **Indicateurs clés**:
  * **Perte** - perte d’entraînement à 4 décimales
  * **LR** - taux d’apprentissage actuel en notation scientifique
  * **Norme des gradients** - norme des gradients
  * **Modèle** - le modèle en cours d’entraînement
  * **Méthode** - `QLoRA` / `LoRA` / `Complet`
* **Ligne de timing** - temps écoulé, ETA, étapes par seconde et total de jetons traités
  {% endcolumn %}

{% column %}

#### Moniteur GPU

La colonne de droite affiche les statistiques GPU en direct, relevées toutes les quelques secondes :

* **Utilisation** - barre de pourcentage
* **Température** - barre °C
* **VRAM** - utilisé / total en Go
* **Puissance** - consommation / limite en watts

#### Arrêter l’entraînement

Utilisez le **Arrêter l’entraînement** bouton en haut à droite de la carte de progression. Une boîte de dialogue vous offre deux choix :

* **Arrêter et enregistrer** - enregistre un checkpoint avant l’arrêt
* **Annuler** - arrête immédiatement sans checkpoint
  {% endcolumn %}
  {% endcolumns %}

{% columns %}
{% column %}

#### Graphiques

Quatre graphiques en direct se mettent à jour au fur et à mesure de l’avancement de l’entraînement :

1. **Perte d’entraînement** - valeurs brutes plus une ligne lissée par EMA et une ligne de référence de moyenne glissante
2. **Taux d’apprentissage** - la courbe du planificateur de LR
3. **Norme des gradients** - norme des gradients au fil des étapes
4. **graphe de perte d’évaluation** - affiché uniquement lorsque vous avez configuré une partition d’évaluation
   {% 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%2FRgXfe3sobdQWxha8yslr%2Fimage.png?alt=media&#x26;token=b3aa9004-778b-4e3d-85b1-40a205ad0602" alt="" width="278"><figcaption></figcaption></figure></div>
{% 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                 |
| Clipping des valeurs aberrantes | Aucun clipping / p99 / p95     |
| {% 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%2FFJtjQpAgOFaieyQCYhkq%2Fimage.png?alt=media&#x26;token=4da9cdc2-c088-4ab8-8d0d-40d8d392ee03" alt="" width="276"><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

#### Fichiers de configuration

{% columns %}
{% column %}
Toutes les configurations d’entraînement peuvent être enregistrées et rechargées en tant que fichiers YAML. Les fichiers sont nommés automatiquement comme :

```
{model}_{method}_{dataset}_{timestamp}.yaml
```

{% 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%2FuGAKdGkANbh2wIENA9X7%2Fimage.png?alt=media&#x26;token=9553db5b-5c88-4556-be49-fe61035edf11" alt="" width="178"><figcaption></figcaption></figure></div>
{% 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 le versionnage de vos expériences.

## <i class="fa-hat-chef">:hat-chef:</i> Recettes de données - Démarrage rapide

[Unsloth Data Recipes](https://unsloth.ai/docs/fr/nouveau/studio/data-recipe) vous permet de téléverser des documents comme des PDF ou des fichiers CSV et de les transformer en jeux de données utilisables. 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, afin que vous puissiez reprendre plus tard votre travail enregistré. À partir d’ici, vous pouvez créer une recette vierge ou ouvrir une recette d’apprentissage guidée.

<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%2FQ6e19jESrJg0VjHnX58c%2Fdata%20recipes%20final.png?alt=media&#x26;token=8d74e453-815d-4790-83d1-76d0bc80a3ce" alt="" width="563"><figcaption></figcaption></figure></div>

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, le validez, lancez un aperçu, puis exécutez le jeu de données complet une fois que le résultat vous convient. Ajoutez des données de départ et des blocs de génération, validez le flux de travail, prévisualisez un exemple de sortie, puis lancez la création complète du jeu de données. Unsloth Data Recipes est propulsé par NVIDIA [DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner).

En un coup d’œil, un flux de travail habituel devrait ressembler à ceci :

1. Ouvrez la page des recettes.
2. Créez une nouvelle recette ou ouvrez-en une existante.
3. Ajoutez des blocs pour définir le flux de travail de votre jeu de données.
4. Cliquez sur **Valider** pour détecter rapidement les problèmes de configuration.
5. Lancez un aperçu pour inspecter rapidement des lignes d’exemple.
6. Lancez une création complète du jeu de données lorsque la recette est prête.
7. Consultez la progression et le résultat 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 obtenu dans **Studio** et affinez un modèle.

## <i class="fa-box-isometric">:box-isometric:</i> Exporter - Démarrage rapide

Utilisez l’option « Export » d’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.

<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%2FrrFY8YczW3dDpfYi1k9f%2FScreenshot%202026-03-15%20at%209.28.19%E2%80%AFPM.png?alt=media&#x26;token=d2729e16-799f-48f0-8b07-0248b93fa599" alt="" width="563"><figcaption></figcaption></figure></div>

Vous pouvez lire notre tutoriel / guide détaillé sur l’exportation de modèles avec Unsloth Studio ici :

{% content-ref url="export" %}
[export](https://unsloth.ai/docs/fr/nouveau/studio/export)
{% endcontent-ref %}

## <i class="fa-comment-dots">:comment-dots:</i> Chat - Démarrage rapide

[Unsloth Studio Chat](https://unsloth.ai/docs/fr/nouveau/studio/chat) vous permet d’exécuter des modèles 100 % hors ligne sur votre ordinateur. Exécutez des formats de modèles 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é, des safetensors, etc.
* [**Comparer** différent modèle](#model-arena) sorties côte à côte
* **Téléverser** documents, images et audio dans vos prompts
* [**Ajuster** inférence](#generation-settings) paramètres tels que : température, top-p, top-k et prompt système

<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%2FRCnTAZ6Uh88DIlU3g0Ij%2Fmainpage%20unsloth.png?alt=media&#x26;token=837c96b6-bd09-4e81-bc76-fa50421e9bfb" alt="" width="563"><figcaption></figcaption></figure></div>

Vous pouvez lire notre tutoriel / guide détaillé sur l’exécution de modèles avec Unsloth Studio ici :

{% content-ref url="chat" %}
[chat](https://unsloth.ai/docs/fr/nouveau/studio/chat)
{% endcontent-ref %}

## <i class="fa-video">:video:</i> 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="<https://www.youtube.com/watch?v=mmbkP8NARH4>" %}

Voici un tutoriel vidéo créé par NVIDIA pour vous aider à démarrer avec Studio :
{% endcolumn %}

{% column %}
{% embed url="<https://youtu.be/1lEDuRJWHh4?si=GHaS77ZZPOGjn3GJ>" %}

Tutoriel vidéo d’installation d’Unsloth Studio
{% endcolumn %}
{% endcolumns %}

## Paramètres avancés

### Commandes CLI

Le CLI Unsloth (`cli.py`) fournit les commandes suivantes :

```
Utilisation : cli.py [COMMANDE]

Commandes :
  train             Affiner un modèle
  inference         Exécuter l’inférence sur un modèle entraîné
  export            Exporter un adaptateur entraîné
  list-checkpoints  Lister les checkpoints 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 CLI
├── cli/                       # commandes CLI Typer
│   └── commands/
│       ├── train.py
│       ├── inference.py
│       ├── export.py
│       ├── ui.py
│       └── studio.py
├── setup.sh                   # script d’initialisation (Linux / WSL / Colab)
├── setup.ps1                  # script d’initialisation (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            # appli FastAPI et middleware
    │   ├── run.py             # lanceur de serveur (uvicorn)
    │   ├── auth/              # stockage d’authentification et logique JWT
    │   ├── routes/            # gestionnaires de 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/  # config d’entraînement et suivi
    │   │   │   ├── studio/    # espace de travail principal du studio
    │   │   │   ├── chat/      # interface de chat pour l’inférence
    │   │   │   ├── export/    # flux d’exportation du modèle
    │   │   │   └── onboarding/# assistant de prise en main
    │   │   ├── components/    # composants UI partagés (shadcn)
    │   │   ├── hooks/         # hooks React personnalisés
    │   │   ├── stores/        # magasins d’état Zustand
    │   │   └── types/         # définitions de types TypeScript
    │   ├── package.json
    │   └── vite.config.ts
    └── tests/                 # suite de tests backend
```

{% endcode %}

### Référence de l’API

Tous les points de terminaison nécessitent un JWT valide `Authorization: Bearer <token>` en en-tête (sauf `/api/auth/*` et `/api/health`).

| Méthode | Point de terminaison  | Description                                                                       |
| ------- | --------------------- | --------------------------------------------------------------------------------- |
| `GET`   | `/api/health`         | Vérification de l’état                                                            |
| `GET`   | `/api/system`         | Informations système (GPU, CPU, mémoire)                                          |
| `POST`  | `/api/auth/signup`    | Créer un compte (nécessite un jeton d’installation lors de la première exécution) |
| `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 un entraînement                                                          |
| `POST`  | `/api/train/stop`     | Arrêter un entraînement en cours                                                  |
| `POST`  | `/api/train/reset`    | Réinitialiser l’état d’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 (perte, taux d’apprentissage, étapes)        |
| `GET`   | `/api/train/stream`   | Flux SSE de la progression d’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 jeux 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=<question>
```

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.