> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/entrainement/llama-factory.md).

# LLaMA-Factory

Affinez plus de 100 LLM avec LoRA/QLoRA et une interface web sur les GPU Clore.ai à l'aide de LLaMA-Factory

LLaMA-Factory est le framework de fine-tuning open source le plus complet, prenant en charge plus de 100 modèles de langage, dont toutes les variantes de LLaMA, Qwen, Mistral, Phi, Falcon, ChatGLM, et bien d’autres. Il propose LoRA, QLoRA, le fine-tuning complet, RLHF, DPO et PPO — le tout via une interface Web intuitive (LLaMA Board) ou en CLI. Les serveurs GPU à la demande de CLORE.AI en font la plateforme idéale pour lancer des jobs de fine-tuning à une fraction du coût des fournisseurs cloud.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

| Paramètre | Minimum          | Recommandé     |
| --------- | ---------------- | -------------- |
| RAM       | 16 Go            | 32 Go+         |
| VRAM      | 8 Go (QLoRA)     | 24 Go+         |
| Disque    | 50 Go            | 200 Go+        |
| GPU       | NVIDIA RTX 2080+ | A100, RTX 4090 |

{% hint style="info" %}
**La méthode d'entraînement détermine les exigences en GPU :**

* **QLoRA (4 bits)**: 8 Go de VRAM pour les modèles 7B, 16 Go pour les 13B
* **LoRA (float16)**: 16 Go de VRAM pour les modèles 7B, 40 Go pour les 13B
* **Fine-tuning complet**: \~14 Go de VRAM par paramètre 7B (+ états de l'optimiseur)
* Le multi-GPU (DeepSpeed/FSDP) s'adapte à n'importe quel nombre de GPU
  {% endhint %}

## Déploiement rapide sur CLORE.AI

**Image Docker :** `hiyouga/llamafactory:latest`

**Ports :** `22/tcp`, `7860/http`

**Variables d'environnement :**

| Variable               | Exemple     | Description                                    |
| ---------------------- | ----------- | ---------------------------------------------- |
| `HF_TOKEN`             | `hf_xxx...` | Jeton HuggingFace pour les modèles protégés    |
| `WANDB_API_KEY`        | `xxx...`    | Weights & Biases pour le suivi des expériences |
| `CUDA_VISIBLE_DEVICES` | `0,1`       | GPU à utiliser                                 |

## Configuration étape par étape

### 1. Louez un serveur GPU sur CLORE.AI

Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace) et sélectionnez selon votre tâche :

| Tâche         | VRAM  | GPU recommandé          |
| ------------- | ----- | ----------------------- |
| QLoRA 7B      | 8 Go  | RTX 3070/2080           |
| QLoRA 13B     | 16 Go | RTX 3090/A4000          |
| LoRA 7B       | 16 Go | RTX 3090/A4000          |
| LoRA 13B      | 40 Go | A6000/A100 40 Go        |
| FT complet 7B | 80 Go | A100 80 Go              |
| Multi-GPU     | Varie | 2-8× n'importe quel GPU |

### 2. Connectez-vous en SSH à votre serveur

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Créer les répertoires de travail

```bash
mkdir -p /root/llamafactory/{data,models,output,saves}
```

### 4. Récupérer l'image Docker

```bash
docker pull hiyouga/llamafactory:latest
```

### 5. Lancer LLaMA-Factory

**Lancer avec l'interface Web (LLaMA Board) :**

```bash
docker run -d \
  --name llamafactory \\
  --gpus all \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \\
  -v /root/llamafactory/models:/root/.cache/huggingface \\
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \\
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \\
  -e HF_TOKEN=hf_your_token_here \
  hiyouga/llamafactory:latest \\
  llamafactory-cli webui
```

**Avec le suivi Weights & Biases :**

```bash
docker run -d \
  --name llamafactory \\
  --gpus all \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \\
  -v /root/llamafactory/models:/root/.cache/huggingface \\
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \\
  -v /root/llamafactory/saves:/app/LLaMA-Factory/saves \\
  -e HF_TOKEN=hf_your_token_here \
  -e WANDB_API_KEY=your_wandb_key \\
  hiyouga/llamafactory:latest \\
  llamafactory-cli webui
```

**Multi-GPU avec DeepSpeed (4 GPU) :**

```bash
docker run -d \
  --name llamafactory \\
  --gpus all \
  --shm-size 16g \
  --ipc host \
  -p 7860:7860 \
  -v /root/llamafactory/data:/app/LLaMA-Factory/data \\
  -v /root/llamafactory/models:/root/.cache/huggingface \\
  -v /root/llamafactory/output:/app/LLaMA-Factory/output \\
  -e CUDA_VISIBLE_DEVICES=0,1,2,3 \\
  hiyouga/llamafactory:latest \\
  bash -c "llamafactory-cli webui"
```

### 6. Accéder à l'interface Web

Vérifiez les journaux et obtenez l'URL :

```bash
docker logs -f llamafactory
```

Votre URL http\_pub CLORE.AI pour le port 7860 :

```
https://<order-id>-7860.clore.ai/
```

***

## Exemples d'utilisation

### Exemple 1 : Fine-tuning LoRA via l'interface Web (LLaMA Board)

1. Ouvrez LLaMA Board à votre URL CLORE.AI
2. Allez à **Entraîner** onglet
3. Configurer :
   * **Nom du modèle**: `LLaMA-3` → `Meta-Llama-3-8B-Instruct`
   * **Étape d'entraînement**: `Fine-tuning supervisé`
   * **Jeu de données**: Sélectionnez votre jeu de données (ou téléversez-en un personnalisé)
   * **Méthode de fine-tuning**: `lora`
   * **rang LoRA**: `8` (plus élevé = plus de paramètres entraînés)
   * **Taux d'apprentissage**: `1e-4`
   * **Époques**: `3`
   * **Répertoire de sortie**: `llama3-finetuned`
4. Cliquez sur **Démarrer** pour commencer l'entraînement
5. Surveillez les courbes de perte dans le **Perte** graphique

### Exemple 2 : Fine-tuning QLoRA via la CLI

Préparez un fichier de configuration d'entraînement YAML :

```bash
docker exec -it llamafactory bash

cat > /app/LLaMA-Factory/configs/qlora_mistral.yaml << 'EOF'
### Modèle
model_name_or_path: mistralai/Mistral-7B-Instruct-v0.3

### Méthode
stage: sft
do_train: true
finetuning_type: lora
lora_target: all
lora_rank: 16
lora_alpha: 32
lora_dropout: 0.05

### Jeu de données
dataset: alpaca_en
template: mistral
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

### Sortie
output_dir: saves/mistral-qlora
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

### Entraînement
per_device_train_batch_size: 2
gradient_accumulation_steps: 8
learning_rate: 0.0001
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
fp16: true

### Quantification
quantization_method: bitsandbytes
quantization_bit: 4
EOF

# Lancer l'entraînement
llamafactory-cli train /app/LLaMA-Factory/configs/qlora_mistral.yaml
```

### Exemple 3 : Téléverser un jeu de données personnalisé

Créez un jeu de données personnalisé au format Alpaca :

```bash
# Créer le fichier de jeu de données
cat > /root/llamafactory/data/my_dataset.json << 'EOF'
[
  {
    "instruction": "Vous êtes un agent du service client pour une entreprise technologique. Répondez de manière utile.",
    "input": "Mon ordinateur portable ne s'allume plus après la mise à jour. Que dois-je faire ?",
    "output": "Je comprends à quel point cela peut être frustrant. Diagnosticons le problème étape par étape :\n\n1. **Maintenez le bouton d'alimentation enfoncé pendant 10 secondes** pour forcer l'arrêt\n2. **Débranchez le câble d'alimentation** et la batterie si elle est amovible, puis attendez 30 secondes\n3. **Rebranchez l'alimentation** et essayez de rallumer l'appareil\n4. Si rien ne se passe encore, appuyez sur **F8/F11** pendant le démarrage pour accéder au mode de récupération\n\nVoulez-vous que je vous guide en détail pour l'une de ces étapes ?"
  },
  {
    "instruction": "Vous êtes un agent du service client pour une entreprise technologique.",
    "input": "Comment réinitialiser mon mot de passe ?",
    "output": "Réinitialiser votre mot de passe est facile ! Voici comment faire :\n\n1. Allez sur la page de connexion et cliquez sur **'Mot de passe oublié'**\n2. Saisissez votre **adresse e-mail enregistrée**\n3. Vérifiez votre e-mail pour un lien de réinitialisation (vérifiez aussi le dossier spam)\n4. Cliquez sur le lien et **créez un nouveau mot de passe**\n\nLe lien de réinitialisation expire dans 24 heures. Si vous ne recevez pas l'e-mail dans les 5 minutes, contactez notre équipe d'assistance."
  }
]
EOF

# Enregistrer le jeu de données dans dataset_info.json
docker exec -it llamafactory bash -c "
cat >> /app/LLaMA-Factory/data/dataset_info.json << 'EOF2'
,
\"my_dataset\": {
  \"file_name\": \"/root/llamafactory/data/my_dataset.json\"
}
EOF2
"
```

Puis sélectionnez `my_dataset` dans le menu déroulant Jeu de données de LLaMA Board.

### Exemple 4 : DPO (Optimisation directe des préférences)

```yaml
### configs/dpo_llama.yaml

model_name_or_path: meta-llama/Meta-Llama-3-8B-Instruct

### Méthode - DPO
stage: dpo
do_train: true
finetuning_type: lora
lora_rank: 8

### Spécifique au DPO
pref_beta: 0.1
pref_loss: sigmoid  # sigmoid, hinge, ipo

### Jeu de données (doit être au format de préférence)
dataset: dpo_en_demo
template: llama3
cutoff_len: 2048

### Sortie
output_dir: saves/llama3-dpo
logging_steps: 10
save_steps: 100

### Entraînement
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
learning_rate: 5e-5
num_train_epochs: 1.0
fp16: true
```

```bash
docker exec -it llamafactory bash -c "llamafactory-cli train /configs/dpo_llama.yaml"
```

### Exemple 5 : Inférence avec un modèle affiné

Après l'entraînement, testez votre modèle :

```bash
docker exec -it llamafactory bash

# Chat interactif
llamafactory-cli chat \\
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \\
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \\
  --template mistral \\
  --finetuning_type lora
```

Ou exportez le modèle fusionné :

```bash
llamafactory-cli export \\
  --model_name_or_path mistralai/Mistral-7B-Instruct-v0.3 \\
  --adapter_name_or_path /app/LLaMA-Factory/saves/mistral-qlora \\
  --template mistral \\
  --finetuning_type lora \\
  --export_dir /app/LLaMA-Factory/output/mistral-merged \\
  --export_size 4 \\
  --export_legacy_format false
```

***

## Configuration

### Paramètres d'entraînement clés

| Paramètre                     | Valeur typique | Description                             |
| ----------------------------- | -------------- | --------------------------------------- |
| `lora_rank`                   | 8–64           | Rang LoRA (plus élevé = plus expressif) |
| `lora_alpha`                  | 2× le rang     | Mise à l'échelle alpha de LoRA          |
| `lora_dropout`                | 0.0–0.1        | Dropout pour les couches LoRA           |
| `lora_target`                 | `all`          | Quelles couches appliquer à LoRA        |
| `learning_rate`               | `1e-4`         | Taux d'apprentissage initial            |
| `num_train_epochs`            | 1–5            | Époques d'entraînement                  |
| `per_device_train_batch_size` | 1–4            | Taille du batch par GPU                 |
| `gradient_accumulation_steps` | 4–16           | Multiplicateur de batch effectif        |
| `cutoff_len`                  | 1024–4096      | Longueur maximale de séquence           |
| `quantization_bit`            | 4 ou 8         | Bits de quantification QLoRA            |
| `warmup_ratio`                | 0.05–0.1       | Fraction de préchauffage du LR          |
| `lr_scheduler_type`           | `cosine`       | Planificateur de LR                     |

### Méthodes de fine-tuning prises en charge

| Méthode              | Utilisation mémoire | Qualité    | Quand l'utiliser          |
| -------------------- | ------------------- | ---------- | ------------------------- |
| `complet`            | Très élevée         | Meilleur   | VRAM illimitée            |
| `gel`                | Moyen               | Bon        | Geler les couches de base |
| `lora`               | Faible              | Très bonne | Choix par défaut          |
| `qlora` (lora+quant) | Le plus bas         | Bon        | VRAM limitée              |

### Entraînement multi-GPU avec DeepSpeed

Pour entraîner sur plusieurs GPU, lancez avec `torchrun`:

```bash
docker exec -it llamafactory bash -c "
FORCE_TORCHRUN=1 NNODES=1 RANK=0 MASTER_ADDR=127.0.0.1 MASTER_PORT=29500 \\
llamafactory-cli train configs/qlora_mistral.yaml \\
  --deepspeed examples/deepspeed/ds_z3_config.json
"
```

***

## Conseils de performance

### 1. Paramètres QLoRA optimaux par GPU

**8 Go de VRAM (RTX 3070) :**

```yaml
quantization_bit: 4
per_device_train_batch_size: 1
gradient_accumulation_steps: 8
cutoff_len: 1024
```

**24 Go de VRAM (RTX 3090/4090) :**

```yaml
quantization_bit: 4  # Utilisez quand même QLoRA pour une taille de batch plus grande
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
cutoff_len: 2048
```

**80 Go de VRAM (A100) :**

```yaml
# Pas besoin de quantification — utilisez LoRA directement
finetuning_type: lora
per_device_train_batch_size: 8
gradient_accumulation_steps: 2
cutoff_len: 4096
fp16: true
```

### 2. Flash Attention 2 pour des contextes plus longs

```yaml
flash_attn: fa2  # Nécessite un GPU Ampere ou supérieur
```

Cela permet d'entraîner avec des séquences 2× plus longues sur la même VRAM.

### 3. Checkpointing des gradients

Économise de la VRAM au prix d'un entraînement environ 20 % plus lent :

```yaml
gradient_checkpointing: true
```

### 4. Choisir la bonne cible LoRA

```yaml
lora_target: all  # Toutes les couches linéaires (par défaut, meilleure qualité)
# ou
lora_target: q_proj,v_proj  # Minimal, le plus rapide, qualité moindre
```

### 5. Geler les couches supérieures pour une adaptation rapide

```yaml
finetuning_type: freeze
freeze_trainable_layers: 2   # N'entraîner que les 2 couches du haut
freeze_trainable_modules: all
```

Beaucoup plus rapide que le LoRA complet pour une adaptation simple à une tâche.

### 6. Surveiller avec TensorBoard

```bash
# Dans un terminal séparé
docker exec -it llamafactory bash -c "
tensorboard --logdir /app/LLaMA-Factory/saves --host 0.0.0.0 --port 6006
"
```

Ajoutez le port 6006 à votre commande CLORE.AI pour accéder à TensorBoard.

***

## Dépannage

### Problème : « CUDA out of memory » pendant l'entraînement

1. Réduisez la taille du batch : `per_device_train_batch_size: 1`
2. Activez le checkpointing des gradients : `gradient_checkpointing: true`
3. Réduisez la longueur du contexte : `cutoff_len: 512`
4. Utilisez QLoRA (4 bits) : `quantization_bit: 4`
5. Réduisez le rang LoRA : `lora_rank: 4`

### Problème : la perte d'entraînement ne diminue pas

* Vérifiez le taux d'apprentissage — essayez `5e-5` ou `2e-4`
* Vérifiez que le format du jeu de données correspond au modèle
* Augmentez `lora_rank` (8→16→32)
* Vérifiez que `lora_target: all` est défini

### Problème : vitesse d'entraînement lente

```bash
# Vérifiez l'utilisation du GPU à l'intérieur du conteneur
docker exec -it llamafactory bash -c "watch -n 1 nvidia-smi"
```

Si le GPU est utilisé à moins de 80 % :

* Augmenter la taille du lot
* Utilisez Flash Attention : `flash_attn: fa2`
* Supprimez `gradient_checkpointing` si la VRAM le permet

### Problème : modèle introuvable dans l'interface Web

```bash
# Pré-télécharger dans le volume de cache
docker exec -it llamafactory bash -c "
huggingface-cli download mistralai/Mistral-7B-Instruct-v0.3
"
```

Puis actualisez la liste des modèles dans LLaMA Board.

### Problème : erreurs de format du jeu de données

Tous les formats de jeu de données doivent correspondre `dataset_info.json` spécification :

```bash
# Valider le jeu de données
docker exec -it llamafactory python3 -c "
import json
with open('/app/LLaMA-Factory/data/my_dataset.json') as f:
    data = json.load(f)
print(f'Le jeu de données contient {len(data)} exemples')
print('Clés du premier exemple :', list(data[0].keys()))
"
```

### Problème : port WebUI inaccessible

Assurez-vous que LLaMA-Factory a démarré le serveur Gradio :

```bash
docker logs llamafactory 2>&1 | grep -E "Running on|Error|Traceback"
```

Ajoutez `--share` indicateur pour une URL Gradio publique comme alternative.

***

## Liens

* [GitHub](https://github.com/hiyouga/LLaMA-Factory)
* [Documentation](https://llamafactory.readthedocs.io)
* [Docker Hub (hiyouga)](https://hub.docker.com/r/hiyouga/llamafactory)
* [Modèles pris en charge](https://github.com/hiyouga/LLaMA-Factory?tab=readme-ov-file#supported-models)
* [Format du jeu de données](https://github.com/hiyouga/LLaMA-Factory/blob/main/data/README.md)
* [la place de marché CLORE.AI](https://clore.ai/marketplace)

***

## Recommandations GPU Clore.ai

{% hint style="warning" %}
**Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| Cas d’utilisation      | GPU recommandé   | Coût estimé sur Clore.ai                  |
| ---------------------- | ---------------- | ----------------------------------------- |
| Développement/Test     | RTX 3090 (24 Go) | 0,07–0,21 $/gpu/h                         |
| Affinage (7B–13B)      | RTX 4090 (24 Go) | 0,14–0,42 $/gpu/h                         |
| Grands modèles (70B+)  | A100 80 Go       | [bare metal](https://clore.ai/bare-metal) |
| Entraînement multi-GPU | 2-4x A100 80 Go  | [bare metal](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.


---

# 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://docs.clore.ai/guides/guides_v2-fr/entrainement/llama-factory.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.