vLLM est une bibliothèque de service et d'inférence à hautes performances conçue pour les grands modèles de langage (LLM). Elle permet aux développeurs de déployer et d'exécuter rapidement des LLM dans leur propre infrastructure. Initialement développé par le Sky Computing Lab de l'UC Berkeley, il s'agit désormais d'un projet open-source miantenu conjointement par le monde universitaire et l'industrie.

vLLM aborde des défis clés dans l'inférence LLM grâce à :

• Gestion Mémoire Efficace : Utilise la technologie PagedAttention pour une gestion intelligente de la mémoire des paires clé-valeur dans le mécanisme d'attention.
• Batching de Requêtes : Traite plusieurs requêtes entrantes de manière continue pour améliorer significativement le débit.
• Optimisation d'Exécution : Emploie des CUDA/HIP graphs pour une exécution rapide des modèles.
• Support de Quantification : Prend en charge diverses méthodes de quantification comme GPTQ, AWQ, INT4, INT8 et FP8.

Avantages Clés

• Débit Élevé : Offre une capacité de traitement des requêtes plusieurs fois supérieure aux méthodes traditionnelles.
• Compatibilité Étendue : S'intègre facilement avec les modèles populaires de l'écosystème HuggingFace.
• Flexibilité de Déploiement : Prend en charge diverses configurations, des machines uniques aux clusters distribués.
• Facilité d'Utilisation : Fournit une API compatible avec OpenAI, réduisant les coûts de migration.

Préparation et Installation

Configuration Système Requise

• Système d'Exploitation : Linux (Ubuntu 20.04/22.04 recommandé)
• Version Python : 3.8+
• GPU : NVIDIA (16 Go de VRAM recommandé)
• CUDA : 11.8+
• Espace Disque : Minimum 50 Go

Étapes d'Installation

1. Créez et activez un environnement virtuel Python : ``` python -m venv vllm-env source vllm-env/bin/activate

2. Installez vLLM et FastAPI : ``` pip install vllm==0.17.1 fastapi uvicorn

3. Installez les dépendances CUDA pour PyTorch : ``` pip install torch --extra-index-url https://download.pytorch.org/whl/cu118

Mise en Place d'un Service LLM Basique

Lancement du Service vLLM

Créez un fichier basic\_service.py :

from vllm import LLM, SamplingParams

# Initialisation du modèle et des paramètres d'échantillonnage
modele_llm = LLM(model="facebook/opt-1.3b")
parametres_echantillonnage = SamplingParams(temperature=0.8, top_p=0.95)

# Exemple d'inférence
prompts_entree = ["Quel sera l'avenir du développement de l'IA ?"]
resultats = modele_llm.generate(prompts_entree, parametres_echantillonnage)

for resultat in resultats:
   print(f"Prompt : {resultat.prompt}")
   print(f"Texte généré : {resultat.outputs[0].text}")

Exécutez le script :

python basic_service.py

Encapsulation avec FastAPI

Créez un fichier fastapi\_service.py pour créer un microservice :

from fastapi import FastAPI
from vllm import LLM, SamplingParams
from pydantic import BaseModel

application = FastAPI()

# Modèle de données pour les requêtes de génération
class RequetteGeneration(BaseModel):
   instruction: str
   seuil_temperature: float = 0.8
   probabilite_top_p: float = 0.95
   token_max: int = 256

# Initialisation du modèle LLM
moteur_llm = LLM(model="facebook/opt-1.3b")

@application.post("/generer")
async def generer_texte(requette: RequetteGeneration):
   parametres = SamplingParams(
       temperature=requette.seuil_temperature,
       top_p=requette.probabilite_top_p,
       max_tokens=requette.token_max
   )
   
   output = moteur_llm.generate([requette.instruction], parametres)[0]
   
   return {
       "texte_genere": output.outputs[0].text,
       "instruction_recue": output.prompt,
       "raison_fin": output.outputs[0].finish_reason
   }

Lancez le service :

uvicorn fastapi_service:application --host 0.0.0.0 --port 8000

Implémentation de Fonctionnalités Avancées

Support de Réponses en Streaming

Modifiez le service FastAPI pour gérer les réponses en flux continu :

from fastapi.responses import StreamingResponse
import asyncio

@application.post("/flux")
async def flux_texte(requette: RequetteGeneration):
   parametres = SamplingParams(
       temperature=requette.seuil_temperature,
       top_p=requette.probabilite_top_p,
       max_tokens=requette.token_max,
       stream=True
   )
   
   async def generateur_flux():
       for output in moteur_llm.generate([requette.instruction], parametres):
           yield output.outputs[0].text + "\n"
           await asyncio.sleep(0.1) # Petite pause pour simuler le streaming
   
   return StreamingResponse(generateur_flux(), media_type="text/plain")

Gestion de Plusieurs Modèles

Modifiez l'initialisation du service pour charger plusieurs modèles :

# Charger plusieurs modèles
modèles_disponibles = {
   "opt-1.3b": LLM(model="facebook/opt-1.3b"),
   "gpt2-xl": LLM(model="gpt2-xl")
}

@application.post("/generer/{nom_modele}")
async def generer_avec_modele(nom_modele: str, requette: RequetteGeneration):
   if nom_modele not in modèles_disponibles:
       return {"erreur": "Modèle non trouvé"}
   
   moteur_courant = modèles_disponibles[nom_modele]
   # La logique de génération suit ici, similaire à /generer

Conseils pour le Déploiement en Production

Optimisation des Performances

• Augmentez la taille des lots (batch size).
• Activez le parallélisme Tensor (Tensor Parallelism).
• Choisissez une méthode de quantification adoptée.
• Ajustez les paramètres des noyaux CUDA.

Surveillance et Journalisation

Ajoutez des fonctionnalités de surveillance et de journalisation :

from fastapi import Request
import logging
import time

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@application.middleware("http")
async def journaliser_requetes(requette: Request, call_next):
   debut_temps = time.time()
   reponse = await call_next(requette)
   temps_traitement = time.time() - debut_temps
   logger.info(f"{requette.method} {requette.url} - {reponse.status_code} - {temps_traitement:.2f}s")
   return reponse

Considérations de Sécurité

• Implémentez une authentification par clé API.
• Limitez le taux de requêtes.
• Validez les entrées utilisateur.
• Utilisez le chiffrement HTTPS pour les communications.

Conclusion

Ce guide a couvert la création d'un microservice LLM privé basé sur vLLM et FastAPI, depuis la configuration initiale jusqu'aux fonctionnalités avancées et aux considérations de production. La combinaison de vLLM pour l'inférence performante et de FastAPI pour la création d'API flexibles offre une solution robuste pour le déploiement de LLM personnalisés.