Normalmente, a execução de um modelo de linguagem grande com 70 bilhões de parâmetros requer várias dezenas de gigabytes de memória de vídeo. AirLLM aborda esse problema com mais calma e oferece uma maneira diferente: tal modelo pode ser executado em uma placa de vídeo com apenas 4 GB de memória, e sem quantização, destilação e corte. Nesta nota tentarei contar sem pressa como funciona o AirLLM, como usá-lo, e compartilharei meu pequeno projeto AirLLM-experiments, o que torna o trabalho com esta biblioteca um pouco mais conveniente.
O que é AirLLM
AirLLM é uma biblioteca de código aberto para inferência de modelos de linguagem grande, escrita por Gavin Li. Sua ideia é simples e elegante: em vez de armazenar todos os pesos do modelo na memória de vídeo de uma só vez, a biblioteca carrega apenas uma camada por vez na GPU. Os pesos são armazenados no disco na forma de fragmentos cortados em camadas e, durante a geração, cada camada é carregada, processada e descarregada por vez.
Conclui-se que a quantidade de memória de vídeo necessária não depende do tamanho geral do modelo, mas do tamanho de uma de suas camadas. É por isso que o modelo 70B cabe em 4 GB, o DeepSeek-V3 no 671B cabe em cerca de 12 GB e o Qwen3-235B cabe em cerca de 3 GB. Mas o tamanho do modelo em si é limitado principalmente pelo espaço em disco, e não pelos recursos da placa de vídeo.
Essas economias de memória têm o custo da velocidade: cada camada é lida do disco quando cada token é gerado, portanto a saída é lenta, cerca de segundos por token. Portanto, AirLLM tem menos a ver com um bate-papo interativo rápido e mais com a capacidade de lançar um modelo que de outra forma não caberia no hardware.
Instalação
A biblioteca é instalada a partir do PyPI usando o comando usual:
pip install airllm
Quando você iniciar pela primeira vez, o modelo será baixado do Hugging Face e será decomposto em camadas. Este processo é lento e ocupa muito espaço em disco, portanto você deve preparar o espaço livre com antecedência. Se desejar, você pode ativar a compactação de 4 ou 8 bits – então a quantização de bloco será aplicada aos pesos, o que acelera o carregamento das camadas do disco em cerca de três vezes, e a precisão é perdida um pouco.
Exemplo básico
Você pode trabalhar com AirLLM quase da mesma maneira que com um modelo normal de transformadores. Basta inserir o ID do modelo uma vez no Hugging Face e tudo ficará 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]))
A própria classe AutoModel determina o tipo de modelo, portanto a mesma linha pode ser usada para Llama, Qwen e DeepSeek. E se você pegar um modelo como o DeepSeek-V3 com parâmetros de 671B, ele também caberá em cerca de 12 GB de memória de vídeo – isso é em grande parte o que torna o projeto atraente.
Iniciar no macOS
AirLLM roda não apenas em CUDA, mas também em Apple Silicon. No macOS, ele usa o backend MLX, portanto, precisará do mlx e do torch instalados e oferece suporte apenas a chips Apple. Há também uma pequena limitação: a implementação do MLX suporta apenas arquiteturas do tipo Llama, portanto, o Qwen e modelos semelhantes não podem ser iniciados em um MacBook dessa forma.
Usar exemplo
Os experimentos AirLLM são dois pequenos utilitários de console interativos para executar localmente grandes modelos de linguagem. Eles eliminam a necessidade de escrever sempre o mesmo código para carregar o modelo e organizar o chat.
A primeira ferramenta, airllm-lib-usage.py, executa a biblioteca AirLLM diretamente no processo Python atual. Mostra uma lista numerada de modelos do catálogo geral, se necessário instala dependências faltantes e abre uma sessão de chat. O tempo de execução MLX é usado no macOS, o torch é usado em outras plataformas.
A segunda ferramenta, airllm-openai-server-client.py, ajuda você a trabalhar com o servidor airllm-openai-server, que roda em Docker e fornece uma API compatível com OpenAI. Ao iniciá-lo pela primeira vez, o utilitário solicita configurações, coleta a imagem, pega o contêiner e abre um chat de streaming para o servidor em execução. Quando iniciado repetidamente, ele encontra um contêiner existente e simplesmente o reutiliza e armazena o cache do modelo em um volume Docker separado para não baixar o modelo novamente.
A lista de modelos disponíveis está incluída no módulo comum model_catalog.py, portanto ambas as ferramentas funcionam com o mesmo conjunto. Comandos de chat também são comuns: /help, /clear, /exit. O código fonte e as instruções estão no repositório:
https://github.com/zefir1990/AirLLM-experiments
No que prestar atenção
A primeira resposta pode levar vários minutos para ser preparada: primeiro, o AirLLM baixa o modelo e o corta em camadas, e só então começa a gerar. Além disso, a velocidade também permanece baixa – este é um compromisso deliberado para economizar memória. Para modelos fechados como o metal-lhama, você precisa aceitar os termos do Hugging Face e passar um token de acesso. É melhor não excluir o cache dos modelos e fragmentos baixados, caso contrário, tudo terá que ser baixado novamente.
Links
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/
Fontes
https://github.com/lyogavin/airllm
https://github.com/zefir1990/AirLLM-experiments
Leave a Reply