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

# 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

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

```python
# 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]))
```

```python
# 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
)
```

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

## Cómo integrarlo con Koldo/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)