Déploiement Initial et Configuration

Le modèle DASD-4B-Thinking est un LLM de 4 milliards de paramètres optimisé pour les tâches de raisonnement complexes, telles que les calculs mathématiques et la génération de code. Sa méthode d'entraînement efficace lui permet d'atteindre de hautes performances avec des données relativement restreintes.

Mise en place de l'environnement

Assurez-vous que les dépendances requises sont installées :

pip install vllm chainlit

Pour démarrer le serveur d'inférence via vLLM avec une configuration de base :

python -m vllm.entrypoints.api_server \
    --model /chemin/vers/DASD-4B-Thinking \
    --max-num-batched-tokens 4096 \
    --served-model-name DASD-4B-Thinking

La vérification du bon fonctionnement s'effectue en consultant les journaux d'activité. Une sortie indiquant que le serveur Uvicorn écoute sur le port 8000 confirme le succès du lancement.

Analyse du Paramètre de Traitement par Lots

Le paramètre --max-num-batched-tokens est central pour la gestion dynamique des lots dans vLLM. Il définit la quantité maximale de jetons (tokens) traités simultanément, influençant directement le débit, la latence et l'efficacité mémoire du GPU.

Voici des recommandations de valeurs initiales en fonction des cas d'usage :

Mesure de Performance et Ajustements

L'impact du paramétrage peut être évalué avec un script de test simple qui mesure le temps de réponse.

import time
from datetime import datetime
import requests

def evaluer_latence(taille_lot_tokens):
    debut = datetime.now()
    reponse = requests.post(
        "http://localhost:8000/generate",
        json={
            "prompt": "Explique le théorème de Pythagore.",
            "max_tokens": 256
        }
    )
    fin = datetime.now()
    delai = (fin - debut).total_seconds()
    return delai, reponse.json()

# Comparer plusieurs configurations
valeurs_test = [2048, 4096, 8192]
resultats = {}
for val in valeurs_test:
    delai, _ = evaluer_latence(val)
    resultats[val] = delai
    print(f"Test avec {val} tokens par lot terminé en {delai:.3f} secondes.")

Les résultats orientent les optimisations :

• Pour une faible latence : Utiliser une valeur basse (ex. : 2048).
• Pour un débit maximal : Augmenter la valeur (ex. : 16384) si la mémoire GPU le permet.
• En cas d'erreur de mémoire : Réduire significativement la taille du lot.

Intégration avec une Interface Utilisateur (Chainlit)

Chainlit permet de créer rapidement une interface web interactive. Le script suivant fait le pont entre l'interface et le serveur vLLM.

import chainlit as cl
import requests

@cl.on_message
async def gerir_message(utilisateur_message: str):
    reponse_api = requests.post(
        "http://localhost:8000/generate",
        json={
            "prompt": f"Question: {utilisateur_message}\nRéponse:",
            "max_tokens": 512,
            "temperature": 0.6
        }
    )
    donnees = reponse_api.json()
    await cl.Message(content=donnees["text"]).send()

Ce script se lance avec la commande chainlit run script.py. Il fournit un point d'entrée convivial pour interagir avec le modèle, en particulier pour tester ses capacités de raisonnement sur des requêtes précises.

Résolution de Problèmes Courants

Le service ne démarre pas : Vérifiez le chemin d'accès au modèle et la disponibilité de la mémoire GPU (nvidia-smi).

Les réponses sont lentes : Tentez de diminuer la valeur de --max-num-batched-tokens. Vérifiez aussi la connectivité réseau.

Erreurs de mémoire CUDA : La taille du lot dépasse la capacité mémoire. Réduisez le paramètre de tokens par lot ou passez à un GPU doté de plus de VRAM.