LitGPT

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

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

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

---

Qu'est-ce que LitGPT ?

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

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

• Préentraînement à partir de zéro — préentraînement complet avec Flash Attention, FSDP et checkpointing des gradients

• Ajustement fin efficace — ajustement fin 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

• Économe en mémoire — quantification 4 bits, checkpointing des gradients, checkpointing des 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 et plus
Stockage	100 Go	500 Go+
Système d'exploitation	Ubuntu 20.04+	Ubuntu 22.04
Python	3.10+	3.11
CUDA	12.8+	12.8+

Exigences en VRAM par tâche

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

---

Ports

Port	Service	Remarques
22	SSH	Accès au 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érez l'image officielle de LitGPT
docker pull pytorchlightning/litgpt:latest

# Exécutez 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écutez directement une commande spécifique
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. Accédez à Marketplace Clore.ai

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

3. Choisissez un PyTorch ou CUDA 12.8 image de base

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

5. Sélectionnez 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

# Installez via pip (recommandé)
pip install litgpt

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

# Ou installez depuis les sources pour obtenir 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] COMMAND [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   Ajuster finement un modèle
  generate   Générer du texte
  pretrain   Préentraîner un modèle
  serve      Servir un modèle pour l'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échargez Llama 3.2 3B (nécessite un jeton HF pour les modèles à accès restreint)
litgpt download \
  --repo_id meta-llama/Llama-3.2-3B-Instruct \
  --checkpoint_dir checkpoints/

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

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

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

Définir le jeton Hugging Face

# Pour les modèles à accès restreint (Llama, Gemma)
export HF_TOKEN=hf_your-token-here

# Ou authentifiez-vous via la CLI
pip install huggingface_hub
huggingface-cli login

---

Inférence (chat et génération)

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

# Génération unique
litgpt generate \
  --prompt "Expliquez l'informatique sur 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 "Écrivez 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

Ajustement fin LoRA (recommandé)

LoRA entraîne un petit ensemble de paramètres d'adaptateur (généralement 0,1 à 1 % des poids totaux) tandis que le modèle de base reste figé. Le LoRA de Llama 3 8B sur 10 000 exemples prend environ 2 heures sur un RTX 3090 avec r=16.

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

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

# Surveillez l'entraînement
# LitGPT produit des journaux avec la perte, le taux d'apprentissage et l'ETA

QLoRA (4 bits + LoRA)

Utilisez QLoRA pour ajuster finement de grands modèles avec une VRAM limitée. Llama 3 8B tient sur un seul 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

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

# Utilisez 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": "Expliquez l'apprentissage par renforcement",
        "max_new_tokens": 500,
        "temperature": 0.8,
        "top_p": 0.9,
    }
)
print(response.json()["output"])

---

Préentraînement à partir de zéro

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

# Préparez les données de préentraînement (tokenisées et découpées en blocs)
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 exportation des 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 la distribution
litgpt convert to_hf \
  --checkpoint_dir out/llama-lora-finetuned/final \
  --output_dir hf_model/

# Exporter au format GGUF (pour Ollama/LlamaCpp)
# Utilisez 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

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

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

---

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.

LitGPT couvre trois charges de travail distinctes — inférence, ajustement fin 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	Tient Llama 3 8B en bf16 ; génération à ~95 tok/s
Ajustement fin LoRA (modèles 7–8B)	RTX 3090	24 Go	Choix économique ; QLoRA maintient la VRAM sous 10 Go
Ajustement fin LoRA (7–8B), itération rapide	RTX 4090	24 Go	~35 % plus rapide qu'un 3090 ; réduit un travail de 2 h à ~1,4 h
Ajustement fin complet (7B) ou QLoRA (70B)	A100 40 Go	40 Go	40 Go suffisent pour du 7B en pleine précision ou du 70B en 4 bits
Ajustement fin complet (13B+) ou exécutions de préentraînement	A100 80 Go	80 Go	Débit le plus élevé ; ~2 800 tok/s d'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 l'ajustement fin complet sur des modèles 7B avec parallélisme tensoriel. Coût sur Clore.ai : 0,07–0,21 $/h pour deux 3090.

Pour le préentraînement ou l'ajustement fin >70B : Utilisez 4×A100 80 Go 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

Mémoire CUDA insuffisante

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

# Activer le gradient checkpointing
--train.gradient_checkpointing true

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

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

Échec du téléchargement / HuggingFace 401

# Définir le jeton HF
export HF_TOKEN=hf_your-token-here
huggingface-cli login

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

La perte d'entraînement 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('Toutes les lignes sont valides')
"

# Réduisez le taux d'apprentissage
--train.lr 1e-5  # La valeur par défaut est souvent trop élevée pour les petits ensembles de données

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

Le port 8000 du serveur n'est pas accessible

# Vérifiez que le serveur est à l'écoute
ss -tlnp | grep 8000

# Ouvrir le pare-feu
ufw allow 8000/tcp

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

L'entraînement multi-GPU se bloque

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

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

# Définir les 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

• Marketplace Clore.ai: https://clore.ai/marketplace