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 :

Conserver les neurones chauds sur le GPU pour un calcul rapide
Décharger les neurones froids vers le CPU/RAM sans perte de qualité significative
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

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

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.

Démarrage rapide sur Clore.ai

Étape 1 : choisissez votre serveur

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

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 :

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 :

# Se connecter en SSH à 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 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

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

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

# 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 de base (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 sensible aux 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 de discussion 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 du transformeur conserver 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 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

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.

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 cours d’exécution, 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 de neurones"}
    ],
    max_tokens=256
)
print(response.choices[0].message.content)

Dépannage

Mémoire CUDA insuffisante

# 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

# 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

# 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

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.

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

70B (déchargement minimal)

~35–45 jetons/s

A100 80 Go

80 Go

bare metal

70B en précision complète

~50–60 jetons/s

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.

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
📄 Article de recherche : PowerInfer : diffusion rapide de grands modèles de langage avec un GPU grand public
🤗 Modèles GGUF : huggingface.co/TheBloke
🧩 Laboratoire SJTU IPADS : ipads.se.sjtu.edu.cn

PrécédentMLC-LLM

SuivantLMDeploy

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?