AirLLM: rode um modelo de 70B com 4GB de VRAM

Rodar um modelo de linguagem grande localmente exige VRAM. Muita VRAM. Um modelo de 70 bilhões de parâmetros em precisão completa (float16) precisa de aproximadamente 140 GB de VRAM para rodar. Isso está completamente fora do alcance de qualquer setup doméstico.

As alternativas usuais são quantização (reduzir a precisão dos pesos de float16 para int8 ou int4, sacrificando alguma qualidade) ou modelos menores, com 7B, 13B ou 30B de parâmetros. Ambas funcionam, mas são compromissos: ou você abre mão de qualidade, ou abre mão de capacidade.

O AirLLM propõe uma terceira abordagem, e ela é elegantemente simples.

A ideia central: streaming de camadas

Imagine que você está assistindo a um filme de 50 GB no streaming. Você não precisa baixar o filme inteiro antes de assistir. O servidor envia os dados em pedaços na ordem em que você vai precisar deles. Você assiste ao começo enquanto o resto ainda está chegando.

O AirLLM faz a mesma coisa com os modelos de linguagem.

Um LLM moderno é estruturado em camadas empilhadas. Cada token gerado pela rede passa por todas as camadas sequencialmente, da primeira até a última. O AirLLM explora exatamente essa característica: em vez de carregar todas as camadas na VRAM de uma vez, ele divide o modelo em arquivos separados (um por camada) e carrega apenas a camada atual para a GPU. Depois que o processamento daquela camada termina, os dados são descarregados e a próxima camada é carregada no lugar.

O resultado prático: a VRAM necessária é proporcional ao tamanho de uma única camada, não do modelo inteiro. Um modelo de 70B com 80 camadas passa a precisar de muito menos memória do que o modelo completo.

Isso vem com um custo: velocidade. Carregar dados do disco para a GPU a cada camada é mais lento do que tê-las todas na memória de uma vez. O AirLLM mitiga isso com prefetching (carrega a próxima camada enquanto a atual ainda está processando), mas ainda é mais lento que rodar o modelo inteiramente em VRAM. Para quem precisa de velocidade de produção, não é a ferramenta certa. Para quem quer explorar um modelo grande em hardware limitado, sem perda de qualidade dos pesos, é exatamente o que faz sentido.

O que você consegue rodar e com quanto de VRAM

Os números a seguir são medidos diretamente pelo projeto com hardware real:

Os modelos MoE (Mixture of Experts, como o Qwen3 235B e o Kimi K3) rodam com VRAM especialmente baixa porque o AirLLM carrega apenas os "especialistas" que o token atual precisa, não todos os especialistas do modelo.

Como instalar e usar

O AirLLM é uma biblioteca Python instalável pelo pip. O requisito básico é Python 3.8+ com PyTorch com suporte a CUDA.

Instalação

pip install airllm

Para modelos específicos que exigem versões especiais do Transformers (como o Kimi K3 e o Qwen3.8-Flash-Next), o README do projeto documenta os requisitos adicionais.

Uso básico

A interface é intencionalmente simples. Você passa o ID do repositório do Hugging Face (ou um caminho local) e o AirLLM cuida do resto:

from airllm import AutoModel

MAX_LENGTH = 128

# Passe o ID do repositório no Hugging Face ou um caminho local
model = AutoModel.from_pretrained("Qwen/Qwen3-32B")

# Exemplos de modelos maiores (mesma linha de código):
# model = AutoModel.from_pretrained("Qwen/Qwen3-235B-A22B")   # 235B, ~3GB
# model = AutoModel.from_pretrained("deepseek-ai/DeepSeek-V3") # 671B, ~12GB

input_text = ["Qual é a capital do Brasil?"]

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=50,
)

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

Na primeira execução, o AirLLM baixa o modelo do Hugging Face (se ainda não estiver em cache) e divide os pesos em arquivos por camada. Esse processo demora dependendo do tamanho do modelo e da velocidade do disco. Nas execuções seguintes, ele reutiliza os arquivos já divididos.

Compressão para mais velocidade

O AirLLM tem suporte opcional a compressão dos pesos das camadas no disco. Isso reduz o tamanho dos arquivos e pode acelerar o carregamento dependendo da velocidade do seu disco e da sua CPU. Para ativar:

model = AutoModel.from_pretrained(
    "Qwen/Qwen3-32B",
    compression="4bit"  # ou "8bit"
)

A compressão aqui é diferente da quantização tradicional: é aplicada ao arquivo em disco, não ao processamento do modelo. Os pesos são descomprimidos na hora de carregar cada camada, então o processamento acontece na precisão original.

Suporte a treinamento

O AirLLM adicionou suporte a treinamento em setembro de 2026. A ideia é a mesma: os pesos congelados são transmitidos camada por camada enquanto os adaptadores (LoRA, por exemplo) ficam na GPU. Isso permite treinar um modelo de 125B como o Qwen3.8-Flash-Next em menos de 6GB de VRAM em uma RTX 3060 Ti.

Para que casos de uso faz sentido

O AirLLM é a ferramenta certa para alguns cenários específicos:

Exploração e pesquisa: Você quer experimentar um modelo grande, entender como ele responde a diferentes prompts, comparar saídas com o modelo completo. A velocidade menor não é problema.

Hardware de homelab: Você tem uma GPU de 8GB, 10GB ou 12GB que ficaria parada se não fosse pelo AirLLM. Com ele, você roda modelos que normalmente precisariam de clusters de GPU.

Avaliação antes de investir em hardware: Você quer ter certeza de que um modelo específico serve para o seu caso de uso antes de alugar uma GPU maior ou comprar hardware mais caro.

Batch offline: Processamento de grandes volumes de texto onde a latência individual não importa, mas o custo de infraestrutura sim.

O AirLLM não é a escolha certa para inferência de produção em tempo real, onde cada segundo de resposta importa para o usuário final. Para isso, você precisa de VRAM suficiente para carregar o modelo completo, ou de serviços especializados de inferência.

Modelos suportados

O AirLLM usa a interface AutoModel do Transformers por baixo, então suporta praticamente qualquer modelo disponível no Hugging Face que siga a arquitetura Transformer padrão: Llama (todas as versões), DeepSeek V2 e V3, Qwen (todas as versões), Phi-4, Gemma, Mistral, ChatGLM, Baichuan, InternLM, e outros.

Para verificar se um modelo específico é suportado ou para relatar problemas de compatibilidade, o repositório do projeto está em github.com/lyogavin/airllm.

Suporte a macOS

O AirLLM também funciona no macOS com Apple Silicon (M1, M2, M3 e M4), usando a memória unificada como VRAM. Em Macs com memória RAM alta (64GB ou mais), é possível rodar modelos ainda maiores do que em GPUs dedicadas, já que a memória unificada é acessível tanto pela CPU quanto pela GPU integrada.

Fontes e Links:

• AirLLM no GitHub
• Pacote no PyPI
• Notebooks de exemplo no Google Colab