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

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.

---

Inicio rápido en Clore.ai

Paso 1: Elige tu servidor

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

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:

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:

# 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

./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):

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

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

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.

---

Ejecutando inferencia

Inferencia básica (Sin predictor)

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

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

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

./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)

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

# 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

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.

---

Ejecutando como servicio

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

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:

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

# 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

# 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

# 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

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.

---

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

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.

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

• 📄 Artículo de investigación: PowerInfer: Servicio rápido de Modelos de Lenguaje Extensos con una GPU de grado de consumo

• 🤗 Modelos GGUF: huggingface.co/TheBloke

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