AirLLM: modelos de lenguaje grandes en una tarjeta gráfica débil

Normalmente, ejecutar un modelo de lenguaje grande con 70 mil millones de parámetros requiere varias decenas de gigabytes de memoria de video. AirLLM aborda este problema con más calma y ofrece una forma diferente: un modelo de este tipo se puede ejecutar en una tarjeta de video con solo 4 GB de memoria y sin cuantificación, destilación ni recorte. En esta nota intentaré contarles sin prisas cómo funciona AirLLM, cómo usarlo y compartiré mi pequeño proyecto AirLLM-experiments, que hace que trabajar con esta biblioteca sea un poco más conveniente.

Qué es AirLLM

AirLLM es una biblioteca de código abierto para la inferencia de modelos de lenguajes grandes escrita por Gavin Li. Su idea es simple pero elegante: en lugar de almacenar todos los pesos del modelo en la memoria de video a la vez, la biblioteca carga solo una capa a la vez en la GPU. Los pesos se almacenan en el disco en forma de fragmentos cortados en capas y, durante la generación, cada capa se carga, procesa y descarga por turno.

De ello se deduce que la cantidad de memoria de vídeo necesaria no depende del tamaño total del modelo, sino del tamaño de una de sus capas. Es por eso que el modelo 70B cabe en 4 GB, el DeepSeek-V3 en el 671B cabe en unos 12 GB y el Qwen3-235B cabe en unos 3 GB. Pero el tamaño del modelo en sí está limitado principalmente por el espacio en disco y no por las capacidades de la tarjeta de video.

Estos ahorros de memoria se obtienen a costa de la velocidad: cada capa se lee del disco cuando se genera cada token, por lo que la salida es lenta, aproximadamente segundos por token. Entonces, AirLLM se trata menos de un chat interactivo rápido y más de la capacidad de incluso lanzar un modelo que de otro modo no encajaría en el hardware.

Instalación

La biblioteca se instala desde PyPI usando el comando habitual:

pip install airllm

Cuando lo inicie por primera vez, el modelo se descargará de Hugging Face y se descompondrá en capas. Este proceso es lento y ocupa mucho espacio en disco, por lo que debes preparar espacio libre con antelación. Si lo desea, puede habilitar la compresión de 4 u 8 bits; luego se aplicará la cuantificación de bloques a los pesos, lo que acelera la carga de capas desde el disco aproximadamente tres veces y la precisión se pierde bastante.

Ejemplo básico

Puede trabajar con AirLLM casi de la misma forma que con un modelo normal de Transformers. Basta con ingresar el ID del modelo una vez en Hugging Face, y luego todo le resultará familiar:

from airllm import AutoModel

MAX_LENGTH = 128
model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

input_text = ['What is the capital of United States?']

input_tokens = model.tokenizer(
    input_text,
    return_tensors="pt",
    return_attention_mask=False,
    truncation=True,
    max_length=MAX_LENGTH,
    padding=False)

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]))

La propia clase AutoModel determina el tipo de modelo, por lo que se puede utilizar la misma línea para Llama, Qwen y DeepSeek. Y si tomamos un modelo como DeepSeek-V3 con parámetros 671B, también caben alrededor de 12 GB de memoria de video; esto es en gran medida lo que hace que el proyecto sea atractivo.

Iniciar en macOS

AirLLM no solo se ejecuta en CUDA, sino también en Apple Silicon. En macOS utiliza el backend MLX, por lo que necesitará instalar mlx y torch, y solo es compatible con chips Apple. También hay una pequeña limitación: la implementación de MLX solo admite arquitecturas tipo Llama, por lo que Qwen y modelos similares no se pueden ejecutar en una MacBook de esta manera.

Ejemplo de uso

Los experimentos AirLLM son dos pequeñas utilidades de consola interactiva para ejecutar modelos de lenguaje grandes localmente. Eliminan la necesidad de escribir el mismo código cada vez para cargar el modelo y organizar el chat.

La primera herramienta, airllm-lib-usage.py, ejecuta la biblioteca AirLLM directamente en el proceso actual de Python. Muestra una lista numerada de modelos del catálogo general, si es necesario instala las dependencias faltantes y abre una sesión de chat. El tiempo de ejecución de MLX se usa en macOS, torch se usa en otras plataformas.

La segunda herramienta, airllm-openai-server-client.py, le ayuda a trabajar con el servidor airllm-openai-server, que se ejecuta en Docker y proporciona una API compatible con OpenAI. Cuando lo inicia por primera vez, la utilidad solicita configuración, recopila la imagen, toma el contenedor y abre un chat de transmisión en vivo al servidor en ejecución. Cuando se inicia repetidamente, encuentra un contenedor existente y simplemente lo reutiliza y almacena el caché del modelo en un volumen Docker separado para no descargar el modelo nuevamente.

La lista de modelos disponibles está incluida en el módulo común model_catalog.py, por lo que ambas herramientas funcionan con el mismo conjunto. Los comandos de chat también son comunes: /help, /clear, /exit. El código fuente y las instrucciones están en el repositorio:

https://github.com/zefir1990/AirLLM-experiments

A qué prestar atención

La primera respuesta puede tardar varios minutos en prepararse: primero, AirLLM descarga el modelo y lo corta en capas, y solo entonces comienza a generar. Además, la velocidad también sigue siendo baja; se trata de un compromiso deliberado para ahorrar memoria. Para modelos cerrados como meta-llama, debes aceptar los términos de Hugging Face y pasar un token de acceso. Es mejor no borrar el caché de los modelos y fragmentos descargados; de lo contrario, será necesario descargar todo nuevamente.

Enlaces

https://github.com/lyogavin/airllm
https://github.com/mkamranr/airllm-openai-server
https://github.com/zefir1990/AirLLM-experiments
https://pypi.org/project/airllm/
https://huggingface.co/

Fuentes

https://github.com/lyogavin/airllm
https://github.com/zefir1990/AirLLM-experiments