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

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.

---

Inicio rápido en Clore.ai

Paso 1: Elige tu servidor

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

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:

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:

# 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

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

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

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

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.

---

Ejecutando inferencia

Inferencia básica (sin predictor)

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

Modo PowerInfer (con predictor)

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

---

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:

# 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

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.

---

Ejecución como servicio

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

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:

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

# 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

# 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

# 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

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.

---

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	70B (descarga mínima)	~35–45 tok/s
A100 80GB	80 GB	bare metal	70B precisión completa	~50–60 tok/s

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.

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

• 📄 Artículo de investigación: PowerInfer: servicio rápido de grandes modelos de lenguaje con una GPU de consumo

• 🤗 Modelos GGUF: huggingface.co/TheBloke

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