PowerInfer

CPU/GPU-Hybrid-LLM-Inferenz, die Aktivierungslokalität ausnutzt — führt 70B-Parametermodelle auf einer einzelnen Consumer-GPU aus, indem die Berechnung intelligent zwischen CPU und GPU aufgeteilt wird.

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

---

Was ist PowerInfer?

PowerInfer ist eine Hochleistungs-Inferenz-Engine für große Sprachmodelle, die eine zentrale Erkenntnis ausnutzt: LLMs zeigen eine starke Aktivierungslokalität — eine kleine Teilmenge von Neuronen („heiße Neuronen“) wird über die meisten Inferenzschritte hinweg konsistent aktiviert, während der Großteil inaktiv bleibt.

PowerInfer nutzt diese Eigenschaft, um:

1. Heiße Neuronen auf der GPU halten für schnelle Berechnungen

2. Kal­te Neuronen auf CPU/RAM auslagern ohne nennenswerten Qualitätsverlust

3. Dynamisch umleiten Berechnungen zwischen CPU und GPU basierend auf Aktivierungsmustern

Das Ergebnis: Sie können ein 70B-Modell mit nur 16 GB VRAM ausführen, statt 140 GB+ komplett auf der GPU zu benötigen.

Hauptfunktionen

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

• Neuronenbewusstes Scheduling — der Prädiktor bestimmt pro Inferenz die CPU- vs.-GPU-Routing-Entscheidung

• Minimale Qualitätsverschlechterung — erhält >95 % der Qualität mit voller Präzision

• llama.cpp-Kompatibilität — Unterstützung für das GGUF-Format

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

Warum PowerInfer auf Clore.ai verwenden?

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

• Ausführen Llama 2 70B auf einer einzelnen RTX 4090 (24 GB VRAM)

• GPU-Mietkosten im Vergleich zu Multi-GPU-Setups drastisch senken

• Lange Kontextfenster mit CPU-RAM als Puffer verarbeiten

• Modelle ausführen, für die zuvor teure A100/H100-Instanzen nötig waren

---

Hardware-Anforderungen

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

Die CPU ist wichtig: PowerInfer lagert kalte Neuronen auf die CPU aus. Eine CPU mit vielen Kernen (AMD EPYC, Intel Xeon) und hoher Speicherbandbreite verbessert den Durchsatz für große Modelle erheblich.

---

Schnellstart auf Clore.ai

Schritt 1: Wählen Sie Ihren Server

Auf clore.ai Marktplatz filtern nach:

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

• Hohe CPU-Kernanzahl (16+ Kerne ideal)

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

Schritt 2: Benutzerdefiniertes Docker-Image erstellen

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

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

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

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

# PowerInfer klonen und bauen
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)

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

EXPOSE 22

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

Builden und auf Docker Hub pushen oder inline mit Clore.ai verwenden:

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

Schritt 3: Auf Clore.ai bereitstellen

Setzen Sie in Ihrer Clore.ai-Bestellung:

• Docker-Image: yourname/powerinfer:latest

• Ports: 22 (SSH)

• Umgebung: NVIDIA_VISIBLE_DEVICES=all

---

PowerInfer aus dem Quellcode bauen

Wenn Sie es vorziehen, innerhalb des Containers zu bauen:

# Per SSH auf Ihren Clore.ai-Server verbinden
ssh root@<clore-node-ip> -p <ssh-port>

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

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

# Mit CUDA-Unterstützung bauen
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 verifizieren

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

---

Modelle beziehen

GGUF-Modelle herunterladen

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

# HuggingFace CLI installieren
pip3 install huggingface_hub

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

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

Neuronen-Prädiktor generieren (erforderlich für PowerInfer)

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

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

# Prädiktor für Ihr Modell generieren
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

# Dadurch werden Prädiktordateien in ./predictors/ erstellt
ls ./predictors/llama-2-7b-chat/

Zeit für die Prädiktorgenerierung: Das Erstellen eines Neuronen-Prädiktors kann je nach Modellgröße 30–60 Minuten dauern. Dies ist eine einmalige Operation — der Prädiktor wird bei späteren Ausführungen wiederverwendet.

---

Inferenz ausführen

Einfache Inferenz (ohne Prädiktor)

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

./build/bin/main \
  -m ./models/llama-2-7b-chat.Q4_K_M.gguf \
  --gpu-layers 20 \
  -p "Erzähl 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

Servermodus (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-Layer auf der GPU bleiben. Passen Sie dies an Ihre VRAM-Größe an:

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

# Faustregel für Q4-Modelle:
# 7B: ~0,13 GB pro Layer → 24-GB-Karte = ~184 Layer (alle)
# 13B: ~0,18 GB pro Layer → 24-GB-Karte = ~133 Layer
# 70B: ~0,23 GB pro Layer → 24-GB-Karte = ~104 Layer (von insgesamt 80)

Leitfaden zur Layer-Zuweisung:

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

---

Leistungs-Benchmarks

Durchsatzvergleich (Llama 2 70B, RTX 3090)

Engine	GPU-Layer	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

3-fache Beschleunigung gegenüber standardmäßigem llama.cpp bei großer Modellinferenz auf Consumer-GPUs ist mit der neuronenbewussten Planung von PowerInfer typisch.

---

Als Dienst ausführen

Erstellen Sie einen systemd-Dienst für die dauerhafte API-Bereitstellung:

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, verwenden Sie einen beliebigen 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 Out of Memory

# GPU-Layer reduzieren
./build/bin/main -m model.gguf --gpu-layers 10  # Von 20 reduzieren

# Prüfen, was den 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 den NUMA-Knoten binden, der der GPU am nächsten liegt
numactl --cpunodebind=0 --membind=0 ./build/bin/main -m model.gguf

Build fehlgeschlagen

# Sicherstellen, dass das CUDA-Toolkit installiert ist
nvcc --version

# CMake-Version prüfen (3.14+ benötigt)
cmake --version

# Build bereinigen
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, setzen Sie die CUDA_HOME Umgebungsvariable: export CUDA_HOME=/usr/local/cuda bevor Sie cmake ausführen.

---

GPU-Empfehlungen für Clore.ai

Das CPU/GPU-Hybrid-Design von PowerInfer verändert die Wirtschaftlichkeit beim Betrieb 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	ca. 0,07–0,21 $/h	70B (mit 64 GB+ RAM)	~8–12 tok/s
RTX 4090	24 GB	ca. 0,14–0,42 $/h	70B (schnellere CPU-Auslagerung)	~12–18 tok/s
A100 40GB	40 GB	Bare Metal	70B (minimale Auslagerung)	~35–45 tok/s
A100 80GB	80 GB	Bare Metal	70B volle Präzision	~50–60 tok/s

PowerInfer-Sweet-Spot: Eine RTX 3090 für 0,07–0,21 $/Std. mit Llama 2 70B Q4 ist ein Durchbruch für preisbewusste Nutzer. Sie erhalten ein 70B-Modell für 10–12× weniger als die Mietkosten einer A100. Der Durchsatz ist geringer (~10 tok/s), aber für Forschung oder Inferenz mit geringem Traffic ist das ein unschlagbarer Wert.

CPU ist genauso wichtig wie GPU: PowerInfer lagert „kalte“ Neuronen auf die CPU aus. Clore.ai-Server mit AMD-EPYC- oder Intel-Xeon-CPUs (viele Kerne, hohe Speicherbandbreite) übertreffen herkömmliche Single-Socket-Consumer-CPUs deutlich. Prüfen Sie die Serverspezifikationen, bevor Sie für große Modellaufgaben mieten.

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

---

Ressourcen

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

• 📄 Forschungspapier: PowerInfer: Schneller Betrieb großer Sprachmodelle mit einer Consumer-GPU

• 🤗 GGUF-Modelle: huggingface.co/TheBloke

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