AirLLM : de grands modèles de langage sur une carte graphique faible

En règle générale, l’exécution d’un modèle de langage volumineux comportant 70 milliards de paramètres nécessite plusieurs dizaines de gigaoctets de mémoire vidéo. AirLLM aborde ce problème plus sereinement et propose une manière différente : un tel modèle peut être exécuté sur une carte vidéo avec seulement 4 Go de mémoire, et sans quantification, distillation et découpage. Dans cette note, je vais essayer de vous expliquer sans hâte comment fonctionne AirLLM, comment l’utiliser, et je partagerai mon petit projet AirLLM-experiments, qui rend le travail avec cette bibliothèque un peu plus pratique.

Qu’est-ce qu’AirLLM

AirLLM est une bibliothèque open source pour l’inférence de grands modèles de langage écrite par Gavin Li. Son idée est simple et pourtant élégante : au lieu de stocker tous les poids du modèle en même temps dans la mémoire vidéo, la bibliothèque ne charge qu’une seule couche à la fois sur le GPU. Les poids sont stockés sur le disque sous forme de fragments découpés en couches, et lors de la génération, chaque couche est chargée, traitée et déchargée tour à tour.

Il s’ensuit que la quantité de mémoire vidéo requise ne dépend pas de la taille globale du modèle, mais de la taille d’une de ses couches. C’est pourquoi le modèle 70B tient dans 4 Go, le DeepSeek-V3 sur 671B tient dans environ 12 Go et le Qwen3-235B tient dans environ 3 Go. Mais la taille du modèle lui-même est limitée principalement par l’espace disque, et non par les capacités de la carte vidéo.

Ces économies de mémoire se font au détriment de la vitesse : chaque couche est lue sur le disque lorsque chaque jeton est généré, la sortie est donc lente, environ quelques secondes par jeton. AirLLM concerne donc moins une discussion interactive rapide que la possibilité de lancer un modèle qui, autrement, ne rentrerait pas dans le matériel.

Installation

La bibliothèque s’installe depuis PyPI à l’aide de la commande habituelle :

pip install airllm

Lors du premier lancement, le modèle sera téléchargé depuis Hugging Face et sera décomposé en couches. Ce processus est lent et occupe beaucoup d’espace disque, vous devez donc préparer l’espace libre à l’avance. Si vous le souhaitez, vous pouvez activer la compression 4 bits ou 8 bits – la quantification par blocs sera alors appliquée aux poids, ce qui accélère le chargement des couches à partir du disque d’environ trois fois, et la précision est considérablement perdue.

Exemple de base

Vous pouvez travailler avec AirLLM presque de la même manière qu’avec un modèle classique de transformateurs. Il suffit de saisir une fois l’ID du modèle sur Hugging Face, et tout vous sera alors familier :

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 classe AutoModel elle-même détermine le type de modèle, la même ligne peut donc être utilisée pour Llama, Qwen et DeepSeek. Et si vous prenez un modèle comme DeepSeek-V3 avec des paramètres 671B, il pourra également contenir environ 12 Go de mémoire vidéo – c’est en grande partie ce qui rend le projet attrayant.

Lancer sur macOS

AirLLM fonctionne non seulement sur CUDA, mais également sur Apple Silicon. Sur macOS, il utilise le backend MLX, il faudra donc que mlx et torch soient installés et ne prend en charge que les puces Apple. Il existe également une petite limitation : l’implémentation MLX ne prend en charge que les architectures de type Llama, donc Qwen et les modèles similaires ne peuvent pas être lancés sur un MacBook de cette manière.

Utiliser un exemple

Les expériences AirLLM sont deux petits utilitaires de console interactifs permettant d’exécuter localement de grands modèles de langage. Ils éliminent le besoin d’écrire le même code à chaque fois pour charger le modèle et organiser le chat.

Le premier outil, airllm-lib-usage.py, exécute la bibliothèque AirLLM directement dans le processus Python actuel. Il affiche une liste numérotée de modèles du catalogue général, si nécessaire, il installe les dépendances manquantes et ouvre une session de chat. Le runtime MLX est utilisé sur macOS, torch est utilisé sur d’autres plates-formes.

Le deuxième outil, airllm-openai-server-client.py, vous aide à travailler avec le serveur airllm-openai-server, qui s’exécute dans Docker et fournit une API compatible OpenAI. Lorsque vous le lancez pour la première fois, l’utilitaire demande des paramètres, collecte l’image, récupère le conteneur et ouvre une discussion en streaming sur le serveur en cours d’exécution. Lorsqu’il est lancé à plusieurs reprises, il trouve un conteneur existant et le réutilise simplement, et stocke le cache du modèle dans un volume Docker séparé afin de ne pas télécharger à nouveau le modèle.

La liste des modèles disponibles est incluse dans le module commun model_catalog.py, donc les deux outils fonctionnent avec le même ensemble. Les commandes de discussion sont également courantes : /help, /clear, /exit. Le code source et les instructions sont dans le dépôt :

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

À quoi faire attention

La préparation de la première réponse peut prendre plusieurs minutes : tout d’abord, AirLLM télécharge le modèle et le découpe en couches, puis commence seulement à générer. De plus, la vitesse reste également faible – il s’agit d’un compromis délibéré dans un souci d’économie de mémoire. Pour les modèles fermés comme le méta-llama, vous devez accepter les conditions de Hugging Face et transmettre un jeton d’accès. Il est préférable de ne pas supprimer le cache des modèles et fragments téléchargés, sinon tout devra être téléchargé à nouveau.

Liens

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/

Sources

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