> 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-es/modelos-de-lenguaje/powerinfer.md).

# PowerInfer

**Inferencia LLM híbrida CPU/GPU que aprovecha la localidad de activación** — ejecuta modelos de 70B parámetros en una sola GPU de consumo al dividir inteligentemente el cómputo entre CPU y GPU.

> 🌟 **Más de 8.000 estrellas en GitHub** | Desarrollado en SJTU IPADS | Licencia MIT

***

## ¿Qué es PowerInfer?

PowerInfer es un motor de inferencia de alto rendimiento para grandes modelos de lenguaje que aprovecha una idea clave: **Los LLM muestran una fuerte localidad de activación** — un pequeño subconjunto de neuronas ("neuronas calientes") se activan de forma constante en la mayoría de los pasos de inferencia, mientras que la mayoría permanece inactiva.

PowerInfer usa esta propiedad para:

1. **Mantener las neuronas calientes en la GPU** para un cómputo rápido
2. **Descargar las neuronas frías a la CPU/RAM** sin una pérdida significativa de calidad
3. **Enrutamiento dinámico** del cómputo entre CPU y GPU según los patrones de activación

El resultado: puedes ejecutar un modelo de 70B con solo **16 GB de VRAM** en lugar de requerir más de 140 GB, todos en la GPU.

### Capacidades clave

* **Compatibilidad con GPU de consumo** — las RTX 3090/4090 pueden ejecutar modelos de 70B
* **Programación consciente de las neuronas** — el predictor determina el enrutamiento entre CPU y GPU por inferencia
* **Degradación mínima de la calidad** — mantiene más del 95% de la calidad de precisión completa
* **Compatibilidad con llama.cpp** — soporte para el formato GGUF
* **Descarga de CPU consciente de NUMA** — optimizado para CPUs con gran cantidad 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 **única RTX 4090** (24 GB de VRAM)
* Reduce drásticamente los costos de alquiler de GPU frente a configuraciones multi-GPU
* Procesa ventanas de contexto largas con la RAM de la CPU como desbordamiento
* Ejecuta modelos que antes requerían costosas instancias 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           | Moderada    |

{% hint style="info" %}
**La CPU importa:** PowerInfer descarga las neuronas frías a la CPU. Una CPU con gran cantidad de núcleos (AMD EPYC, Intel Xeon) y un 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) mercado, filtra por:

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

### Paso 2: Crea una imagen Docker personalizada

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

```dockerfile
FROM nvidia/cuda:12.8.1-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 solucionador
RUN pip3 install torch numpy scipy

EXPOSE 22

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

Compila y súbelo a Docker Hub o úsalo en línea con Clore.ai:

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

### Paso 3: Despliega en Clore.ai

En tu pedido de Clore.ai, configura:

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

***

## Compilando PowerInfer desde el código fuente

Si prefieres compilar dentro del contenedor:

```bash
# Conéctate por SSH a tu servidor de Clore.ai
ssh root@<clore-node-ip> -p <ssh-port>

# Instala los prerrequisitos
apt-get update && apt-get install -y git cmake build-essential python3 python3-pip

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

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

echo "¡Compilación completada!"
ls -la bin/
```

### Verificar compilación

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

***

## Obtener modelos

### Descargar modelos GGUF

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

```bash
# Instalar la CLI de HuggingFace
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 16 GB+ 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 de neuronas para cada modelo. Este es el diferenciador clave frente a llama.cpp:

```bash
# Instalar dependencias del solucionador de Python
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 tardar entre 30 y 60 minutos según el tamaño del modelo. Esta es una operación única — el predictor se reutiliza en ejecuciones posteriores.
{% endhint %}

***

## Ejecutando inferencia

### Inferencia básica (sin predictor)

Para probar 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 "Háblame sobre la computación cuántica" \\
  -n 256
```

### Modo PowerInfer (con predictor)

Modo completo de 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 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
```

***

## Optimización de la división de capas en GPU

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

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

# Regla general para modelos Q4:
# 7B:  ~0,13 GB por capa  → tarjeta de 24 GB = ~184 capas (todas)
# 13B: ~0,18 GB por capa  → tarjeta de 24 GB = ~133 capas
# 70B: ~0,23 GB por capa  → tarjeta de 24 GB = ~104 capas (de 80 en total)
```

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

| VRAM de 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) |

***

## Benchmark de rendimiento

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

| Motor                | Capas de 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" %}
**3 veces más rápido** que el llama.cpp estándar para inferencia de modelos grandes en GPUs de consumo es lo habitual con la programación consciente de neuronas de PowerInfer.
{% endhint %}

***

## Ejecución como servicio

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

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

### Memoria insuficiente en CUDA

```bash
# Reduce las capas de GPU
./build/bin/main -m model.gguf --gpu-layers 10  # Reduce desde 20

# Comprueba qué está usando la VRAM
nvidia-smi

# Libera la memoria de la GPU
sudo fuser -v /dev/nvidia*  # Ver procesos
```

### Inferencia lenta en CPU

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

# Comprueba la topología NUMA
numactl --hardware

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

### Fallo de compilación

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

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

# Compilación limpia
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 la variable de entorno `CUDA_HOME` : `export CUDA_HOME=/usr/local/cuda` antes de ejecutar cmake.
{% endhint %}

***

## Recomendaciones de GPU para Clore.ai

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

| GPU       | VRAM  | Precio de Clore.ai                        | Modelo máximo (Q4)              | Rendimiento (Llama 2 70B Q4) |
| --------- | ----- | ----------------------------------------- | ------------------------------- | ---------------------------- |
| RTX 3090  | 24 GB | $0.07–0.21/h                              | 70B (con 64 GB+ de RAM)         | \~8–12 tok/s                 |
| RTX 4090  | 24 GB | $0.14–0.42/h                              | 70B (descarga a CPU más rápida) | \~12–18 tok/s                |
| A100 40GB | 40 GB | [bare metal](https://clore.ai/bare-metal) | 70B (descarga mínima)           | \~35–45 tok/s                |
| A100 80GB | 80 GB | [bare metal](https://clore.ai/bare-metal) | 70B precisión completa          | \~50–60 tok/s                |

{% hint style="info" %}
**Punto óptimo de PowerInfer:** Una RTX 3090 a 0,07–0,21 $/hora ejecutando Llama 2 70B Q4 es un avance para usuarios con presupuesto ajustado. Obtienes un modelo de 70B por 10–12 veces menos que el costo de alquilar una A100. El rendimiento es menor (\~10 tok/s), pero para investigación o inferencia con poco tráfico es un valor insuperable.
{% endhint %}

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

**Cuello de botella del ancho de banda de memoria:** Para modelos de 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 cercanas 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 grandes modelos de lenguaje con una GPU 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
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-es/modelos-de-lenguaje/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.