Fine-tuning universel Axolotl

Fine-tuning de LLM piloté par YAML avec Axolotl sur Clore.ai — LoRA, QLoRA, DPO, multi-GPU

Axolotl regroupe HuggingFace Transformers, PEFT, TRL et DeepSpeed dans une interface unique pilotée par YAML. Vous définissez votre modèle, jeu de données, méthode d'entraînement et hyperparamètres dans un seul fichier de configuration — puis lancez avec une seule commande. Aucun script Python requis pour les flux de travail standard.

Tous les exemples s'exécutent sur des serveurs GPU loués via le CLORE.AI Marketplace.

Principales caractéristiques

• Configuration uniquement YAML — définissez tout dans un seul fichier, pas de Python nécessaire

• Toutes les méthodes d'entraînement — LoRA, QLoRA, entraînement complet, DPO, ORPO, KTO, RLHF

• Multi-GPU prêt à l'emploi — DeepSpeed ZeRO 1/2/3 et FSDP avec un seul indicateur

• Regroupement d'exemples — concaténer de courts exemples pour remplir la longueur de séquence, gain de débit 3–5×

• Flash Attention 2 — économies de VRAM automatiques sur le matériel pris en charge

• Large compatibilité de modèles — Llama 3.x, Mistral, Qwen 2.5, Gemma 2, Phi-4, DeepSeek, Falcon

• Formats de jeux de données intégrés — alpaca, sharegpt, chat_template, completion et personnalisé

Exigences

Composant	Minimum	Recommandé
GPU	RTX 3060 12 Go	RTX 4090 24 Go (×2+)
VRAM	12 Go	24+ Go
RAM	16 Go	64 Go
Disque	50 Go	100 Go
CUDA	11.8	12.1+
Python	3.10	3.11

Tarifs Clore.ai : RTX 4090 ≈ 0,5–2 $/jour · RTX 3090 ≈ 0,3–1 $/jour · RTX 3060 ≈ 0,15–0,3 $/jour

Démarrage rapide

1. Installer Axolotl

# Cloner et installer
git clone https://github.com/OpenAccess-AI-Collective/axolotl.git
cd axolotl

pip install packaging ninja
pip install -e '.[flash-attn,deepspeed]'

Ou utilisez l'image Docker (recommandé pour la reproductibilité) :

docker run --gpus all -it --rm \
  -v /workspace:/workspace \
  winglian/axolotl:main-latest

2. Créez un fichier de configuration

Enregistrez ceci sous config.yml:

base_model: meta-llama/Meta-Llama-3.1-8B-Instruct
model_type: LlamaForCausalLM
tokenizer_type: AutoTokenizer

load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 16
lora_dropout: 0.05
lora_target_linear: true

datasets:
  - path: yahma/alpaca-cleaned
    type: alpaca

sequence_len: 2048
sample_packing: true
pad_to_sequence_len: true

wandb_project: axolotl-clore
wandb_name: llama3-qlora

output_dir: /workspace/axolotl-output

gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 1
learning_rate: 2e-4
optimizer: adamw_bnb_8bit
lr_scheduler: cosine
warmup_steps: 10

bf16: auto
flash_attention: true
gradient_checkpointing: true

logging_steps: 10
save_strategy: steps
save_steps: 500
eval_steps: 500

evals_per_epoch:
val_set_size: 0.02

3. Lancer l'entraînement

# GPU unique
accelerate launch -m axolotl.cli.train config.yml

# Multi-GPU (tous les GPU disponibles)
accelerate launch --multi_gpu -m axolotl.cli.train config.yml

Journaux de progression de l'entraînement vers stdout et éventuellement vers Weights & Biases.

Approfondissement de la configuration

Formats de jeux de données

Axolotl prend en charge plusieurs formats d'entrée nativement :

# Style Alpaca (instruction / input / output)
datasets:
  - path: yahma/alpaca-cleaned
    type: alpaca

# ShareGPT conversation multi-tour
datasets:
  - path: anon8231489123/ShareGPT_Vicuna_unfiltered
    type: sharegpt
    conversation: chatml

# Modèle de chat (détection automatique via le tokenizer)
datasets:
  - path: HuggingFaceH4/ultrachat_200k
    type: chat_template
    field_messages: messages
    message_field_role: role
    message_field_content: content

# Fichier JSONL local
datasets:
  - path: /workspace/data/my_dataset.jsonl
    type: alpaca
    ds_type: json

Multi-GPU avec DeepSpeed

Créer deepspeed_zero2.json:

{
  "bf16": { "enabled": true },
  "zero_optimization": {
    "stage": 2,
    "offload_optimizer": { "device": "cpu" },
    "allgather_partitions": true,
    "allgather_bucket_size": 5e8,
    "reduce_scatter": true,
    "reduce_bucket_size": 5e8,
    "overlap_comm": true,
    "contiguous_gradients": true
  },
  "train_micro_batch_size_per_gpu": "auto",
  "gradient_accumulation_steps": "auto",
  "gradient_clipping": 1.0
}

Ajoutez à votre configuration :

deepspeed: deepspeed_zero2.json

Puis lancez :

accelerate launch --num_processes 4 -m axolotl.cli.train config.yml

Alignement DPO / ORPO

base_model: meta-llama/Meta-Llama-3.1-8B-Instruct
rl: dpo
# ou : rl: orpo

datasets:
  - path: argilla/ultrafeedback-binarized-preferences
    type: chat_template.default
    field_messages: chosen
    field_chosen: chosen
    field_rejected: rejected

dpo_beta: 0.1

Entraînement complet (sans LoRA)

base_model: meta-llama/Meta-Llama-3.1-8B-Instruct

# Pas d'adaptateur, pas de quantification
adapter:
load_in_4bit: false
load_in_8bit: false

learning_rate: 5e-6
micro_batch_size: 1
gradient_accumulation_steps: 8
gradient_checkpointing: true
flash_attention: true
bf16: auto

deepspeed: deepspeed_zero3.json  # requis pour l'entraînement complet des modèles 8B+

Exemples d'utilisation

Inférence après entraînement

# Lancer l'inférence interactive
accelerate launch -m axolotl.cli.inference config.yml \
  --lora_model_dir /workspace/axolotl-output

Fusionner LoRA dans le modèle de base

accelerate launch -m axolotl.cli.merge_lora config.yml \
  --lora_model_dir /workspace/axolotl-output \
  --output_dir /workspace/merged-model

Prétraiter le jeu de données (valider avant l'entraînement)

python -m axolotl.cli.preprocess config.yml

Cela tokenise et valide le jeu de données. Utile pour détecter les erreurs de format avant une longue session d'entraînement.

Référence d'utilisation de la VRAM

Modèle	Méthode	GPUs	VRAM/GPU	Configuration
Llama 3.1 8B	QLoRA 4bits	1	≈12 Go	r=32, seq_len=2048
Llama 3.1 8B	LoRA 16bits	1	≈20 Go	r=16, seq_len=2048
Llama 3.1 8B	Complet	2	≈22 Go	DeepSpeed ZeRO-3
Qwen 2.5 14B	QLoRA 4bits	1	~16 Go	r=16, seq_len=2048
Llama 3.3 70B	QLoRA 4bits	2	≈22 Go	r=16, seq_len=2048
Llama 3.3 70B	Complet	4	≈40 Go	DeepSpeed ZeRO-3+offload

Conseils

• Toujours activer sample_packing: true — plus grande amélioration unique du débit (3–5× sur les jeux de données courts)

• Utilisez flash_attention: true sur GPU Ampere+ pour 20–40 % d'économies de VRAM

• Commencez par QLoRA pour les expériences, passez à l'entraînement complet seulement lorsque la qualité LoRA atteint un plateau

• Définir val_set_size: 0.02 pour surveiller le surapprentissage pendant l'entraînement

• Prétraitez d'abord — exécutez axolotl.cli.preprocess pour valider le format des données avant de s'engager dans une longue exécution

• Utilisez l'image Docker pour des environnements reproductibles — évite les conflits de dépendances

• lora_target_linear: true applique LoRA à toutes les couches linéaires, généralement mieux que de ne cibler que l'attention

Dépannage

Problème	Solution
OutOfMemoryError	Plus bas micro_batch_size à 1, activez gradient_checkpointing
Erreurs de format de jeu de données	Exécutez python -m axolotl.cli.preprocess config.yml pour déboguer
sample_packing lent sur la première époque	Normal — le calcul initial du regroupement est une opération ponctuelle
L'entraînement Multi-GPU bloque	Vérifiez NCCL : export NCCL_DEBUG=INFO, assurez-vous que tous les GPU sont visibles
flash_attention erreur d'importation	Installer : pip install flash-attn --no-build-isolation
La perte n'augmente pas (ne diminue pas)	Baissez le LR à 1e-4, augmentez le warmup, vérifiez la qualité du jeu de données
Erreur de connexion WandB	Exécutez wandb login ou définissez wandb_project: sur une chaîne vide

Ressources

• Axolotl GitHub

• Exemples de configurations

• CLORE.AI Marketplace