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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

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

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

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

ssh -p <PORT> root@<SERVER_IP>

3. Créer les répertoires de travail

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

4. Récupérer l'image Docker

docker pull hiyouga/llamafactory:latest

5. Lancer LLaMA-Factory

Lancer avec l'interface Web (LLaMA Board) :

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 :

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

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 :

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 :

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 :

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

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

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 :

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

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:

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

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

24 Go de VRAM (RTX 3090/4090) :

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

# 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

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 :

gradient_checkpointing: true

4. Choisir la bonne cible LoRA

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

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

# 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

# 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

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

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

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

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

---

Liens

• GitHub

• Documentation

• Docker Hub (hiyouga)

• Modèles pris en charge

• Format du jeu de données

• la place de marché CLORE.AI

---

Recommandations GPU Clore.ai

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 sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

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
Entraînement multi-GPU	2-4x A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.