> 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/modeles-de-langage/powerinfer.md). # PowerInfer **Inférence LLM hybride CPU/GPU exploitant la localité des activations** — exécutez des modèles de 70 milliards de paramètres sur un seul GPU grand public en répartissant intelligemment le calcul entre le CPU et le GPU. > 🌟 **8 000+ étoiles GitHub** | Développé à SJTU IPADS | Licence MIT *** ## Qu'est-ce que PowerInfer ? PowerInfer est un moteur d'inférence haute performance pour les grands modèles de langage qui exploite une idée clé : **Les LLM montrent une forte localité d'activation** — un petit sous-ensemble de neurones (« neurones chauds ») est systématiquement activé pendant la plupart des étapes d'inférence, tandis que la majorité reste inactive. PowerInfer utilise cette propriété pour : 1. **Garder les neurones chauds sur le GPU** pour un calcul rapide 2. **Décharger les neurones froids vers le CPU/RAM** sans perte de qualité significative 3. **Acheminer dynamiquement** le calcul entre le CPU et le GPU en fonction des schémas d'activation Le résultat : vous pouvez exécuter un modèle 70B avec seulement **16 Go de VRAM** au lieu de nécessiter 140 Go+ entièrement sur GPU. ### Capacités clés * **Prise en charge des GPU grand public** — RTX 3090/4090 peuvent exécuter des modèles 70B * **Planification consciente des neurones** — un prédicteur décide de l'acheminement CPU vs GPU pour chaque inférence * **Dégradation minimale de la qualité** — conserve >95 % de la qualité en pleine précision * **Compatibilité avec llama.cpp** — prise en charge du format GGUF * **Déchargement CPU conscient de la NUMA** — optimisé pour les CPU à grand nombre de cœurs ### Pourquoi utiliser PowerInfer sur Clore.ai ? Clore.ai loue des GPU à un coût bien inférieur aux alternatives cloud. Avec PowerInfer : * Exécuter **Llama 2 70B** sur un **unique RTX 4090** (24 Go de VRAM) * Réduisez les coûts de location GPU par rapport aux configurations multi-GPU * Traitez de longues fenêtres de contexte en utilisant la RAM CPU comme débordement * Exécutez des modèles nécessitant auparavant des instances A100/H100 coûteuses *** ## Exigences matérielles | Taille du modèle | VRAM min. | RAM recommandée | Performance | | ---------------- | --------- | --------------- | ----------- | | 7B | 4 Go | 16 Go | Excellente | | 13B | 6 Go | 32 Go | Très bonne | | 34B | 12 Go | 64 Go | Bonne | | 70B | 16 Go | 128 Go | Modérée | {% hint style="info" %} **Le CPU compte :** PowerInfer décharge les neurones froids sur le CPU. Un CPU à grand nombre de cœurs (AMD EPYC, Intel Xeon) avec une bande passante mémoire élevée améliore considérablement le débit pour les grands modèles. {% endhint %} *** ## Démarrage rapide sur Clore.ai ### Étape 1 : Choisissez votre serveur Sur [clore.ai](https://clore.ai) place de marché, filtrez pour : * **GPU NVIDIA** avec 16 Go+ de VRAM (RTX 3090, RTX 4090, A100) * **Nombre élevé de cœurs CPU** (16+ cœurs idéal) * **64 Go+ de RAM** pour les modèles 70B, 32 Go pour les modèles 13B ### Étape 2 : Créez une image Docker personnalisée PowerInfer nécessite une configuration Docker personnalisée. Utilisez ce `Dockerfile`: ```dockerfile FROM nvidia/cuda:12.1.0-devel-ubuntu22.04 # Installer les dépendances RUN apt-get update && apt-get install -y \ git \ cmake \ build-essential \ python3 \ python3-pip \ curl \ wget \ openssh-server \ && rm -rf /var/lib/apt/lists/* # Configurer SSH RUN mkdir /var/run/sshd && \ echo 'root:powerinfer' | chpasswd && \ sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config # Cloner et compiler PowerInfer RUN git clone https://github.com/SJTU-IPADS/PowerInfer.git /app/PowerInfer WORKDIR /app/PowerInfer RUN mkdir build && cd build && \ cmake .. -DLLAMA_CUBLAS=ON && \ cmake --build . --config Release -j$(nproc) # Installer les dépendances Python pour le solveur RUN pip3 install torch numpy scipy EXPOSE 22 CMD ["/bin/bash", "-c", "service ssh start && tail -f /dev/null"] ``` Construire et pousser vers Docker Hub ou utiliser en ligne avec Clore.ai : ```bash docker build -t votrenom/powerinfer:latest . docker push votrenom/powerinfer:latest ``` ### Étape 3 : Déployer sur Clore.ai Dans votre commande Clore.ai, définissez : * **Image Docker :** `votrenom/powerinfer:latest` * **Ports :** `22` (SSH) * **Environnement :** `NVIDIA_VISIBLE_DEVICES=all` *** ## Compiler PowerInfer depuis les sources Si vous préférez compiler à l'intérieur du conteneur : ```bash # SSH vers votre serveur Clore.ai ssh root@ -p # Installer les prérequis apt-get update && apt-get install -y git cmake build-essential python3 python3-pip # Cloner PowerInfer git clone https://github.com/SJTU-IPADS/PowerInfer.git cd PowerInfer # Compiler avec le support CUDA mkdir build && cd build cmake .. -DLLAMA_CUBLAS=ON -DCMAKE_BUILD_TYPE=Release cmake --build . --config Release -j$(nproc) echo "Compilation terminée !" ls -la bin/ ``` ### Vérifier la compilation ```bash ./build/bin/main --help # Devrait afficher l'aide CLI de PowerInfer ``` *** ## Obtention des modèles ### Télécharger des modèles GGUF PowerInfer utilise le format GGUF (comme llama.cpp) : ```bash # Installer le CLI HuggingFace pip3 install huggingface_hub # Télécharger Llama 2 7B Q4 (recommandé pour les tests) huggingface-cli download TheBloke/Llama-2-7B-Chat-GGUF \ llama-2-7b-chat.Q4_K_M.gguf \ --local-dir ./models # Télécharger Llama 2 70B Q4 (requiert 16 Go+ de VRAM) huggingface-cli download TheBloke/Llama-2-70B-Chat-GGUF \ llama-2-70b-chat.Q4_K_M.gguf \ --local-dir ./models ``` ### Générer le prédicteur de neurones (obligatoire pour PowerInfer) PowerInfer a besoin d'un prédicteur d'activation neuronale pour chaque modèle. C'est le différenciateur clé par rapport à llama.cpp : ```bash # Installer les dépendances Python du solveur pip3 install torch numpy scipy # Générer le prédicteur pour votre modèle python3 PowerInfer/solver/solve.py \ --model ./models/llama-2-7b-chat.Q4_K_M.gguf \ --output ./predictors/llama-2-7b-chat \ --target-gpu-layers 20 \ --gpu-memory-gb 16 # Cela crée des fichiers de prédicteur dans ./predictors/ ls ./predictors/llama-2-7b-chat/ ``` {% hint style="warning" %} **Temps de génération du prédicteur :** La création d'un prédicteur de neurones peut prendre 30–60 minutes selon la taille du modèle. C'est une opération unique — le prédicteur est réutilisé lors des exécutions suivantes. {% endhint %} *** ## Exécution de l'inférence ### Inférence basique (sans prédicteur) Pour tester sans génération de prédicteur (répartition GPU/CPU standard) : ```bash ./build/bin/main \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --gpu-layers 20 \ -p "Parlez-moi de l'informatique quantique" \ -n 256 ``` ### Mode PowerInfer (avec prédicteur) Mode PowerInfer complet avec routage conscient des neurones : ```bash ./build/bin/main \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --predictor-path ./predictors/llama-2-7b-chat \ --gpu-layers 20 \ --n-gpu-layers 20 \ -p "Quel est le sens de la vie ?" \ -n 512 \ --ctx-size 4096 ``` ### Mode chat interactif ```bash ./build/bin/main \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --predictor-path ./predictors/llama-2-7b-chat \ --gpu-layers 20 \ -i \ --ctx-size 4096 \ --temp 0.7 \ --top-p 0.9 \ --repeat-penalty 1.1 \ --color ``` ### Mode serveur (API compatible OpenAI) ```bash ./build/bin/server \ -m ./models/llama-2-7b-chat.Q4_K_M.gguf \ --predictor-path ./predictors/llama-2-7b-chat \ --gpu-layers 20 \ --host 0.0.0.0 \ --port 8080 \ --ctx-size 4096 ``` *** ## Optimisation de la répartition des couches GPU Le `--gpu-layers` paramètre détermine combien de couches de transformeur garder sur le GPU. Ajustez-le en fonction de votre VRAM : ```bash # Vérifier la VRAM disponible nvidia-smi --query-gpu=memory.free,memory.total --format=csv # Règle empirique pour les modèles Q4 : # 7B : ~0.13 Go par couche → carte 24 Go = ~184 couches (toutes) # 13B : ~0.18 Go par couche → carte 24 Go = ~133 couches # 70B : ~0.23 Go par couche → carte 24 Go = ~104 couches (sur 80 totales) ``` **Guide d'allocation des couches :** | VRAM GPU | Modèle 7B | Modèle 13B | Modèle 34B | Modèle 70B | | -------- | ----------- | ----------- | ----------- | ----------- | | 8 Go | Toutes (32) | 20 couches | 10 couches | 4 couches | | 16 Go | Toutes (32) | Toutes (40) | 25 couches | 10 couches | | 24 Go | Toutes (32) | Toutes (40) | Toutes (60) | 20 couches | | 48 Go | Toutes (32) | Toutes (40) | Toutes (60) | Toutes (80) | *** ## Benchmarks de performance ### Comparaison de débit (Llama 2 70B, RTX 3090) | Moteur | Couches GPU | Tokens/sec | | -------------------------- | ---------------------- | ------------ | | llama.cpp (GPU uniquement) | 20/80 | \~4 t/s | | llama.cpp (CPU uniquement) | 0/80 | \~1 t/s | | **PowerInfer** | **20/80 + prédicteur** | **\~12 t/s** | {% hint style="success" %} **3× accélération** par rapport à llama.cpp standard pour l'inférence de grands modèles sur GPU grand public est typique avec la planification consciente des neurones de PowerInfer. {% endhint %} *** ## Exécution en tant que service Créez un service systemd pour un service API persistant : ```bash cat > /etc/systemd/system/powerinfer.service << 'EOF' [Unit] Description=Serveur LLM PowerInfer After=network.target [Service] Type=simple WorkingDirectory=/app/PowerInfer ExecStart=/app/PowerInfer/build/bin/server \ -m /models/llama-2-13b-chat.Q4_K_M.gguf \ --predictor-path /predictors/llama-2-13b-chat \ --gpu-layers 30 \ --host 0.0.0.0 \ --port 8080 \ --ctx-size 4096 Restart=always RestartSec=5 [Install] WantedBy=multi-user.target EOF systemctl daemon-reload systemctl enable powerinfer systemctl start powerinfer systemctl status powerinfer ``` *** ## Utilisation de l'API Une fois le serveur en fonctionnement, utilisez n'importe quel client compatible OpenAI : ```python from openai import OpenAI client = OpenAI( base_url="http://:/v1", api_key="none" ) response = client.chat.completions.create( model="local-model", messages=[ {"role": "user", "content": "Expliquez simplement les réseaux neuronaux"} ], max_tokens=256 ) print(response.choices[0].message.content) ``` *** ## Dépannage ### CUDA Out of Memory ```bash # Réduire les couches GPU ./build/bin/main -m model.gguf --gpu-layers 10 # Réduire depuis 20 # Vérifier ce qui utilise la VRAM nvidia-smi # Libérer la mémoire GPU sudo fuser -v /dev/nvidia* # Voir les processus ``` ### Inférence CPU lente ```bash # Activer l'optimisation du threading CPU ./build/bin/main -m model.gguf --threads $(nproc) --gpu-layers 20 # Vérifier la topologie NUMA numactl --hardware # Épingler au nœud NUMA le plus proche du GPU numactl --cpunodebind=0 --membind=0 ./build/bin/main -m model.gguf ``` ### Échec de la compilation ```bash # Assurez-vous que le toolkit CUDA est installé nvcc --version # Vérifier la version de CMake (besoin de 3.14+) cmake --version # Nettoyer la compilation rm -rf build && mkdir build cd build && cmake .. -DLLAMA_CUBLAS=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda ``` {% hint style="danger" %} **Problème courant :** Si `cmake` ne trouve pas CUDA, définissez `CUDA_HOME` la variable d'environnement : `export CUDA_HOME=/usr/local/cuda` avant d'exécuter cmake. {% endhint %} *** ## Recommandations GPU Clore.ai La conception hybride CPU/GPU de PowerInfer change l'économie d'exécution des grands modèles. Les serveurs Clore.ai avec des GPU à grande VRAM ET des CPU rapides sont idéaux. | GPU | VRAM | Prix Clore.ai | Modèle max (Q4) | Débit (Llama 2 70B Q4) | | --------- | ----- | ------------- | ---------------------------------- | ---------------------- | | RTX 3090 | 24 Go | \~0,12 $/h | 70B (avec 64 Go+ RAM) | \~8–12 tok/s | | RTX 4090 | 24 Go | \~0,70 $/h | 70B (déchargement CPU plus rapide) | \~12–18 tok/s | | A100 40GB | 40 Go | \~1,20 $/h | 70B (déchargement minimal) | \~35–45 tok/s | | A100 80GB | 80 Go | \~2,00 $/h | 70B pleine précision | \~50–60 tok/s | {% hint style="info" %} **Le point fort de PowerInfer :** Le RTX 3090 à \~0,12 $/h exécutant Llama 2 70B Q4 est une percée pour les utilisateurs soucieux du budget. Vous obtenez un modèle 70B pour 10–12× moins cher qu'une location A100. Le débit est plus faible (\~10 tok/s), mais pour la recherche ou une inférence à faible trafic, c'est une valeur imbattable. {% endhint %} **Le CPU compte autant que le GPU :** PowerInfer décharge les neurones « froids » sur le CPU. Les serveurs Clore.ai avec des CPU AMD EPYC ou Intel Xeon (beaucoup de cœurs, large bande passante mémoire) surpasseront nettement les CPU grand public mono-socket. Vérifiez les spécifications du serveur avant de louer pour travailler sur de grands modèles. **Goulot d'étranglement de la bande passante mémoire :** Pour les modèles 70B, la bande passante de la RAM CPU est le facteur limitant lors du calcul des neurones froids. Les serveurs avec DDR5 ECC ou des architectures proches de la HBM verront un meilleur débit. *** ## Ressources * 🐙 **GitHub :** [github.com/SJTU-IPADS/PowerInfer](https://github.com/SJTU-IPADS/PowerInfer) * 📄 **Article de recherche :** [PowerInfer : Fast Large Language Model Serving with a Consumer-grade GPU](https://arxiv.org/abs/2312.12456) * 🤗 **Modèles GGUF :** [huggingface.co/TheBloke](https://huggingface.co/TheBloke) * 🧩 **Laboratoire SJTU IPADS :** [ipads.se.sjtu.edu.cn](https://ipads.se.sjtu.edu.cn) --- # 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/modeles-de-langage/powerinfer.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.