> 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é d’activation** — 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. > 🌟 **Plus de 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 présentent une forte localité d’activation** — un petit sous-ensemble de neurones (« neurones chauds ») est activé de façon constante à travers la plupart des étapes d’inférence, tandis que la majorité reste inactive. PowerInfer utilise cette propriété pour : 1. **Conserver 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 de 70 milliards avec seulement **16 Go de VRAM** au lieu d’exiger plus de 140 Go entièrement sur le GPU. ### Fonctionnalités clés * **Prise en charge des GPU grand public** — les RTX 3090/4090 peuvent exécuter des modèles de 70 milliards * **Planification sensible aux neurones** — le prédicteur détermine le routage CPU vs GPU pour chaque inférence * **Dégradation minimale de la qualité** — conserve plus de 95 % de la qualité en précision complète * **Compatibilité avec llama.cpp** — prise en charge du format GGUF * **Déchargement CPU sensible au 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 à celui des alternatives cloud. Avec PowerInfer : * Exécutez **Llama 2 70B** sur un **seul RTX 4090** (24 Go de VRAM) * Réduisez drastiquement les coûts de location GPU par rapport aux configurations multi-GPU * Traitez de longues fenêtres de contexte avec la RAM CPU comme dépassement * Exécutez des modèles nécessitant auparavant de coûteuses instances A100/H100 *** ## Configuration matérielle requise | Taille du modèle | VRAM minimale | RAM recommandée | Performances | | ---------------- | ------------- | --------------- | ------------ | | 7B | 4 Go | 16 Go | Excellente | | 13B | 6 Go | 32 Go | Très bonne | | 34B | 12 Go | 64 Go | Bon | | 70B | 16 Go | 128 Go | Modérée | {% hint style="info" %} **Le CPU compte :** PowerInfer décharge les neurones froids vers le CPU. Un CPU à grand nombre de cœurs (AMD EPYC, Intel Xeon) avec une bande passante mémoire rapide 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 selon : * **GPU NVIDIA** avec 16 Go+ de VRAM (RTX 3090, RTX 4090, A100) * **Nombre élevé de cœurs CPU** (16 cœurs ou plus idéalement) * **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.8.1-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"] ``` Construisez et envoyez vers Docker Hub ou utilisez en ligne avec Clore.ai : ```bash docker build -t yourname/powerinfer:latest . docker push yourname/powerinfer:latest ``` ### Étape 3 : déployez sur Clore.ai Dans votre commande Clore.ai, définissez : * **Image Docker :** `yourname/powerinfer:latest` * **Ports :** `22` (SSH) * **Environnement :** `NVIDIA_VISIBLE_DEVICES=all` *** ## Compiler PowerInfer à partir des sources Si vous préférez compiler à l’intérieur du conteneur : ```bash # Se connecter en SSH à 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 la prise en charge de 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 # Doit afficher l’aide CLI de PowerInfer ``` *** ## Obtenir les modèles ### Télécharger les modèles GGUF PowerInfer utilise le format GGUF (comme llama.cpp) : ```bash # Installer l’interface 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 (nécessite 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 (requis pour PowerInfer) PowerInfer a besoin d’un prédicteur d’activation des neurones pour chaque modèle. C’est la principale différence avec 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 de base (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 sensible aux 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 de discussion 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 du transformeur conserver 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 de 24 Go = ~184 couches (toutes) # 13B : ~0,18 Go par couche → carte de 24 Go = ~133 couches # 70B : ~0,23 Go par couche → carte de 24 Go = ~104 couches (sur 80 au total) ``` **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 | | 24GB | Toutes (32) | Toutes (40) | Toutes (60) | 20 couches | | 48GB | Toutes (32) | Toutes (40) | Toutes (60) | Toutes (80) | *** ## Références de performance ### Comparaison du débit (Llama 2 70B, RTX 3090) | Moteur | Couches GPU | Jetons/s | | -------------------------- | ---------------------- | ----------------- | | llama.cpp (GPU uniquement) | 20/80 | \~4 jetons/s | | llama.cpp (CPU uniquement) | 0/80 | \~1 jeton/s | | **PowerInfer** | **20/80 + prédicteur** | **\~12 jetons/s** | {% hint style="success" %} **Accélération x3** par rapport à llama.cpp standard pour l’inférence de grands modèles sur GPU grand public est typique grâce à la planification sensible aux 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 cours d’exécution, 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 de neurones"} ], max_tokens=256 ) print(response.choices[0].message.content) ``` *** ## Dépannage ### Mémoire CUDA insuffisante ```bash # Réduire les couches GPU ./build/bin/main -m model.gguf --gpu-layers 10 # Réduire de 20 # Vérifier ce qui utilise la VRAM nvidia-smi # Vider la mémoire du GPU sudo fuser -v /dev/nvidia* # Voir les processus ``` ### Inférence CPU lente ```bash # Activer l’optimisation du multithreading 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 # Vérifier que le toolkit CUDA est installé nvcc --version # Vérifier la version de CMake (il faut 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 la variable d’environnement `CUDA_HOME` : `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 dotés de GPU à forte VRAM ET de 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,07–0,21 $/h | 70B (avec 64 Go+ de RAM) | \~8–12 jetons/s | | RTX 4090 | 24 Go | 0,14–0,42 $/h | 70B (déchargement CPU plus rapide) | \~12–18 jetons/s | | A100 40 Go | 40 Go | [bare metal](https://clore.ai/bare-metal) | 70B (déchargement minimal) | \~35–45 jetons/s | | A100 80 Go | 80 Go | [bare metal](https://clore.ai/bare-metal) | 70B en précision complète | \~50–60 jetons/s | {% hint style="info" %} **Le point idéal de PowerInfer :** Une RTX 3090 à 0,07–0,21 $/h exécutant Llama 2 70B Q4 est une avancée majeure pour les utilisateurs soucieux de leur budget. Vous obtenez un modèle 70B pour 10 à 12× moins cher qu’une location A100. Le débit est plus faible (\~10 jetons/s), mais pour la recherche ou l’inférence à faible trafic, le rapport qualité-prix est imbattable. {% endhint %} **Le CPU compte autant que le GPU :** PowerInfer décharge les neurones « froids » vers le CPU. Les serveurs Clore.ai dotés de CPU AMD EPYC ou Intel Xeon (beaucoup de cœurs, large bande passante mémoire) dépasseront nettement les CPU grand public à socket unique. Vérifiez les spécifications du serveur avant de louer pour des travaux sur de grands modèles. **Goulet d’étranglement de la bande passante mémoire :** Pour les modèles 70B, la bande passante de la RAM CPU est le facteur limitant pendant le calcul des neurones froids. Les serveurs avec RAM DDR5 ECC ou des architectures proches de la HBM offriront un meilleur débit. *** ## Ressources * 🐙 **GitHub :** [github.com/SJTU-IPADS/PowerInfer](https://github.com/SJTU-IPADS/PowerInfer) * 📄 **Article de recherche :** [PowerInfer : diffusion rapide de grands modèles de langage avec un GPU grand public](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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/powerinfer.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.