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

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.

---

Démarrage rapide sur Clore.ai

Étape 1 : Choisissez votre serveur

Sur 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:

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 :

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 :

# SSH vers votre serveur Clore.ai
ssh root@<clore-node-ip> -p <ssh-port>

# 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

./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) :

# 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 :

# 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/

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.

---

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) :

./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 :

./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

./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)

./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 :

# 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

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.

---

Exécution en tant que service

Créez un service systemd pour un service API persistant :

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 :

from openai import OpenAI

client = OpenAI(
    base_url="http://<clore-node-ip>:<port>/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

# 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

# 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

# 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

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.

---

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

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.

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

• 📄 Article de recherche : PowerInfer : Fast Large Language Model Serving with a Consumer-grade GPU

• 🤗 Modèles GGUF : huggingface.co/TheBloke

• 🧩 Laboratoire SJTU IPADS : ipads.se.sjtu.edu.cn