LitGPT

LitGPT est une bibliothèque haute performance pour le pré-entraînement, l'ajustement fin (finetuning) et le déploiement de plus de 20 grands modèles de langage construite sur PyTorch Lightning. Avec plus de 12K étoiles sur GitHub, c'est une boîte à outils de référence pour les ingénieurs qui ont besoin d'un code d'entraînement de LLM propre et modifiable sans la surcharge d'abstraction de HuggingFace Transformers.

Chaque modèle dans LitGPT fait ~1 000 lignes de PyTorch propre — pas de chaînes d'héritage à 10 niveaux, pas de magie. Vous pouvez lire l'implémentation de Llama 3 de bout en bout en un après-midi et la modifier en toute confiance.

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

---

Qu'est-ce que LitGPT ?

LitGPT fournit des implémentations prêtes pour la production de LLMs à la pointe avec une interface d'entraînement unifiée :

• Plus de 20 modèles pris en charge — Llama 3, Gemma 2, Mistral, Phi-3, Falcon, StableLM, et plus

• Préentraînement depuis zéro — préentraînement complet avec Flash Attention, FSDP et checkpointing de gradient

• Ajustement fin efficace — finetuning complet, LoRA, QLoRA et méthodes Adapter

• Servir en toute confiance — serveur d'inférence intégré avec quantification

• Prise en charge multi-GPU — DDP, FSDP, parallélisme tensoriel prêts à l'emploi

• Efficace en mémoire — quantification 4 bits, checkpointing de gradient, checkpointing d'activations

---

Exigences du serveur

Composant	Minimum	Recommandé
GPU	RTX 3090 (24 Go)	A100 80 Go / H100
VRAM	16 Go (LoRA 7B)	80 Go+ (70B complet)
RAM	32 Go	64 Go+
CPU	8 cœurs	16+ cœurs
Stockage	100 Go	500 Go+
OS	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11
CUDA	11.8+	12.1+

Exigences de VRAM par tâche

Tâche	Modèle	VRAM
Inférence (4 bits)	Llama-3 8B	~6 Go
LoRA finetune	Llama-3 8B	~16 Go
Finetuning complet	Llama-3 8B	~80 Go
LoRA finetune	Llama-3 70B	~48 Go (2×A100)
Finetuning complet	Llama-3 70B	~640 Go (8×A100)
QLoRA finetune	Llama-3 8B	~8 Go

---

Ports

Port	Service	Remarques
22	SSH	Accès terminal et transfert de fichiers
8000	Serveur d'inférence LitGPT	API REST pour le service de modèles

---

Démarrage rapide avec Docker

# Récupérer l'image officielle LitGPT
docker pull pytorchlightning/litgpt:latest

# Exécuter un conteneur interactif avec GPU
docker run -it --gpus all \
  -p 8000:8000 \
  -v $(pwd)/checkpoints:/checkpoints \
  -v $(pwd)/data:/data \
  pytorchlightning/litgpt:latest \
  bash

# Ou exécuter une commande spécifique directement
docker run --gpus all \
  -v $(pwd)/checkpoints:/checkpoints \
  pytorchlightning/litgpt:latest \
  litgpt download --repo_id meta-llama/Llama-3.2-3B-Instruct

---

Installation sur Clore.ai

Étape 1 — Louer un serveur

1. Aller à Place de marché Clore.ai

2. Filtrer par VRAM ≥ 24 Go (RTX 3090 ou mieux)

3. Choisir un PyTorch ou CUDA 12.1 image de base

4. Ouvrir les ports 22 et 8000 dans les paramètres de votre commande

5. Sélectionner stockage ≥ 200 Go pour les poids du modèle

Étape 2 — Se connecter via SSH

ssh root@<server-ip> -p <ssh-port>

Étape 3 — Installer LitGPT

# Installer via pip (recommandé)
pip install litgpt

# Avec tous les extras (quantification, serveur, etc.)
pip install 'litgpt[all]'

# Ou installer depuis les sources pour les dernières fonctionnalités
git clone https://github.com/Lightning-AI/litgpt.git
cd litgpt
pip install -e '.[all]'

Étape 4 — Vérifier l'installation

litgpt --help

Sortie attendue :

Utilisation : litgpt [OPTIONS] COMMANDE [ARGS]...
  
Commandes :
  chat       Discuter avec un modèle
  convert    Convertir les poids du modèle
  download   Télécharger les poids du modèle
  evaluate   Évaluer un modèle
  finetune   Affiner un modèle
  generate   Générer du texte
  pretrain   Préentraîner un modèle
  serve      Servir un modèle pour inférence

---

Téléchargement des modèles

LitGPT télécharge les modèles depuis Hugging Face :

# Lister les modèles disponibles
litgpt download --list

# Télécharger Llama 3.2 3B (requiert un token HF pour les modèles protégés)
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --checkpoint_dir checkpoints/

# Télécharger Mistral 7B (accès ouvert)
litgpt download \
  --repo_id mistralai/Mistral-7B-Instruct-v0.3

# Télécharger Gemma 2 2B
litgpt download \
  --repo_id google/gemma-2-2b-it \
  --access_token votre-token-hf

# Télécharger Phi-3 (petit mais puissant)
litgpt download \
  --repo_id microsoft/Phi-3-mini-4k-instruct

Définir le token HuggingFace

# Pour les modèles protégés (Llama, Gemma)
export HF_TOKEN=hf_votre-token-ici

# Ou s'authentifier via l'interface CLI
pip install huggingface_hub
huggingface-cli login

---

Inférence (Chat & Génération)

# Chat interactif
litgpt chat \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct

# Génération unique
litgpt generate \
  --prompt "Expliquer le calcul GPU en termes simples" \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --max_new_tokens 200

# Avec température et échantillonnage
litgpt generate \
  --prompt "Écrire une fonction Python pour trier une liste" \
  --checkpoint_dir checkpoints/mistralai/Mistral-7B-Instruct-v0.3 \
  --temperature 0.7 \
  --top_p 0.9 \
  --max_new_tokens 500

---

Ajustement fin (Finetuning)

Ajustement LoRA (recommandé)

LoRA entraîne un petit ensemble de paramètres d'adapteur (typiquement 0,1–1% des poids totaux) tandis que le modèle de base reste gelé. LoRA sur Llama 3 8B avec 10K exemples prend ~2 heures sur une RTX 3090 avec r=16.

# Préparez votre jeu de données
# Format : JSON lines avec {"instruction": "...", "input": "...", "output": "..."}
cat > data/train.json << 'EOF'
{"instruction": "Qu'est-ce que le cloud computing GPU ?", "input": "", "output": "Le cloud computing GPU fournit un accès à la demande au matériel GPU via Internet, permettant l'entraînement et l'inférence d'IA sans posséder le matériel physique."}
{"instruction": "Comment louer un GPU sur Clore.ai ?", "input": "", "output": "Visitez clore.ai/marketplace, filtrez par spécifications GPU, sélectionnez un serveur, configurez les ports et cliquez sur louer. L'accès SSH est fourni immédiatement."}
EOF

# Affiner avec LoRA
litgpt finetune lora \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --data JSON \
  --data.json_path data/train.json \
  --train.epochs 3 \
  --train.micro_batch_size 4 \
  --lora_r 8 \
  --lora_alpha 16 \
  --out_dir out/llama-lora-finetuned

# Surveiller l'entraînement
# LitGPT affiche des logs avec perte, taux d'apprentissage et ETA

QLoRA (4 bits + LoRA)

Utilisez QLoRA pour affiner de grands modèles avec une VRAM limitée. Llama 3 8B tient sur une seule RTX 3090 de 24 Go :

litgpt finetune lora \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-8B-Instruct \
  --quantize bnb.nf4 \
  --train.epochs 3 \
  --train.micro_batch_size 2 \
  --lora_r 16 \
  --lora_alpha 32 \
  --out_dir out/llama-qlora

Finetuning complet

litgpt finetune full \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --data JSON \
  --data.json_path data/train.json \
  --train.epochs 2 \
  --train.micro_batch_size 2 \
  --train.accumulate_gradients 8 \
  --out_dir out/llama-full-finetuned

Entraînement Multi-GPU

# Utiliser FSDP sur plusieurs GPU
litgpt finetune full \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-8B-Instruct \
  --devices 4 \
  --strategy fsdp \
  --train.epochs 3 \
  --out_dir out/llama-multigpu

---

Servir des modèles (API REST)

# Démarrer le serveur d'inférence
litgpt serve \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --host 0.0.0.0 \
  --port 8000

# Tester l'API
curl -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Quelle est la capitale de la France ?",
    "max_new_tokens": 100,
    "temperature": 0.7
  }'

Client Python

import requests

response = requests.post(
    "http://<server-ip>:8000/predict",
    json={
        "prompt": "Expliquer l'apprentissage par renforcement",
        "max_new_tokens": 500,
        "temperature": 0.8,
        "top_p": 0.9,
    }
)
print(response.json()["output"])

---

Préentraînement depuis zéro

Pour entraîner un LLM personnalisé depuis zéro sur vos propres données :

# Préparez les données de préentraînement (tokenisées et découpées)
python scripts/prepare_redpajama.py \
  --source_path /data/raw_text \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --destination_path /data/tokenized

# Démarrer le préentraînement
litgpt pretrain \
  --model_name Llama-3.2 \
  --data /data/tokenized \
  --train.micro_batch_size 4 \
  --train.max_tokens 10_000_000_000 \
  --devices 8 \
  --strategy fsdp \
  --out_dir out/my-pretrained-llm

---

Conversion et export de modèles

# Fusionner les poids LoRA dans le modèle de base
litgpt merge_lora \
  --checkpoint_dir out/llama-lora-finetuned

# Convertir au format HuggingFace pour distribution
litgpt convert to_hf \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --output_dir hf_model/

# Exporter au format GGUF (pour Ollama/LlamaCpp)
# Utiliser le script de conversion llama.cpp après l'export HF
python llama.cpp/convert.py hf_model/ --outfile model.gguf

---

Évaluation des modèles

# Lancer le benchmark MMLU
litgpt evaluate \
  --checkpoint_dir checkpoints/meta-llama/Llama-3.2-3B-Instruct \
  --tasks mmlu \
  --num_fewshot 5

# Lancer plusieurs benchmarks
litgpt evaluate \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --tasks "mmlu,hellaswag,truthfulqa_mc"

---

Recommandations GPU Clore.ai

LitGPT couvre trois charges de travail distinctes — inférence, ajustement LoRA et préentraînement complet — chacune avec des exigences GPU différentes.

Charge de travail	GPU	VRAM	Remarques
Inférence / chat (modèles 7–8B)	RTX 3090	24 Go	Convient à Llama 3 8B en bf16 ; ~95 tok/s en génération
LoRA finetune (modèles 7–8B)	RTX 3090	24 Go	Choix économique ; QLoRA maintient la VRAM sous 10 Go
LoRA finetune (7–8B), itération rapide	RTX 4090	24 Go	~35% plus rapide que 3090 ; réduit un job de 2h à ~1,4h
Finetuning complet (7B) ou QLoRA (70B)	A100 40 Go	40 Go	40 Go permet le 7B en précision complète ou le 70B en 4 bits
Finetuning complet (13B+) ou exécutions de préentraînement	A100 80 Go	80 Go	Débit le plus élevé ; ~2 800 tok/sec en entraînement sur 8B

Recommandé pour la plupart des utilisateurs : Paire de RTX 3090 (2×24 Go = 48 Go effectifs avec FSDP). Gère QLoRA sur des modèles 70B, ou finetuning complet sur des modèles 7B avec parallélisme tensoriel. Coût sur Clore.ai : ~0,25 $/h pour deux 3090.

Pour le préentraînement ou l'affinage >70B : Utilisez 4×A100 80Go avec FSDP. L'intégration FSDP de LitGPT gère le sharding de manière transparente — il suffit de passer --devices 4 --strategy fsdp.

---

Dépannage

CUDA : mémoire insuffisante

# Réduire la taille de batch
--train.micro_batch_size 1

# Activer le gradient checkpointing
--train.gradient_checkpointing true

# Utiliser QLoRA au lieu de LoRA
--quantize bnb.nf4

# Vérifier la mémoire GPU
nvidia-smi

Échec du téléchargement / HuggingFace 401

# Définir le token HF
export HF_TOKEN=hf_votre-token-ici
huggingface-cli login

# Ou passer directement
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --access_token hf_votre-token

La perte d'entraînement n'augmente pas (ne diminue pas)

# Vérifiez le format de vos données — doit être du JSON Lines valide
python -c "
import json
with open('data/train.json') as f:
    for i, line in enumerate(f):
        json.loads(line)
        if i < 3: print(f'Line {i}: OK')
print('All lines valid')
"

# Réduire le taux d'apprentissage
--train.lr 1e-5  # Par défaut c'est souvent trop élevé pour de petits jeux de données

# Vérifier la taille des données — LoRA nécessite au moins 100-1000 exemples
wc -l data/train.json

Le port serveur 8000 n'est pas accessible

# Vérifier que le serveur écoute
ss -tlnp | grep 8000

# Ouvrir le pare-feu
ufw allow 8000/tcp

# Redémarrer le serveur avec l'hôte explicite
litgpt serve \
  --checkpoint_dir checkpoints/... \
  --host 0.0.0.0 \
  --port 8000

L'entraînement Multi-GPU se bloque

# Vérifier la connectivité NCCL
python -c "import torch; print(torch.cuda.device_count())"

# Essayer DDP au lieu de FSDP pour les modèles plus petits
--strategy ddp

# Définir des variables d'environnement NCCL
export NCCL_DEBUG=INFO
export NCCL_IB_DISABLE=1  # Si InfiniBand n'est pas disponible

---

Liens utiles

• GitHub: https://github.com/Lightning-AI/litgpt ⭐ 12K+

• Documentation: https://lightning.ai/docs/litgpt

• PyTorch Lightning: https://lightning.ai

• Modèles HuggingFace: https://huggingface.co/models

• Discord: https://discord.gg/lightning-ai

• Place de marché Clore.ai: https://clore.ai/marketplace