> 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-de/sprachmodelle/powerinfer.md).

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

{% hint style="info" %}
**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.
{% endhint %}

***

## Schnellstart auf Clore.ai

### Schritt 1: Wählen Sie Ihren Server

Auf [clore.ai](https://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`:

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

```bash
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:

```bash
# 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

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

***

## Modelle beziehen

### GGUF-Modelle herunterladen

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

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

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

{% hint style="warning" %}
**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.
{% endhint %}

***

## Inferenz ausführen

### Einfache Inferenz (ohne Prädiktor)

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

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

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

### Interaktiver Chat-Modus

```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
```

### Servermodus (OpenAI-kompatible API)

```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
```

***

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

```bash
# 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** |

{% hint style="success" %}
**3-fache Beschleunigung** gegenüber standardmäßigem llama.cpp bei großer Modellinferenz auf Consumer-GPUs ist mit der neuronenbewussten Planung von PowerInfer typisch.
{% endhint %}

***

## Als Dienst ausführen

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

```bash
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:

```python
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

```bash
# 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

```bash
# 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

```bash
# 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
```

{% hint style="danger" %}
**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.
{% endhint %}

***

## 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](https://clore.ai/bare-metal) | 70B (minimale Auslagerung)       | \~35–45 tok/s              |
| A100 80GB | 80 GB | [Bare Metal](https://clore.ai/bare-metal) | 70B volle Präzision              | \~50–60 tok/s              |

{% hint style="info" %}
**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.
{% endhint %}

**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](https://github.com/SJTU-IPADS/PowerInfer)
* 📄 **Forschungspapier:** [PowerInfer: Schneller Betrieb großer Sprachmodelle mit einer Consumer-GPU](https://arxiv.org/abs/2312.12456)
* 🤗 **GGUF-Modelle:** [huggingface.co/TheBloke](https://huggingface.co/TheBloke)
* 🧩 **SJTU IPADS Lab:** [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-de/sprachmodelle/powerinfer.md?ask=<question>&goal=<endgoal>
```

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