airllm

name	airllm
description	Inferencia de LLMs de 70B-405B en GPU de 4GB — layer-wise sharding, lazy loading, prefetching, sin cuantización
url	https://github.com/lyogavin/airllm
category	mlops
fecha	2026-06-04T00:00:00.000Z

AirLLM — Inferencia de LLMs Masivos en Hardware Limitado

¿Qué hace?

AirLLM es una librería Python de código abierto que permite ejecutar inferencia de modelos de lenguaje grandes (LLMs) de 70B+ parámetros en una GPU de solo 4GB de VRAM, sin necesidad de cuantización, distillation ni pruning. En su versión más reciente, soporta Llama3.1 405B en 8GB de VRAM.

• Stars: 18,993 ⭐ | Forks: 2,080
• Lenguaje: Jupyter Notebook (Python)
• Licencia: Apache 2.0
• Versión: v2.11.0 (Qwen2.5 support)
• Creado: 2023-06-12

Casos de uso

1. Investigación con hardware limitado — Probar modelos de 70B-405B en laptops/desktops con GPU modesta (RTX 3060 4GB)
2. Educación y aprendizaje — Enseñar LLMs sin necesidad de clusters de GPUs costosos
3. Prototipado rápido — Evaluar diferentes modelos y prompts antes de escalar a hardware más grande
4. Inferencia edge/local — Desplegar modelos grandes en entornos con recursos limitados
5. MacOS inference — Ejecutar modelos de 70B en Mac con Apple Silicon usando MLX
6. Fine-tuning evaluation — Probar modelos antes de fine-tuning sin gastar en cloud GPUs

Arquitectura / Patrones clave

Core Architecture:

AutoModel.from_pretrained("model_id")
    ├── Detecta arquitectura del modelo (Llama, Mistral, Mixtral, Qwen, ChatGLM, Baichuan, InternLM)
    └── AirLLMBaseModel
            ├── split_and_save_layers() → divide el modelo en shards por capa
            ├── init_model() → crea modelo vacío con init_empty_weights()
            ├── Prefetching pipeline (CUDA stream + ThreadPoolExecutor)
            ├── Forward pass layer-by-layer
            │       ├── Cada capa se carga en GPU → procesa → libera memoria
            │       └── Activaciones intermedias se guardan en RAM (no VRAM)
            └── Compression (opcional)
                    ├── 4bit block-wise quantization (3x speedup)
                    └── 8bit block-wise quantization (2x speedup)

Patrones técnicos clave:

1. Layer-wise Sharding: El modelo se divide en shards por capa (embed → layers[0..N] → norm → lm_head). Cada shard se guarda como archivo safetensors independiente.
2. Lazy Layer Loading: Durante el forward pass, solo una capa está en GPU a la vez.
3. Prefetching Pipeline: CUDA stream y ThreadPoolExecutor solapan el loading de la siguiente capa con el compute de la capa actual (10% speedup).
4. Block-wise Quantization: Compresión solo en pesos (no activations), usando bitsandbytes. Menos impacto en accuracy que cuantización full.
5. Model Persister Pattern: Abstracción para persistencia de capas (SafetensorModelPersister para CUDA, MlxModelPersister para macOS).
6. Auto-discovery: AutoModel.from_pretrained() detecta automáticamente la arquitectura.

Modelos soportados:

Llama, Llama2, Llama3, Llama3.1 (hasta 405B!), Mistral, Mixtral, Qwen, Qwen2, Qwen2.5, ChatGLM, Baichuan, InternLM

Snippets útiles

# Instalación
pip install airllm
# Opcional: para compresión
pip install bitsandbytes

# Uso básico (70B en 4GB GPU)
from airllm import AutoModel

model = AutoModel.from_pretrained("garage-bAInd/Platypus2-70B-instruct")

input_text = ["What is the capital of United States?"]
input_tokens = model.tokenizer(input_text, return_tensors="pt", truncation=True, max_length=128)

generation_output = model.generate(
    input_tokens['input_ids'].cuda(),
    max_new_tokens=20,
    use_cache=True,
    return_dict_in_generate=True
)

print(model.tokenizer.decode(generation_output.sequences[0]))

# Con compresión 4bit (3x speedup)
model = AutoModel.from_pretrained(
    "garage-bAInd/Platypus2-70B-instruct",
    compression='4bit',
    profiling_mode=True,
    prefetching=True,
    delete_original=True  # Free disk space after splitting
)

# Con token HuggingFace (modelos gated)
model = AutoModel.from_pretrained(
    "meta-llama/Llama-2-70b-hf",
    hf_token="HF_API_TOKEN"
)

Cómo integrarlo con Mastermind/Hermes

1. Democratización de LLMs — Permite trabajar con modelos de 70B-405B en hardware modesto, extremadamente relevante para proyectos de IA sin acceso a infraestructura cloud costosa.
2. Compatibilidad con HuggingFace — Usa la misma API que transformers (from_pretrained, generate), facilitando la integración.
3. MacOS support — Útil para desarrollo en Apple Silicon.
4. Compresión sin pérdida significativa — Block-wise quantization ofrece 3x speedup con pérdida de accuracy "ignorable".

Pitfalls

• Espacio en disco: El proceso de split del modelo consume mucho disco. Tener espacio suficiente en .cache/huggingface.
• Compresión desactiva prefetching: Si usas compression='4bit' o '8bit', el prefetching se desactiva automáticamente.
• Error MetadataIncompleteBuffer: Indica falta de espacio en disco durante el split.
• Tokenizer sin padding: Algunos tokenizers no tienen padding token — hay que desactivar padding.
• QWen y ChatGLM: Requieren usar AutoModel en lugar de clases específicas.

Fecha de descubrimiento

2026-06-04 (trending diario)