# PowerInfer

**Гибридный вывод LLM на CPU/GPU с использованием локальности активаций** — запуск моделей с 70B параметров на одном потребительском GPU за счёт интеллектуального распределения вычислений между CPU и GPU.

> 🌟 **8 000+ звёзд на GitHub** | Разработано в SJTU IPADS | Лицензия MIT

***

## Что такое PowerInfer?

PowerInfer — это высокопроизводительный движок вывода для больших языковых моделей, который использует ключевое наблюдение: **LLM демонстрируют сильную локальность активаций** — небольшой поднабор нейронов ("горячие нейроны") регулярно активируется на большинстве шагов вывода, в то время как большинство остаётся неактивным.

PowerInfer использует это свойство для:

1. **Держать горячие нейроны на GPU** для быстрой обработки
2. **Выгружать холодные нейроны на CPU/ОЗУ** без существенной потери качества
3. **Динамически маршрутизировать** вычисления между CPU и GPU на основе паттернов активации

Результат: вы можете запускать модель 70B имея всего **16 ГБ VRAM** вместо необходимости иметь 140 ГБ+ полностью на GPU.

### Ключевые возможности

* **Поддержка потребительских GPU** — RTX 3090/4090 могут запускать модели 70B
* **Планирование с учётом нейронов** — предиктор определяет маршрутизацию на CPU или GPU для каждого вывода
* **Минимальное ухудшение качества** — сохраняет >95% качества с полной точностью
* **Совместимость с llama.cpp** — поддержка формата GGUF
* **Выгрузка на CPU с учётом NUMA** — оптимизировано для CPU с большим количеством ядер

### Зачем использовать PowerInfer на Clore.ai?

Clore.ai арендует GPU по значительно более низкой цене, чем облачные альтернативы. С PowerInfer:

* Запустите **Llama 2 70B** на **одном RTX 4090** (24 ГБ VRAM)
* Сократите расходы на аренду GPU по сравнению с мульти-GPU конфигурациями
* Обрабатывайте длинные контексты, используя RAM CPU как переполнение
* Запускайте модели, ранее требовавшие дорогих инстансов A100/H100

***

## Требования к оборудованию

| Размер модели | Мин. VRAM | Рекомендуемая ОЗУ | Производительность |
| ------------- | --------- | ----------------- | ------------------ |
| 7B            | 4 ГБ      | 16 ГБ             | Отлично            |
| 13B           | 6 ГБ      | 32 ГБ             | Очень хорошо       |
| 34B           | 12 ГБ     | 64 ГБ             | Хорошо             |
| 70B           | 16 ГБ     | 128 ГБ            | Умеренно           |

{% hint style="info" %}
**CPU имеет значение:** PowerInfer выгружает холодные нейроны на CPU. CPU с большим количеством ядер (AMD EPYC, Intel Xeon) и высокой пропускной способностью памяти значительно повышают пропускную способность для больших моделей.
{% endhint %}

***

## Быстрый старт на Clore.ai

### Шаг 1: Выберите сервер

На [clore.ai](https://clore.ai) маркетплейсе отфильтруйте по:

* **NVIDIA GPU** с VRAM 16 ГБ+ (RTX 3090, RTX 4090, A100)
* **Высокое количество ядер CPU** (идеально 16+ ядер)
* **64 ГБ+ ОЗУ** для моделей 70B, 32 ГБ для 13B моделей

### Шаг 2: Создайте пользовательский Docker-образ

PowerInfer требует кастомной Docker-настройки. Используйте этот `Dockerfile`:

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

# Установить зависимости
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
RUN mkdir /var/run/sshd && \
    echo 'root:powerinfer' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Клонировать и собрать 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)

# Установить Python-зависимости для решателя
RUN pip3 install torch numpy scipy

EXPOSE 22

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

Соберите и отправьте в Docker Hub или используйте встроенно с Clore.ai:

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

### Шаг 3: Разверните на Clore.ai

В заказе Clore.ai укажите:

* **Docker-образ:** `yourname/powerinfer:latest`
* **Порты:** `22` (SSH)
* **Окружение:** `NVIDIA_VISIBLE_DEVICES=all`

***

## Сборка PowerInfer из исходников

Если вы предпочитаете собирать внутри контейнера:

```bash
# SSH на ваш Clore.ai сервер
ssh root@<clore-node-ip> -p <ssh-port>

# Установить предварительные требования
apt-get update && apt-get install -y git cmake build-essential python3 python3-pip

# Клонировать PowerInfer
git clone https://github.com/SJTU-IPADS/PowerInfer.git
cd PowerInfer

# Сборка с поддержкой CUDA
mkdir build && cd build
cmake .. -DLLAMA_CUBLAS=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j$(nproc)

echo "Сборка завершена!"
ls -la bin/
```

### Проверить сборку

```bash
./build/bin/main --help
# Должно вывести справку по PowerInfer CLI
```

***

## Получение моделей

### Скачать модели GGUF

PowerInfer использует формат GGUF (такой же, как в llama.cpp):

```bash
# Установить HuggingFace CLI
pip3 install huggingface_hub

# Скачать Llama 2 7B Q4 (рекомендуется для тестирования)
huggingface-cli download TheBloke/Llama-2-7B-Chat-GGUF \
  llama-2-7b-chat.Q4_K_M.gguf \
  --local-dir ./models

# Скачать Llama 2 70B Q4 (требует 16 ГБ+ VRAM)  
huggingface-cli download TheBloke/Llama-2-70B-Chat-GGUF \
  llama-2-70b-chat.Q4_K_M.gguf \
  --local-dir ./models
```

### Генерация предиктора нейронов (требуется для PowerInfer)

PowerInfer требует предиктор активации нейронов для каждой модели. Это ключевое отличие от llama.cpp:

```bash
# Установить Python-зависимости для решателя
pip3 install torch numpy scipy

# Сгенерировать предиктор для вашей модели
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

# Это создаёт файлы предиктора в ./predictors/
ls ./predictors/llama-2-7b-chat/
```

{% hint style="warning" %}
**Время генерации предиктора:** Создание предиктора нейронов может занять 30–60 минут в зависимости от размера модели. Это однократная операция — предиктор повторно используется при последующих запусках.
{% endhint %}

***

## Запуск вывода

### Базовый вывод (без предиктора)

Для тестирования без генерации предиктора (стандартное разделение GPU/CPU):

```bash
./build/bin/main \
  -m ./models/llama-2-7b-chat.Q4_K_M.gguf \
  --gpu-layers 20 \
  -p "Расскажите мне о квантовых вычислениях" \
  -n 256
```

### Режим PowerInfer (с предиктором)

Полный режим PowerInfer с маршрутизацией, учитывающей нейроны:

```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 "В чём смысл жизни?" \
  -n 512 \
  --ctx-size 4096
```

### Интерактивный режим чата

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

### Серверный режим (API, совместимый с OpenAI)

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

***

## Оптимизация разделения слоёв на GPU

Параметр `--gpu-layers` определяет, сколько трансформер-слоёв держать на GPU. Настраивайте это в зависимости от вашей VRAM:

```bash
# Проверить доступную VRAM
nvidia-smi --query-gpu=memory.free,memory.total --format=csv

# Правило для Q4 моделей:
# 7B:  ~0.13 ГБ на слой  → карта 24 ГБ = ~184 слоёв (все)
# 13B: ~0.18 ГБ на слой  → карта 24 ГБ = ~133 слоя
# 70B: ~0.23 ГБ на слой  → карта 24 ГБ = ~104 слоя (из 80 всего)
```

**Руководство по распределению слоёв:**

| VRAM GPU | Модель 7B | Модель 13B | Модель 34B | Модель 70B |
| -------- | --------- | ---------- | ---------- | ---------- |
| 8 ГБ     | Все (32)  | 20 слоёв   | 10 слоёв   | 4 слоя     |
| 16 ГБ    | Все (32)  | Все (40)   | 25 слоёв   | 10 слоёв   |
| 24 ГБ    | Все (32)  | Все (40)   | Все (60)   | 20 слоёв   |
| 48 ГБ    | Все (32)  | Все (40)   | Все (60)   | Все (80)   |

***

## Тесты производительности

### Сравнение пропускной способности (Llama 2 70B, RTX 3090)

| Движок                 | Слои на GPU           | Токенов/с    |
| ---------------------- | --------------------- | ------------ |
| llama.cpp (только GPU) | 20/80                 | \~4 т/с      |
| llama.cpp (только CPU) | 0/80                  | \~1 т/с      |
| **PowerInfer**         | **20/80 + предиктор** | **\~12 т/с** |

{% hint style="success" %}
**3× ускорение** по сравнению со стандартным llama.cpp для вывода больших моделей на потребительских GPU типично при планировании с учётом нейронов в PowerInfer.
{% endhint %}

***

## Запуск как сервис

Создайте systemd-сервис для постоянного обслуживания API:

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

После запуска сервера используйте любой клиент, совместимый с OpenAI:

```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": "Объясните нейронные сети простыми словами"}
    ],
    max_tokens=256
)
print(response.choices[0].message.content)
```

***

## Устранение неполадок

### CUDA: недостаточно памяти

```bash
# Уменьшите слои на GPU
./build/bin/main -m model.gguf --gpu-layers 10  # Уменьшить с 20

# Проверьте, что использует VRAM
nvidia-smi

# Очистить память GPU
sudo fuser -v /dev/nvidia*  # Просмотреть процессы
```

### Медленный вывод на CPU

```bash
# Включить оптимизацию потоков CPU
./build/bin/main -m model.gguf --threads $(nproc) --gpu-layers 20

# Проверить топологию NUMA
numactl --hardware

# Привязать к NUMA-узлу, ближайшему к GPU
numactl --cpunodebind=0 --membind=0 ./build/bin/main -m model.gguf
```

### Сборка не удалась

```bash
# Убедитесь, что установлен CUDA toolkit
nvcc --version

# Проверьте версию CMake (нужна 3.14+)
cmake --version

# Очистить сборку
rm -rf build && mkdir build
cd build && cmake .. -DLLAMA_CUBLAS=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda
```

{% hint style="danger" %}
**Типичная проблема:** Если `cmake` не может найти CUDA, задайте `CUDA_HOME` переменную окружения: `export CUDA_HOME=/usr/local/cuda` перед запуском cmake.
{% endhint %}

***

## Рекомендации по GPU для Clore.ai

Гибридная архитектура PowerInfer изменяет экономику запуска больших моделей. Сервера Clore.ai с GPU большой памяти И быстрыми CPU идеальны.

| GPU       | VRAM  | Цена Clore.ai | Макс. модель (Q4)             | Пропускная способность (Llama 2 70B Q4) |
| --------- | ----- | ------------- | ----------------------------- | --------------------------------------- |
| RTX 3090  | 24 ГБ | \~$0.12/ч     | 70B (при 64 ГБ+ ОЗУ)          | \~8–12 ток/с                            |
| RTX 4090  | 24 ГБ | \~$0.70/ч     | 70B (быстрая выгрузка на CPU) | \~12–18 ток/с                           |
| A100 40GB | 40 ГБ | \~$1.20/ч     | 70B (минимальная выгрузка)    | \~35–45 ток/с                           |
| A100 80GB | 80 ГБ | \~$2.00/ч     | 70B в полной точности         | \~50–60 ток/с                           |

{% hint style="info" %}
**Оптимальная точка PowerInfer:** RTX 3090 за \~$0.12/ч, запускающий Llama 2 70B Q4, — прорыв для экономных пользователей. Вы получаете модель 70B за в 10–12× меньшую цену по сравнению с арендой A100. Пропускная способность ниже (\~10 ток/с), но для исследований или низконагруженного вывода это непревзойдённая ценность.
{% endhint %}

**CPU важен так же, как GPU:** PowerInfer выгружает "холодные" нейроны на CPU. Сервера Clore.ai с CPU AMD EPYC или Intel Xeon (много ядер, высокая пропускная способность памяти) значительно превосходят одно- сокетные потребительские CPU. Проверьте характеристики сервера перед арендой для работы с большими моделями.

**Узкое место — пропускная способность памяти:** Для моделей 70B пропускная способность RAM CPU является ограничивающим фактором при вычислениях холодных нейронов. Сервера с DDR5 ECC RAM или архитектурами, близкими к HBM, обеспечат лучшую пропускную способность.

***

## Ресурсы

* 🐙 **GitHub:** [github.com/SJTU-IPADS/PowerInfer](https://github.com/SJTU-IPADS/PowerInfer)
* 📄 **Научная статья:** [PowerInfer: быстрый сервис для больших языковых моделей с потребительским GPU](https://arxiv.org/abs/2312.12456)
* 🤗 **Модели GGUF:** [huggingface.co/TheBloke](https://huggingface.co/TheBloke)
* 🧩 **Лаб. SJTU IPADS:** [ipads.se.sjtu.edu.cn](https://ipads.se.sjtu.edu.cn)


---

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

```
GET https://docs.clore.ai/guides/guides_v2-ru/yazykovye-modeli/powerinfer.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.