Affiner un LLM

Affinez des LLM personnalisés avec des techniques efficaces sur les GPU Clore.ai

Entraînez votre propre LLM personnalisé en utilisant des techniques d'ajustement fin efficaces sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces Web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<adresse-proxy>

Qu'est-ce que LoRA/QLoRA ?

• LoRA (Adaptation de rang faible) - Entraînez de petites couches adaptatrices au lieu du modèle complet

• QLoRA - LoRA avec quantification pour encore moins de VRAM

• Entraîner un modèle 7B sur une seule RTX 3090

• Entraîner un modèle 70B sur une seule A100

Exigences

Modèle	Méthode	VRAM min	Recommandé
7B	QLoRA	12Go	RTX 3090
13B	QLoRA	20Go	RTX 4090
70B	QLoRA	48Go	A100 80GB
7B	LoRA complet	24 Go	RTX 4090

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports :

22/tcp
8888/http
6006/http

Commande :

pip install "transformers>=4.45" "datasets>=2.20" accelerate "peft>=0.14" \
    bitsandbytes "trl>=0.12" wandb jupyterlab && \
jupyter lab --ip=0.0.0.0 --port=8888 --allow-root

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à la Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Préparation du jeu de données

Format de chat (recommandé)

[
  {
    "messages": [
      {"role": "system", "content": "Vous êtes un assistant serviable."},
      {"role": "user", "content": "Qu'est-ce que Python ?"},
      {"role": "assistant", "content": "Python est un langage de programmation..."}
    ]
  }
]

Format d'instruction

[
  {
    "instruction": "Traduire en français",
    "input": "Bonjour, comment ça va ?",
    "output": "Bonjour, comment allez-vous ?"
  }
]

Format Alpaca

[
  {
    "instruction": "Donnez trois conseils pour rester en bonne santé.",
    "input": "",
    "output": "1. Mangez des repas équilibrés..."
  }
]

Modèles modernes pris en charge (2025)

Modèle	ID HF	VRAM min (QLoRA)
Llama 3.1 / 3.3 8B	meta-llama/Llama-3.1-8B-Instruct	12Go
Qwen 2.5 7B / 14B	Qwen/Qwen2.5-7B-Instruct	12GB / 20GB
DeepSeek-R1-Distill (7B/8B)	deepseek-ai/DeepSeek-R1-Distill-Qwen-7B	12Go
Mistral 7B v0.3	mistralai/Mistral-7B-Instruct-v0.3	12Go
Gemma 2 9B	google/gemma-2-9b-it	14GB
Phi-4 14B	microsoft/phi-4	20Go

Script d'ajustement fin QLoRA

Exemple moderne avec PEFT 0.14+, Flash Attention 2, prise en charge DoRA, et compatibilité Qwen2.5 / DeepSeek-R1 :

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from datasets import load_dataset
from trl import SFTTrainer, SFTConfig

# === Configuration ===
# Choisissez l'un de : Qwen2.5, DeepSeek-R1-Distill, Llama 3.1, Mistral, etc.
MODEL_NAME = "Qwen/Qwen2.5-7B-Instruct"
# MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
# MODEL_NAME = "meta-llama/Llama-3.1-8B-Instruct"

DATASET = "your_dataset.json"  # ou nom de dataset HuggingFace
OUTPUT_DIR = "./output"
MAX_SEQ_LENGTH = 4096           # Qwen2.5 prend en charge jusqu'à 32K de contexte
USE_DORA = True                 # DoRA améliore la qualité par rapport à LoRA standard
USE_FLASH_ATTN = True           # Flash Attention 2 économise de la VRAM et accélère

# === Charger le modèle avec quantification 4 bits ===
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,  # Requis pour Qwen2.5 et DeepSeek
    # Flash Attention 2 : nécessite un GPU Ampere+ (RTX 30/40, A100)
    attn_implementation="flash_attention_2" if USE_FLASH_ATTN else "eager",
)

tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

# === Configurer LoRA avec DoRA optionnel ===
# DoRA (Adaptation de rang faible décomposée des poids) — PEFT >= 0.14 requis
# use_dora=True décompose les poids en magnitude + direction pour une meilleure qualité
lora_config = LoraConfig(
    r=64,                    # Rang (plus élevé = plus de capacité, plus de VRAM)
    lora_alpha=16,           # Facteur d'échelle (garder égal ou la moitié de r)
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",  # Couches d'attention
        "gate_proj", "up_proj", "down_proj",      # Couches MLP
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    use_dora=USE_DORA,        # DoRA : qualité améliorée (PEFT 0.14+)
    # use_rslora=True,        # Optionnel : Rank-Stabilized LoRA
)

# Préparer le modèle pour l'entraînement QLoRA
model = prepare_model_for_kbit_training(
    model,
    use_gradient_checkpointing=True,
    gradient_checkpointing_kwargs={"use_reentrant": False},
)
model = get_peft_model(model, lora_config)

# Afficher le résumé des paramètres entraînables
model.print_trainable_parameters()
# Exemple de sortie : params entraînables : 42 991 616 || params totaux : 7 284 891 648 || % entraînables : 0,59

# === Charger le dataset ===
dataset = load_dataset("json", data_files=DATASET)
# Ou utilisez un dataset public :
# dataset = load_dataset("HuggingFaceH4/ultrachat_200k")

# === Formater le dataset pour Qwen2.5 / format ChatML ===
def format_chat_qwen(example):
    """Format pour Qwen2.5 en utilisant le template ChatML."""
    messages = example.get("messages", [])
    if not messages:
        # Gérer les données de type alpaca
        text = f"<|im_start|>system\nVous êtes un assistant utile.<|im_end|>\n"
        text += f"<|im_start|>user\n{example['instruction']}"
        if example.get("input"):
            text += f"\n{example['input']}"
        text += f"<|im_end|>\n<|im_start|>assistant\n{example['output']}<|im_end|>"
    else:
        # Gérer le format messages (ChatML)
        text = tokenizer.apply_chat_template(
            messages,
            tokenize=False,
            add_generation_prompt=False,
        )
    return {"text": text}

dataset = dataset.map(format_chat_qwen, remove_columns=dataset["train"].column_names)

# === Arguments d'entraînement (PEFT 0.14+ / TRL 0.12+) ===
training_args = SFTConfig(
    output_dir=OUTPUT_DIR,
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,         # Batch effectif = 2 * 8 = 16
    learning_rate=2e-4,
    weight_decay=0.001,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    logging_steps=10,
    save_steps=100,
    save_total_limit=3,
    bf16=True,                             # Utiliser bf16 pour les GPU modernes (A100, RTX 30/40)
    # fp16=True,                           # Utiliser fp16 pour les GPU plus anciens
    optim="paged_adamw_8bit",
    max_grad_norm=0.3,
    group_by_length=True,
    report_to="wandb",                     # ou "tensorboard"
    # Spécifique à SFTConfig :
    max_seq_length=MAX_SEQ_LENGTH,
    dataset_text_field="text",
    packing=True,                          # Empiler plusieurs exemples pour l'efficacité
)

# === Entraîner ===
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    tokenizer=tokenizer,
    args=training_args,
)

trainer.train()

# === Sauvegarder l'adaptateur LoRA ===
trainer.save_model(f"{OUTPUT_DIR}/final")
tokenizer.save_pretrained(f"{OUTPUT_DIR}/final")
print(f"Modèle enregistré dans {OUTPUT_DIR}/final")

Flash Attention 2

Flash Attention 2 réduit l'utilisation de la VRAM et accélère significativement l'entraînement. Nécessite un GPU Ampere+ (RTX 3090, RTX 4090, A100).

# Installer Flash Attention 2
pip install flash-attn --no-build-isolation

# Activer lors du chargement du modèle :
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    attn_implementation="flash_attention_2",  # <-- ajoutez ceci
    torch_dtype=torch.bfloat16,               # FA2 nécessite bf16 ou fp16
    device_map="auto",
)

Paramètre	VRAM (7B)	Vitesse
Attention standard (fp16)	~22GB	référence
Flash Attention 2 (bf16)	~16GB	+30%
Flash Attention 2 + QLoRA	~12GB	+30%

DoRA (LoRA décomposé par poids)

DoRA (PEFT >= 0.14) décompose les poids pré-entraînés en composantes magnitude et direction. Il améliore la qualité de l'ajustement fin, en particulier pour les rangs plus petits.

from peft import LoraConfig

# LoRA standard
lora_config = LoraConfig(r=64, lora_alpha=16, use_dora=False, ...)

# DoRA — mêmes paramètres, meilleure qualité
lora_config = LoraConfig(r=64, lora_alpha=16, use_dora=True, ...)
# Remarque : DoRA ajoute ~5-10% de surcharge VRAM par rapport à LoRA standard
# Remarque : Pas compatible avec les modèles quantifiés (4 bits/8 bits) dans tous les cas

Exemples Qwen2.5 & DeepSeek-R1-Distill

Ajustement fin Qwen2.5

MODEL_NAME = "Qwen/Qwen2.5-7B-Instruct"
# Pour 14B : "Qwen/Qwen2.5-14B-Instruct" (nécessite 20GB+ de VRAM avec QLoRA)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,          # Requis pour Qwen2.5
    attn_implementation="flash_attention_2",
)
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)

# Qwen2.5 utilise le format ChatML — utilisez apply_chat_template
messages = [
    {"role": "system", "content": "Vous êtes un assistant serviable."},
    {"role": "user", "content": "Bonjour !"},
    {"role": "assistant", "content": "Salut ! Comment puis-je aider ?"},
]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)

Ajustement fin DeepSeek-R1-Distill

Les modèles DeepSeek-R1-Distill (Qwen-7B, Qwen-14B, Llama-8B, Llama-70B) sont axés sur le raisonnement. Ajustez finement pour adapter leur style de chaîne de pensée à votre domaine.

# Variantes DeepSeek-R1-Distill
MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"   # 7B sur base Qwen2.5
# MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B" # 8B sur base Llama3
# MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B" # 14B (nécessite A100)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
    attn_implementation="flash_attention_2",
)

# DeepSeek-R1 utilise des balises <think>...</think> pour le raisonnement
# Conservez cela dans les données d'entraînement pour préserver la capacité de chaîne de pensée
example_format = """<|im_start|>user
Solve: What is 15 * 23?<|im_end|>
<|im_start|>assistant
<think>
15 * 23 = 15 * 20 + 15 * 3 = 300 + 45 = 345
</think>
La réponse est 345.<|im_end|>"""

# Modules cibles LoRA pour DeepSeek-R1-Distill (base Qwen2.5)
lora_config = LoraConfig(
    r=32,
    lora_alpha=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    use_dora=True,
    task_type="CAUSAL_LM",
)

Utilisation d'Axolotl (plus simple)

Axolotl simplifie l'ajustement fin avec des configurations YAML :

pip install axolotl

# Créer la config
cat > config.yml << 'EOF'
base_model: mistralai/Mistral-7B-v0.1
model_type: MistralForCausalLM
tokenizer_type: LlamaTokenizer

load_in_4bit: true
adapter: qlora
lora_r: 32
lora_alpha: 16

datasets:
  - path: your_data.json
    type: alpaca

sequence_len: 4096
sample_packing: true

gradient_accumulation_steps: 4
micro_batch_size: 2
num_epochs: 3
learning_rate: 2e-4

output_dir: ./output
EOF

# Entraîner
accelerate launch -m axolotl.cli.train config.yml

Exemples de configuration Axolotl

Modèle de chat

base_model: mistralai/Mistral-7B-Instruct-v0.2
load_in_4bit: true
adapter: qlora

datasets:
  - path: data.json
    type: sharegpt

chat_template: mistral

Modèle de code

base_model: codellama/CodeLlama-7b-hf
load_in_4bit: true
adapter: qlora

datasets:
  - path: code_data.json
    type: alpaca

sequence_len: 8192  # Contexte plus long pour le code

Fusion des poids LoRA

Après l'entraînement, fusionnez LoRA dans le modèle de base :

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

# Charger le modèle de base
base_model = AutoModelForCausalLM.from_pretrained(
    "mistralai/Mistral-7B-v0.1",
    torch_dtype=torch.float16,
    device_map="auto",
)

# Charger LoRA
model = PeftModel.from_pretrained(base_model, "./output/final")

# Fusionner
merged_model = model.merge_and_unload()

# Enregistrer le modèle fusionné
merged_model.save_pretrained("./merged_model")
tokenizer.save_pretrained("./merged_model")

Convertir en GGUF

Pour utilisation avec llama.cpp/Ollama :

# Cloner llama.cpp
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Convertir
python convert.py ../merged_model --outtype f16 --outfile model-f16.gguf

# Quantifier
./quantize model-f16.gguf model-q4_k_m.gguf q4_k_m

Surveillance de l'entraînement

Weights & Biases

import wandb
wandb.init(project="llm-finetune", name="mistral-7b-lora")

TensorBoard

# Dans les arguments d'entraînement
report_to="tensorboard"
logging_dir="./logs"

# Voir
tensorboard --logdir ./logs --port 6006 --bind_all

Bonnes pratiques

Hyperparamètres

Paramètre	Modèle 7B	Modèle 13B	Modèle 70B
taille de lot	4	2	1
accum_grad	4	8	16
lr	2e-4	1e-4	5e-5
lora_r	64	32	16
époques	3	2-3	1-2

Taille du dataset

• Minimum : 1 000 exemples

• Bon : 10 000+ exemples

• Qualité > Quantité

Éviter le surapprentissage

training_args = TrainingArguments(
    ...
    weight_decay=0.01,
    warmup_ratio=0.03,
    save_total_limit=3,
    load_best_model_at_end=True,
    evaluation_strategy="steps",
    eval_steps=100,
)

Entraînement multi-GPU

# Avec accelerate
accelerate launch --multi_gpu --num_processes 4 train.py

# Avec DeepSpeed
accelerate launch --use_deepspeed --num_processes 4 train.py

Configuration DeepSpeed :

{
  "bf16": {"enabled": true},
  "zero_optimization": {
    "stage": 2,
    "offload_optimizer": {"device": "cpu"}
  }
}

Sauvegarde et exportation

# Sauvegarder l'adaptateur LoRA
trainer.save_model("./lora_adapter")

# Enregistrer le modèle fusionné
merged_model.save_pretrained("./full_model")

# Téléverser sur HuggingFace
huggingface-cli login
merged_model.push_to_hub("username/my-model")

Dépannage

Erreurs OOM

• Réduire la taille de batch

• Augmentez l'accumulation de gradients

• Utilisez gradient_checkpointing=True

• Réduire lora_r

La perte d'entraînement ne diminue pas

• Vérifiez le format des données

• Augmenter le taux d'apprentissage

• Vérifiez les problèmes de données

Perte NaN

• Réduire le taux d'apprentissage

• Utiliser fp32 au lieu de fp16

• Vérifiez la présence de données corrompues

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)

• Payer avec CLORE jetons

• Comparer les prix entre différents fournisseurs