3 agents. 3 LLM. 1 GPU vieillissant : Ingénierie de l'inférence parallèle sur du métal nu.

3 Agents. 3 LLM. 1 GPU vieillissant : Ingénierie de l'inférence parallèle sur du métal nu

L'essor des systèmes d'IA multi-agents a créé un nouveau défi : comment exécuter trois agents LLM indépendants simultanément sur un seul GPU vieillissant, sans déchargement vers le cloud ? Cet article présente l'ingénierie pratique de l'inférence parallèle sur du métal nu, en utilisant uniquement le matériel que vous possédez déjà. Nous aborderons les prérequis, l'installation étape par étape et des exemples d'utilisation concrets — le tout sur un seul GPU qui a connu des jours meilleurs.

Pourquoi l'inférence parallèle est importante

Les workflows d'IA modernes reposent de plus en plus sur plusieurs agents travaillant de concert — l'un pour le raisonnement, un autre pour la récupération d'informations, un troisième pour la génération créative. Les exécuter séquentiellement sur un seul GPU gaspille du temps et de la mémoire. L'inférence parallèle, où chaque agent génère des tokens simultanément, peut réduire la latence et améliorer le débit. Mais sur un GPU vieillissant (pensez GTX 1080 Ti ou RTX 2060), vous devez gérer soigneusement la mémoire, les tailles de modèles et l'ordonnancement.

Comme le soulignent les discussions récentes dans l'industrie, y compris les articles d'OpenAI News et du Microsoft AI Blog, la tendance vers des modèles plus petits et spécialisés rend cela réalisable. Anthropic News a également souligné qu'une inférence efficace est essentielle pour démocratiser l'IA. Ce guide met ces idées en pratique.

Prérequis

Avant de commencer, définissons la configuration matérielle et logicielle de base.

Matériel

• **GPU** : NVIDIA GTX 1080 Ti (11 Go VRAM) ou similaire. Tout GPU avec 8 Go+ de VRAM fonctionne.
• **CPU** : Tout processeur moderne à 4 cœurs ou plus.
• **RAM** : 32 Go de mémoire système (16 Go minimum).
• **Stockage** : 50 Go libres pour les modèles et le code.

Logiciel

• **OS** : Ubuntu 22.04 LTS (ou tout Linux avec pilotes NVIDIA).
• **Pilote NVIDIA** : Version 525 ou ultérieure.
• **CUDA Toolkit** : 12.1 (compatible avec votre pilote).
• **Python** : 3.10 ou 3.11.

Modèles

Nous utiliserons trois LLM petits mais capables : 1. **Agent 1** : `microsoft/phi-3-mini-4k-instruct` (3,8 milliards de paramètres, ~2,2 Go en 4 bits) 2. **Agent 2** : `TinyLlama/TinyLlama-1.1B-Chat-v1.0` (1,1 milliard de paramètres, ~0,7 Go) 3. **Agent 3** : `google/gemma-2-2b-it` (2 milliards de paramètres, ~1,2 Go en 4 bits)

Utilisation totale de la VRAM : ~4 Go, laissant de la marge pour les caches KV et l'exécution concurrente.

Installation étape par étape

Nous allons configurer un environnement sur métal nu avec un minimum de surcharge. Pas de Docker, pas de cloud — juste de l'inférence brute.

1. Installer les dépendances système

Commencez par mettre à jour votre système et installer les outils essentiels.

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential git curl wget python3-pip python3-venv

2. Installer les pilotes NVIDIA et CUDA

Si vous n'avez pas le pilote NVIDIA installé, faites-le maintenant.

# Vérifiez votre GPU et la version du pilote
nvidia-smi
# Si non installé, utilisez l'installateur de pilotes Ubuntu
sudo ubuntu-drivers autoinstall
sudo reboot

Après le redémarrage, installez CUDA 12.1 (téléchargez depuis NVIDIA). Voici une installation minimale :

wget https://developer.download.nvidia.com/compute/cuda/12.1.0/local_installers/cuda_12.1.0_530.30.02_linux.run
sudo sh cuda_12.1.0_530.30.02_linux.run --silent --toolkit

Ajoutez CUDA à votre PATH :

echo 'export PATH=/usr/local/cuda-12.1/bin:$PATH' >> ~/.bashrc
echo 'export LD_LIBRARY_PATH=/usr/local/cuda-12.1/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc

3. Configurer l'environnement Python

Créez un environnement virtuel pour isoler les dépendances.

python3 -m venv llm_agents_env
source llm_agents_env/bin/activate

4. Installer les bibliothèques d'inférence

Nous utiliserons `transformers` avec `bitsandbytes` pour la quantification 4 bits, et `vllm` pour un ordonnancement parallèle efficace.

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install transformers accelerate bitsandbytes
pip install vllm

`vllm` est essentiel : il prend en charge le traitement par lots continu, ce qui signifie que plusieurs requêtes peuvent être traitées simultanément sur un seul GPU.

5. Télécharger les modèles

Nous allons mettre en cache les trois modèles localement.

# Créez un répertoire pour les modèles
mkdir -p ~/models

# Téléchargez chaque modèle avec une ligne Python
python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('microsoft/phi-3-mini-4k-instruct', device_map='auto', load_in_4bit=True); \
tokenizer = AutoTokenizer.from_pretrained('microsoft/phi-3-mini-4k-instruct'); \
model.save_pretrained('~/models/phi-3-mini'); \
tokenizer.save_pretrained('~/models/phi-3-mini')"

python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0', device_map='auto', load_in_8bit=True); \
tokenizer = AutoTokenizer.from_pretrained('TinyLlama/TinyLlama-1.1B-Chat-v1.0'); \
model.save_pretrained('~/models/tinyllama'); \
tokenizer.save_pretrained('~/models/tinyllama')"

python3 -c "from transformers import AutoModelForCausalLM, AutoTokenizer; \
model = AutoModelForCausalLM.from_pretrained('google/gemma-2-2b-it', device_map='auto', load_in_4bit=True); \
tokenizer = AutoTokenizer.from_pretrained('google/gemma-2-2b-it'); \
model.save_pretrained('~/models/gemma-2-2b'); \
tokenizer.save_pretrained('~/models/gemma-2-2b')"

Cela peut prendre 10 à 20 minutes selon votre vitesse Internet.

Ingénierie de l'inférence parallèle

Maintenant, construisons le système central : trois agents exécutant chacun un LLM différent, tous sur le même GPU.

L'architecture

Nous utilisons le serveur API asynchrone de `vllm`. Chaque agent est un client séparé qui envoie des invites simultanément. Le serveur les regroupe intelligemment.

Fichier de configuration

Créez `config.json` à la racine de votre projet :

{
  "models": [
    {
      "name": "phi-3-mini",
      "model_path": "~/models/phi-3-mini",
      "port": 8001,
      "max_num_seqs": 4,
      "gpu_memory_utilization": 0.3
    },
    {
      "name": "tinyllama",
      "model_path": "~/models/tinyllama",
      "port": 8002,
      "max_num_seqs": 6,
      "gpu_memory_utilization": 0.2
    },
    {
      "name": "gemma-2-2b",
      "model_path": "~/models/gemma-2-2b",
      "port": 8003,
      "max_num_seqs": 4,
      "gpu_memory_utilization": 0.3
    }
  ]
}

Remarque : les fractions `gpu_memory_utilization` totalisent 0,8, laissant 0,2 pour la surcharge.

Lancement du serveur

Créez `start_agents.sh` :

#!/bin/bash
source llm_agents_env/bin/activate

# Démarrez le serveur vllm pour chaque modèle en arrière-plan
python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/phi-3-mini \
    --port 8001 \
    --max-num-seqs 4 \
    --gpu-memory-utilization 0.3 \
    --trust-remote-code &

python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/tinyllama \
    --port 8002 \
    --max-num-seqs 6 \
    --gpu-memory-utilization 0.2 \
    --trust-remote-code &

python3 -m vllm.entrypoints.openai.api_server \
    --model ~/models/gemma-2-2b \
    --port 8003 \
    --max-num-seqs 4 \
    --gpu-memory-utilization 0.3 \
    --trust-remote-code &

# Attendez que tous les processus en arrière-plan se terminent
wait

Rendez-le exécutable et lancez-le :

chmod +x start_agents.sh
./start_agents.sh

Chaque serveur écoute sur un port différent. Ils partagent le même GPU via la gestion de mémoire de `vllm`.

Code client pour les requêtes parallèles

Créez maintenant `run_agents.py` pour envoyer des invites aux trois agents simultanément :

import asyncio
import aiohttp
import time

async def query_agent(session, url, prompt, agent_name):
    payload = {
        "model": agent_name,
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 200,
        "temperature": 0.7
    }
    start_time = time.time()
    async with session.post(url, json=payload) as resp:
        result = await resp.json()
        elapsed = time.time() - start_time
        content = result["choices"][0]["message"]["content"]
        print(f"[{agent_name}] Temps : {elapsed:.2f}s")
        print(f"[{agent_name}] Réponse : {content[:100]}...")
        return content

async def main():
    prompts = {
        "phi-3-mini": "Expliquez l'informatique quantique en termes simples.",
        "tinyllama": "Écrivez un haïku sur un chat.",
        "gemma-2-2b": "Quelle est la capitale de la France ? Expliquez brièvement."
    }
    
    urls = {
        "phi-3-mini": "http://localhost:8001/v1/chat/completions",
        "tinyllama": "http://localhost:8002/v1/chat/completions",
        "gemma-2-2b": "http://localhost:8003/v1/chat/completions"
    }
    
    async with aiohttp.ClientSession() as session:
        tasks = []
        for agent_name, prompt in prompts.items():
            task = query_agent(session, urls[agent_name], prompt, agent_name)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
        print("\n=== Tous les agents terminés ===")
        return results

if __name__ == "__main__":
    asyncio.run(main())

Exécutez-le :

python3 run_agents.py

Vous devriez voir les trois réponses s'afficher, avec des temps qui se chevauchent — la preuve d'une inférence parallèle.

Exemples d'utilisation

Exemple 1 : Raisonnement multi-agents

Combinez les agents pour une tâche de chaîne de pensée. Par exemple, l'agent 1 génère un plan, l'agent 2 récupère des faits, l'agent 3 synthétise la réponse.

Modifiez `run_agents.py` pour passer les sorties séquentiellement mais avec un chargement parallèle des modèles :

# Après avoir obtenu le plan de phi-3-mini, passez-le à tinyllama pour les faits
plan = results[0]
fact_prompt = f"Basé sur ce plan : {plan}, listez les faits clés."
# ... continuez le pipeline

Exemple 2 : Test de charge

Envoyez 10 requêtes simultanées à chaque agent pour tester votre GPU sous stress :

async def stress_test(agent_name, url, num_requests=10):
    async with aiohttp.ClientSession() as session:
        tasks = [query_agent(session, url, "Bonjour, qui êtes-vous ?", agent_name) 
                 for _ in range(num_requests)]
        await asyncio.gather(*tasks)

Sur une GTX 1080 Ti, vous obtiendrez un débit de 5 à 10 tokens/seconde par agent, selon la taille du modèle.

Exemple 3 : Surveillance de l'utilisation du GPU

Pendant l'exécution, surveillez la VRAM dans un autre terminal :

watch -n 1 nvidia-smi

Vous verrez l'utilisation de la VRAM osciller autour de 8 à 9 Go, avec les trois modèles chargés.

Dépannage

Erreurs de mémoire insuffisante

Si la VRAM est insuffisante, réduisez `gpu_memory_utilization` dans la configuration ou utilisez des modèles plus petits (par exemple, remplacez phi-3 par un modèle de 1 milliard de paramètres).

Erreurs CUDA

Assurez-vous que votre pilote correspond à CUDA 12.1. Exécutez :

nvidia-smi | grep "CUDA Version"

Inférence lente

Sur un GPU vieillissant, attendez-vous à 2 à 5 tokens/seconde par agent. C'est normal. Optimisez en réduisant `max_tokens` ou en utilisant la quantification 4 bits.

Conclusion

Exécuter trois agents LLM sur un seul GPU vieillissant est non seulement possible — c'est pratique. Avec une sélection minutieuse des modèles (petits modèles, quantification 4 bits), un ordonnanceur capable comme `vllm` et une configuration sur métal nu, vous pouvez réaliser une inférence parallèle sans ressources cloud. Cette configuration est idéale pour les passionnés, les chercheurs ou toute personne souhaitant expérimenter avec des systèmes multi-agents avec un budget limité.

Comme le soulignent des sources comme le Microsoft AI Blog et Anthropic News, l'avenir de l'IA réside dans une inférence efficace et sur appareil. En concevant pour les contraintes, vous libérez la puissance de multiples agents sans vous ruiner. Maintenant, allez construire quelque chose avec vos trois agents et votre GPU fatigué.