PowerInfer

CPU/GPU-hybride LLM-Inferenz, die Aktivierungs-Lokalität ausnutzt — Führe 70B-Parameter-Modelle auf einer einzigen Consumer-GPU aus, indem die Berechnung intelligent zwischen CPU und GPU aufgeteilt wird.

🌟 8.000+ GitHub-Sterne | Entwickelt an der SJTU IPADS | MIT-Lizenz

---

Was ist PowerInfer?

PowerInfer ist eine leistungsstarke Inferenz-Engine für Large Language Models, die eine zentrale Erkenntnis ausnutzt: LLMs zeigen starke Aktivierungs-Lokalität — eine kleine Teilmenge von Neuronen ("heiße Neuronen") wird konsistent über die meisten Inferenzschritte hinweg aktiviert, während die Mehrheit inaktiv bleibt.

PowerInfer nutzt diese Eigenschaft um:

1. Halte heiße Neuronen auf der GPU für schnelle Berechnung

2. Verlagere kalte Neuronen auf CPU/RAM ohne nennenswerten Qualitätsverlust

3. Routiere dynamisch Berechnung zwischen CPU und GPU basierend auf Aktivierungsmustern

Das Ergebnis: Du kannst ein 70B-Modell mit nur 16GB VRAM statt mehr als 140GB ausschließlich auf GPU ausführen.

Wesentliche Fähigkeiten

• Unterstützung für Consumer-GPUs — RTX 3090/4090 können 70B-Modelle ausführen

• Neuronen-bewusste Planung — ein Prädiktor bestimmt pro Inferenz CPU- vs. GPU-Routing

• Minimale Qualitätsverschlechterung — erhält >95% der Full-Precision-Qualität

• Kompatibilität mit llama.cpp — Unterstützung des GGUF-Formats

• NUMA-bewusstes CPU-Offloading — optimiert für CPUs mit hoher Kernzahl

Warum PowerInfer auf Clore.ai verwenden?

Clore.ai vermietet GPUs zu deutlich niedrigeren Kosten als Cloud-Alternativen. Mit PowerInfer:

• Führe aus Llama 2 70B auf einer einzigen RTX 4090 (24GB VRAM)

• Reduziere GPU-Mietkosten im Vergleich zu Multi-GPU-Setups

• Verarbeite lange Kontextfenster mit CPU-RAM als Überlauf

• Führe Modelle aus, die früher teure A100/H100-Instanzen erforderten

---

Hardwareanforderungen

Modellgröße	Min. VRAM	Empfohlenes RAM	Leistung
7B	4GB	16GB	Ausgezeichnet
13B	6GB	32GB	Sehr gut
34B	12GB	64GB	Gut
70B	16GB	128GB	Mäßig

CPU ist wichtig: PowerInfer verlagert kalte Neuronen auf die CPU. Eine CPU mit hoher Kernzahl (AMD EPYC, Intel Xeon) und schneller Speicherbandbreite verbessert die Durchsatzrate für große Modelle erheblich.

---

Schnellstart auf Clore.ai

Schritt 1: Wähle deinen Server

Auf clore.ai Marktplatz, filtere nach:

• NVIDIA GPU mit 16GB+ VRAM (RTX 3090, RTX 4090, A100)

• Hohe CPU-Kernanzahl (idealerweise 16+ Kerne)

• 64GB+ RAM für 70B-Modelle, 32GB für 13B-Modelle

Schritt 2: Erstelle ein benutzerdefiniertes Docker-Image

PowerInfer benötigt ein benutzerdefiniertes Docker-Setup. Verwende dieses Dockerfile:

FROM nvidia/cuda:12.1.0-devel-ubuntu22.04

# Installiere Abhängigkeiten
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/*

# Konfiguriere SSH
RUN mkdir /var/run/sshd && \
    echo 'root:powerinfer' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Klone und baue 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)

# Installiere Python-Abhängigkeiten für den Solver
RUN pip3 install torch numpy scipy

EXPOSE 22

CMD ["/bin/bash", "-c", "service ssh start && tail -f /dev/null"]

Baue und pushe zu Docker Hub oder verwende inline mit Clore.ai:

docker build -t deinname/powerinfer:latest .
docker push deinname/powerinfer:latest

Schritt 3: Bereitstellung auf Clore.ai

Setze in deiner Clore.ai-Bestellung:

• Docker-Image: deinname/powerinfer:latest

• Ports: 22 (SSH)

• Umgebung: NVIDIA_VISIBLE_DEVICES=all

---

PowerInfer aus dem Quellcode bauen

Wenn du es vorziehst, im Container zu bauen:

# SSH in deinen Clore.ai-Server
ssh root@<clore-node-ip> -p <ssh-port>

# Installiere Voraussetzungen
apt-get update && apt-get install -y git cmake build-essential python3 python3-pip

# Klone PowerInfer
git clone https://github.com/SJTU-IPADS/PowerInfer.git
cd PowerInfer

# Baue mit CUDA-Unterstützung
mkdir build && cd build
cmake .. -DLLAMA_CUBLAS=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j$(nproc)

echo "Build abgeschlossen!"
ls -la bin/

Build überprüfen

./build/bin/main --help
# Sollte die PowerInfer-CLI-Hilfe ausgeben

---

Modelle beschaffen

GGUF-Modelle herunterladen

PowerInfer verwendet das GGUF-Format (wie llama.cpp):

# Installiere HuggingFace CLI
pip3 install huggingface_hub

# Lade Llama 2 7B Q4 herunter (empfohlen für Tests)
huggingface-cli download TheBloke/Llama-2-7B-Chat-GGUF \
  llama-2-7b-chat.Q4_K_M.gguf \
  --local-dir ./models

# Lade Llama 2 70B Q4 herunter (erfordert 16GB+ VRAM)  
huggingface-cli download TheBloke/Llama-2-70B-Chat-GGUF \
  llama-2-70b-chat.Q4_K_M.gguf \
  --local-dir ./models

Neuron-Prädiktor erzeugen (erforderlich für PowerInfer)

PowerInfer benötigt für jedes Modell einen Neuron-Aktivierungs-Prädiktor. Das ist der entscheidende Unterschied zu llama.cpp:

# Installiere Python-Dependencies für den Solver
pip3 install torch numpy scipy

# Erzeuge den Prädiktor für dein Modell
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

# Dies erstellt Prädiktor-Dateien in ./predictors/
ls ./predictors/llama-2-7b-chat/

Prädiktor-Generierungszeit: Das Erstellen eines Neuron-Prädiktors kann je nach Modellgröße 30–60 Minuten dauern. Dies ist eine einmalige Operation — der Prädiktor wird bei späteren Läufen wiederverwendet.

---

Inferenz ausführen

Einfache Inferenz (kein Prädiktor)

Zum Testen ohne Prädiktor-Generierung (standardmäßige GPU/CPU-Aufteilung):

./build/bin/main \
  -m ./models/llama-2-7b-chat.Q4_K_M.gguf \
  --gpu-layers 20 \
  -p "Erzähle mir etwas über Quantencomputing" \
  -n 256

PowerInfer-Modus (mit Prädiktor)

Voller PowerInfer-Modus mit neuronenbewusstem Routing:

./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 "Was ist der Sinn des Lebens?" \
  -n 512 \
  --ctx-size 4096

Interaktiver Chat-Modus

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

Server-Modus (OpenAI-kompatible API)

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

---

Optimierung der GPU-Layer-Aufteilung

Der --gpu-layers Parameter bestimmt, wie viele Transformer-Layers auf der GPU verbleiben sollen. Passe dies anhand deines VRAM an:

# Verfügbaren VRAM prüfen
nvidia-smi --query-gpu=memory.free,memory.total --format=csv

# Faustregel für Q4-Modelle:
# 7B:  ~0.13GB pro Layer  → 24GB-Karte = ~184 Layers (alle)
# 13B: ~0.18GB pro Layer  → 24GB-Karte = ~133 Layers
# 70B: ~0.23GB pro Layer  → 24GB-Karte = ~104 Layers (von 80 insgesamt)

Layer-Zuweisungsleitfaden:

GPU-VRAM	7B-Modell	13B-Modell	34B-Modell	70B-Modell
8GB	Alle (32)	20 Layers	10 Layers	4 Layers
16GB	Alle (32)	Alle (40)	25 Layers	10 Layers
24GB	Alle (32)	Alle (40)	Alle (60)	20 Layers
48GB	Alle (32)	Alle (40)	Alle (60)	Alle (80)

---

Leistungs-Benchmarks

Durchsatzvergleich (Llama 2 70B, RTX 3090)

Engine	GPU-Layers	Tokens/Sek
llama.cpp (nur GPU)	20/80	~4 t/s
llama.cpp (nur CPU)	0/80	~1 t/s
PowerInfer	20/80 + Prädiktor	~12 t/s

3x Beschleunigung gegenüber Standard-llama.cpp für große Modellinferenz auf Consumer-GPUs ist mit PowerInfers neuronenbewusster Planung typisch.

---

Als Dienst betreiben

Erstelle einen systemd-Service für persistentes API-Serving:

cat > /etc/systemd/system/powerinfer.service << 'EOF'
[Unit]
Description=PowerInfer LLM Server
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

---

API-Nutzung

Sobald der Server läuft, verwende jeden OpenAI-kompatiblen Client:

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": "Erkläre neuronale Netze einfach"}
    ],
    max_tokens=256
)
print(response.choices[0].message.content)

---

Fehlerbehebung

CUDA: zu wenig Speicher

# GPU-Layers reduzieren
./build/bin/main -m model.gguf --gpu-layers 10  # Reduziere von 20

# Prüfe, was VRAM verwendet
nvidia-smi

# GPU-Speicher freigeben
sudo fuser -v /dev/nvidia*  # Prozesse anzeigen

Langsame CPU-Inferenz

# CPU-Threading-Optimierung aktivieren
./build/bin/main -m model.gguf --threads $(nproc) --gpu-layers 20

# NUMA-Topologie prüfen
numactl --hardware

# An NUMA-Knoten nahe der GPU binden
numactl --cpunodebind=0 --membind=0 ./build/bin/main -m model.gguf

Build schlägt fehl

# Stelle sicher, dass das CUDA-Toolkit installiert ist
nvcc --version

# Prüfe CMake-Version (benötigt 3.14+)
cmake --version

# Sauberer Build
rm -rf build && mkdir build
cd build && cmake .. -DLLAMA_CUBLAS=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda

Häufiges Problem: Wenn cmake CUDA nicht finden kann, setze CUDA_HOME Umgebungsvariable: export CUDA_HOME=/usr/local/cuda bevor du cmake ausführst.

---

Clore.ai GPU-Empfehlungen

Das CPU/GPU-hybride Design von PowerInfer verändert die Wirtschaftlichkeit des Betriebs großer Modelle. Clore.ai-Server mit GPUs mit hohem VRAM UND schnellen CPUs sind ideal.

GPU	VRAM	Clore.ai-Preis	Max. Modell (Q4)	Durchsatz (Llama 2 70B Q4)
RTX 3090	24 GB	~$0.12/Stunde	70B (mit 64GB+ RAM)	~8–12 tok/s
RTX 4090	24 GB	~$0.70/Stunde	70B (schnelleres CPU-Offload)	~12–18 tok/s
A100 40GB	40 GB	~$1.20/Stunde	70B (minimales Offload)	~35–45 tok/s
A100 80GB	80 GB	~$2.00/Stunde	70B Full-Precision	~50–60 tok/s

PowerInfer Sweet Spot: Die RTX 3090 für ~$0.12/Stunde, die Llama 2 70B Q4 ausführt, ist ein Durchbruch für preisbewusste Nutzer. Du erhältst ein 70B-Modell für 10–12× weniger als die Miete einer A100. Der Durchsatz ist geringer (~10 tok/s), aber für Forschung oder geringen Traffic unschlagbar im Preis-Leistungs-Verhältnis.

CPU ist genauso wichtig wie GPU: PowerInfer verlagert "kalte" Neuronen auf die CPU. Clore.ai-Server mit AMD EPYC- oder Intel Xeon-CPUs (viele Kerne, hohe Speicherbandbreite) übertreffen Single-Socket-Consumer-CPUs deutlich. Prüfe die Server-Spezifikationen vor der Miete für große Modellaufgaben.

Speicherbandbreiten-Engpass: Bei 70B-Modellen ist die CPU-RAM-Bandbreite der begrenzende Faktor während der Berechnung kalter Neuronen. Server mit DDR5 ECC-RAM oder HBM-nahen Architekturen erzielen besseren Durchsatz.

---

Ressourcen

• 🐙 GitHub: github.com/SJTU-IPADS/PowerInfer

• 📄 Fachartikel: PowerInfer: Schnelles Serving großer Sprachmodelle mit einer Consumer-GPU

• 🤗 GGUF-Modelle: huggingface.co/TheBloke

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