> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/entrainement/litgpt.md). # 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. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} *** ## 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 ```bash # 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](https://clore.ai/marketplace) 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 ```bash ssh root@ -p ``` ### Étape 3 — Installer LitGPT ```bash # 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 ```bash 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 : ```bash # 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 ```bash # 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) ```bash # 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`. ```bash # 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 : ```bash 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 ```bash 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 ```bash # 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) ```bash # 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 ```python import requests response = requests.post( "http://: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 : ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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 ```bash # 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) ```bash # 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 ```bash # 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 ```bash # 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**: ⭐ 12K+ * **Documentation**: * **PyTorch Lightning**: * **Modèles HuggingFace**: * **Discord**: * **Place de marché Clore.ai**: --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/entrainement/litgpt.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.