# PowerInfer

**Inferencia híbrida CPU/GPU para LLM explotando la localidad de activaciones** — ejecutar modelos de 70B parámetros en una sola GPU de consumo dividiendo inteligentemente el cómputo entre CPU y GPU.

> 🌟 **8.000+ estrellas en GitHub** | Desarrollado en SJTU IPADS | Licencia MIT

***

## ¿Qué es PowerInfer?

PowerInfer es un motor de inferencia de alto rendimiento para Modelos de Lenguaje Extensos que explota una idea clave: **Los LLM muestran una fuerte localidad de activación** — un pequeño subconjunto de neuronas ("neuronas calientes") se activan consistentemente en la mayoría de los pasos de inferencia, mientras que la mayoría permanecen inactivas.

PowerInfer usa esta propiedad para:

1. **Mantener las neuronas calientes en la GPU** para cómputo rápido
2. **Descargar las neuronas frías a CPU/RAM** sin una pérdida significativa de calidad
3. **Enrutar dinámicamente** el cómputo entre CPU y GPU basado en patrones de activación

El resultado: puedes ejecutar un modelo 70B con solo **16GB de VRAM** en lugar de requerir 140GB+ todo en GPU.

### Capacidades clave

* **Soporte para GPU de consumo** — RTX 3090/4090 pueden ejecutar modelos 70B
* **Planificación consciente de neuronas** — un predictor determina el enrutamiento CPU vs GPU por inferencia
* **Degradación mínima de calidad** — mantiene >95% de la calidad en precisión completa
* **Compatibilidad con llama.cpp** — soporte de formato GGUF
* **Descarga a CPU consciente de NUMA** — optimizado para CPUs con alto conteo de núcleos

### ¿Por qué usar PowerInfer en Clore.ai?

Clore.ai alquila GPUs a un costo mucho menor que las alternativas en la nube. Con PowerInfer:

* Ejecuta **Llama 2 70B** en una **sola RTX 4090** (24GB de VRAM)
* Reduce los costos de alquiler de GPU frente a configuraciones multi-GPU
* Procesa ventanas de contexto largas usando la RAM de la CPU como desbordamiento
* Ejecuta modelos que antes requerían instancias caras A100/H100

***

## Requisitos de hardware

| Tamaño del modelo | VRAM mínima | RAM recomendada | Rendimiento |
| ----------------- | ----------- | --------------- | ----------- |
| 7B                | 4GB         | 16GB            | Excelente   |
| 13B               | 6GB         | 32GB            | Muy bueno   |
| 34B               | 12GB        | 64GB            | Bueno       |
| 70B               | 16GB        | 128GB           | Moderado    |

{% hint style="info" %}
**La CPU importa:** PowerInfer descarga neuronas frías a la CPU. Una CPU con alto número de núcleos (AMD EPYC, Intel Xeon) con ancho de banda de memoria rápido mejora significativamente el rendimiento para modelos grandes.
{% endhint %}

***

## Inicio rápido en Clore.ai

### Paso 1: Elige tu servidor

En [clore.ai](https://clore.ai) en el marketplace, filtra por:

* **GPU NVIDIA** con 16GB+ de VRAM (RTX 3090, RTX 4090, A100)
* **Alto número de núcleos de CPU** (16+ núcleos ideal)
* **64GB+ de RAM** para modelos 70B, 32GB para modelos 13B

### Paso 2: Crea una imagen Docker personalizada

PowerInfer requiere una configuración Docker personalizada. Usa este `Dockerfile`:

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

# Instalar dependencias
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/*

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

# Clonar y compilar 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)

# Instalar dependencias de Python para el solver
RUN pip3 install torch numpy scipy

EXPOSE 22

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

Construir y subir a Docker Hub o usar inline con Clore.ai:

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

### Paso 3: Desplegar en Clore.ai

En tu pedido de Clore.ai, configura:

* **Imagen Docker:** `tuusuario/powerinfer:latest`
* **Puertos:** `22` (SSH)
* **Entorno:** `NVIDIA_VISIBLE_DEVICES=all`

***

## Construir PowerInfer desde la fuente

Si prefieres compilar dentro del contenedor:

```bash
# SSH en tu servidor Clore.ai
ssh root@<clore-node-ip> -p <ssh-port>

# Instalar prerequisitos
apt-get update && apt-get install -y git cmake build-essential python3 python3-pip

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

# Compilar con soporte CUDA
mkdir build && cd build
cmake .. -DLLAMA_CUBLAS=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j$(nproc)

echo "¡Construcción completa!"
ls -la bin/
```

### Verificar compilación

```bash
./build/bin/main --help
# Debería mostrar la ayuda CLI de PowerInfer
```

***

## Obtener modelos

### Descargar modelos GGUF

PowerInfer usa el formato GGUF (igual que llama.cpp):

```bash
# Instalar HuggingFace CLI
pip3 install huggingface_hub

# Descargar Llama 2 7B Q4 (recomendado para pruebas)
huggingface-cli download TheBloke/Llama-2-7B-Chat-GGUF \
  llama-2-7b-chat.Q4_K_M.gguf \
  --local-dir ./models

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

### Generar predictor de neuronas (Requerido para PowerInfer)

PowerInfer necesita un predictor de activación neuronal para cada modelo. Este es el diferenciador clave respecto a llama.cpp:

```bash
# Instalar dependencias Python del solver
pip3 install torch numpy scipy

# Generar predictor para tu modelo
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

# Esto crea archivos de predictor en ./predictors/
ls ./predictors/llama-2-7b-chat/
```

{% hint style="warning" %}
**Tiempo de generación del predictor:** Crear un predictor de neuronas puede tomar 30–60 minutos dependiendo del tamaño del modelo. Esta es una operación de una sola vez — el predictor se reutiliza en ejecuciones posteriores.
{% endhint %}

***

## Ejecutando inferencia

### Inferencia básica (Sin predictor)

Para pruebas sin generar predictor (división estándar GPU/CPU):

```bash
./build/bin/main \
  -m ./models/llama-2-7b-chat.Q4_K_M.gguf \
  --gpu-layers 20 \
  -p "Cuéntame sobre la computación cuántica" \
  -n 256
```

### Modo PowerInfer (Con predictor)

Modo completo PowerInfer con enrutamiento consciente de neuronas:

```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 "¿Cuál es el sentido de la vida?" \
  -n 512 \
  --ctx-size 4096
```

### Modo de chat interactivo

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

### Modo servidor (API compatible con 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
```

***

## Optimizando la división de capas en GPU

El `--gpu-layers` parámetro determina cuántas capas del transformador mantener en la GPU. Ajústalo según tu VRAM:

```bash
# Revisar VRAM disponible
nvidia-smi --query-gpu=memory.free,memory.total --format=csv

# Regla general para modelos Q4:
# 7B:  ~0.13GB por capa  → tarjeta de 24GB = ~184 capas (todas)
# 13B: ~0.18GB por capa  → tarjeta de 24GB = ~133 capas
# 70B: ~0.23GB por capa  → tarjeta de 24GB = ~104 capas (de 80 totales)
```

**Guía de asignación de capas:**

| VRAM GPU | Modelo 7B  | Modelo 13B | Modelo 34B | Modelo 70B |
| -------- | ---------- | ---------- | ---------- | ---------- |
| 8GB      | Todas (32) | 20 capas   | 10 capas   | 4 capas    |
| 16GB     | Todas (32) | Todas (40) | 25 capas   | 10 capas   |
| 24GB     | Todas (32) | Todas (40) | Todas (60) | 20 capas   |
| 48GB     | Todas (32) | Todas (40) | Todas (60) | Todas (80) |

***

## Benchmarks de rendimiento

### Comparación de rendimiento (Llama 2 70B, RTX 3090)

| Motor                | Capas en GPU          | Tokens/seg   |
| -------------------- | --------------------- | ------------ |
| llama.cpp (solo GPU) | 20/80                 | \~4 t/s      |
| llama.cpp (solo CPU) | 0/80                  | \~1 t/s      |
| **PowerInfer**       | **20/80 + predictor** | **\~12 t/s** |

{% hint style="success" %}
**3x de aceleración** sobre llama.cpp estándar para inferencia de modelos grandes en GPUs de consumo es típico con la planificación consciente de neuronas de PowerInfer.
{% endhint %}

***

## Ejecutando como servicio

Crea un servicio systemd para servir la API de forma persistente:

```bash
cat > /etc/systemd/system/powerinfer.service << 'EOF'
[Unit]
Description=Servidor 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
```

***

## Uso de la API

Una vez que el servidor esté en ejecución, usa cualquier cliente compatible con 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": "Explica las redes neuronales de forma sencilla"}
    ],
    max_tokens=256
)
print(response.choices[0].message.content)
```

***

## Solución de problemas

### CUDA Fuera de Memoria

```bash
# Reducir capas en GPU
./build/bin/main -m model.gguf --gpu-layers 10  # Reducir desde 20

# Revisar qué está usando VRAM
nvidia-smi

# Liberar memoria GPU
sudo fuser -v /dev/nvidia*  # Ver procesos
```

### Inferencia lenta en CPU

```bash
# Habilitar optimización de threading en CPU
./build/bin/main -m model.gguf --threads $(nproc) --gpu-layers 20

# Revisar topología NUMA
numactl --hardware

# Fijar al nodo NUMA más cercano a la GPU
numactl --cpunodebind=0 --membind=0 ./build/bin/main -m model.gguf
```

### La compilación falla

```bash
# Asegúrate de que el toolkit CUDA esté instalado
nvcc --version

# Revisar la versión de CMake (se necesita 3.14+)
cmake --version

# Limpieza de compilación
rm -rf build && mkdir build
cd build && cmake .. -DLLAMA_CUBLAS=ON -DCUDA_TOOLKIT_ROOT_DIR=/usr/local/cuda
```

{% hint style="danger" %}
**Problema común:** Si `cmake` no puede encontrar CUDA, establece `CUDA_HOME` la variable de entorno: `export CUDA_HOME=/usr/local/cuda` antes de ejecutar cmake.
{% endhint %}

***

## Recomendaciones de GPU en Clore.ai

El diseño híbrido CPU/GPU de PowerInfer cambia la economía de ejecutar modelos grandes. Los servidores Clore.ai con GPUs de alta VRAM Y CPUs rápidas son ideales.

| GPU       | VRAM  | Precio en Clore.ai | Modelo máximo (Q4)              | Rendimiento (Llama 2 70B Q4) |
| --------- | ----- | ------------------ | ------------------------------- | ---------------------------- |
| RTX 3090  | 24 GB | \~$0.12/h          | 70B (con 64GB+ RAM)             | \~8–12 tok/s                 |
| RTX 4090  | 24 GB | \~$0.70/h          | 70B (offload de CPU más rápido) | \~12–18 tok/s                |
| A100 40GB | 40 GB | \~$1.20/h          | 70B (offload mínimo)            | \~35–45 tok/s                |
| A100 80GB | 80 GB | \~$2.00/h          | 70B en precisión completa       | \~50–60 tok/s                |

{% hint style="info" %}
**Punto ideal de PowerInfer:** RTX 3090 a \~ $0.12/h ejecutando Llama 2 70B Q4 es un avance para usuarios con presupuesto limitado. Obtienes un modelo 70B por 10–12× menos que el costo de alquilar una A100. El rendimiento es más bajo (\~10 tok/s), pero para investigación o inferencia de bajo tráfico es un valor imbatible.
{% endhint %}

**La CPU importa tanto como la GPU:** PowerInfer descarga las neuronas "frías" a la CPU. Los servidores Clore.ai con CPUs AMD EPYC o Intel Xeon (muchos núcleos, alto ancho de banda de memoria) superarán significativamente a CPUs de consumo de un solo socket. Revisa las especificaciones del servidor antes de alquilar para trabajar con modelos grandes.

**Cuello de botella de ancho de banda de memoria:** Para modelos 70B, el ancho de banda de la RAM de la CPU es el factor limitante durante el cálculo de neuronas frías. Los servidores con RAM DDR5 ECC o arquitecturas adyacentes a HBM verán mejor rendimiento.

***

## Recursos

* 🐙 **GitHub:** [github.com/SJTU-IPADS/PowerInfer](https://github.com/SJTU-IPADS/PowerInfer)
* 📄 **Artículo de investigación:** [PowerInfer: Servicio rápido de Modelos de Lenguaje Extensos con una GPU de grado de consumo](https://arxiv.org/abs/2312.12456)
* 🤗 **Modelos GGUF:** [huggingface.co/TheBloke](https://huggingface.co/TheBloke)
* 🧩 **Laboratorio 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-es/modelos-de-lenguaje/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.