> 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 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. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace). {% endhint %} *** ## 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 ```bash # 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](https://clore.ai/marketplace) 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 ```bash ssh root@ -p ``` ### Étape 3 — Installer LitGPT ```bash # 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 ```bash 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 : ```bash # 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 ```bash # 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) ```bash # 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`. ```bash # 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 : ```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 ``` ### Ajustement fin 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 # 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) ```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": "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 : ```bash # 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 ```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 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 ```bash # 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 {% hint style="warning" %} **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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement. {% endhint %} 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 ```bash # 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 ```bash # 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 ```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('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 ```bash # 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 ```bash # 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**: ⭐ 12K+ * **Documentation**: * **PyTorch Lightning**: * **Modèles HuggingFace**: * **Discord**: * **Marketplace 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/entrainement/litgpt.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.