Fine-tuning universel Axolotl

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

Axolotl enveloppe HuggingFace Transformers, PEFT, TRL et DeepSpeed dans une interface unique pilotée par YAML. Vous définissez votre modèle, votre jeu de données, votre méthode d’entraînement et vos hyperparamètres dans un seul fichier de configuration — puis vous lancez tout 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 la place de marché CLORE.AI.

Caractéristiques clés

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

• Toutes les méthodes d’entraînement — LoRA, QLoRA, fine-tuning complet, DPO, ORPO, KTO, RLHF

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

• Empaquetage d’exemples — concaténez de courts exemples pour remplir la longueur de séquence, gain de débit de 3 à 5×

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

• Prise en charge étendue des 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 GB	RTX 4090 24 Go (×2+)
VRAM	12 Go	24+ Go
RAM	16 Go	64 Go
Disque	50 Go	100 Go
CUDA	12.8+	12.8+
Python	3.10	3.11

Tarification Clore.ai : RTX 4090 ≈ 0,14–0,42 $/h · RTX 3090 ≈ 0,07–0,21 $/h · RTX 3060 ≈ 0,03–0,07 $/h

Démarrage rapide

1. Installez 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. Lancez 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

La progression de l’entraînement est journalisée sur stdout et éventuellement dans Weights & Biases.

Plongée approfondie dans la configuration

Formats de jeux de données

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

# Style Alpaca (instruction / entrée / sortie)
datasets:
  - path: yahma/alpaca-cleaned
    type: alpaca

# Chat multi-tour ShareGPT
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éez un fichier 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

Fine-tuning 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 un fine-tuning complet de 8B+

Exemples d'utilisation

Inférence après l’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 tokenize 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	GPU	VRAM/GPU	Configuration
Llama 3.1 8B	QLoRA 4 bits	1	~12 Go	r=32, seq_len=2048
Llama 3.1 8B	LoRA 16 bits	1	~20 Go	r=16, seq_len=2048
Llama 3.1 8B	Complet	2	~22 Go	DeepSpeed ZeRO-3
Qwen 2.5 14B	QLoRA 4 bits	1	~16 GB	r=16, seq_len=2048
Llama 3.3 70B	QLoRA 4 bits	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 — le plus grand gain de débit (3–5× sur les jeux de données courts)

• Utilisez flash_attention: true sur les GPU Ampere+ pour économiser 20 à 40 % de VRAM

• Commencez avec QLoRA pour les expérimentations, passez au fine-tuning complet uniquement lorsque la qualité de LoRA stagne

• Définissez 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 formatage des données avant de lancer une exécution longue

• 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 cibler uniquement l’attention

Dépannage

Problème	Solution
OutOfMemoryError	Réduisez 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 lors de la première époque	Normal — le calcul initial du packing est unique
L'entraînement multi-GPU se bloque	Vérifiez NCCL : export NCCL_DEBUG=INFO, assurez-vous que toutes les GPU sont visibles
flash_attention erreur d'importation	Installez : pip install flash-attn --no-build-isolation
La perte ne diminue pas	Réduisez le taux d’apprentissage à 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

• GitHub d’Axolotl

• Exemples de configuration

• la place de marché CLORE.AI