Construire une API LLM haute performance et prête pour la production avec FastAPI : Un guide étape par étape

FastAPI, un framework web Python moderne et haute performance, est populaire pour sa facilité d'utilisation, sa rapidité et sa documentation API générée automatiquement. En particulier, FastAPI démontre de puissants avantages dans la construction d'API backend pour les applications LLM (Large Language Model). Cet article vous apprendra étape par étape comment construire une API LLM prête pour la production avec FastAPI, et explorera quelques bonnes pratiques.

Pourquoi choisir FastAPI ?

FastAPI offre les avantages clés suivants lors de la construction d'une API d'application LLM :

• Haute performance : Basé sur ASGI, FastAPI peut gérer des requêtes à haute concurrence, ce qui est essentiel pour les applications LLM qui nécessitent une réponse rapide.
• Support asynchrone : FastAPI a un support intégré pour les mots-clés async et await, ce qui facilite la gestion des opérations asynchrones, comme l'appel de l'inférence LLM, en évitant de bloquer le thread principal.
• Documentation API automatique : FastAPI utilise OpenAPI et JSON Schema pour générer automatiquement une documentation API interactive (Swagger UI), ce qui permet aux développeurs de tester et d'utiliser facilement votre API.
• Validation des données : FastAPI utilise Pydantic pour la validation des données, garantissant l'exactitude des paramètres de requête et réduisant les erreurs.
• Injection de dépendances : Le système d'injection de dépendances de FastAPI facilite la gestion et le partage des ressources, comme les modèles LLM.
• Communauté active : FastAPI a une communauté vaste et active, ce qui permet d'obtenir des ressources et un support riches.

Préparation

1. Installer Python : Assurez-vous que Python 3.7 ou une version ultérieure est installée.

2. Installer FastAPI et Uvicorn : Utilisez pip pour installer FastAPI et Uvicorn (serveur ASGI) :

   pip install fastapi uvicorn
   

3. Choisir un modèle LLM : Choisissez le modèle LLM que vous souhaitez utiliser. Il peut s'agir d'un modèle OpenAI ou d'un modèle open source, tel que TinyLlama. Si vous choisissez OpenAI, vous devez obtenir une clé API OpenAI. Si vous choisissez TinyLlama, vous devez télécharger le fichier de modèle.

Étape 1 : Créer une application FastAPI

Créez un fichier nommé main.py et ajoutez le code suivant :

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="LLM API", description="A simple API for interacting with LLMs.")

class InputText(BaseModel):
    text: str

class OutputText(BaseModel):
    generated_text: str

Ce code définit une application FastAPI et définit deux modèles Pydantic : InputText pour recevoir le texte d'entrée et OutputText pour renvoyer le texte généré.

Étape 2 : Ajouter la logique d'inférence LLM

Selon le modèle LLM que vous avez choisi, ajoutez la logique d'inférence correspondante. Voici un exemple d'utilisation de l'API OpenAI :

import openai
import os

# Obtenir la clé API OpenAI
openai.api_key = os.environ.get("OPENAI_API_KEY")  # Il est recommandé d'utiliser des variables d'environnement
```@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generates text based on the input text using OpenAI.
    """
    try:
        response = openai.Completion.create(
            engine="text-davinci-003", # Choisir le modèle
            prompt=input_text.text,
            max_tokens=150,
            n=1,
            stop=None,
            temperature=0.7,
        )
        generated_text = response.choices[0].text.strip()
        return OutputText(generated_text=generated_text)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Ce code définit une route /generate qui reçoit un objet InputText en entrée, appelle l'API OpenAI pour générer du texte et renvoie le texte généré sous forme d'objet OutputText. Notez qu'il faut remplacer text-davinci-003 par le modèle approprié que vous avez choisi.

Si vous utilisez un modèle local comme TinyLlama, vous devez installer la bibliothèque correspondante, par exemple transformers, et charger le modèle en mémoire. Voici un exemple de code :

from transformers import pipeline
import torch

generator = pipeline('text-generation', model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", torch_dtype=torch.bfloat16, device_map="auto")

@app.post("/generate", response_model=OutputText)
async def generate_text(input_text: InputText):
    """
    Generates text based on the input text using TinyLlama.
    """
    try:
        generated_text = generator(input_text.text, max_length=50, do_sample=True, temperature=0.7)[0]['generated_text']
        return OutputText(generated_text=generated_text)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

Étape 3 : Exécuter l'application FastAPI

Exécutez l'application FastAPI avec Uvicorn :

uvicorn main:app --reload
```Cela démarrera un serveur local, et vous pourrez accéder à la documentation API générée automatiquement dans votre navigateur via `http://127.0.0.1:8000/docs`. L'argument `--reload` permet de redémarrer automatiquement le serveur après chaque modification du code, ce qui facilite le développement.

## Étape 4 : Tester l'API

Utilisez la documentation API ou des outils comme curl pour tester votre API. Par exemple, utilisez curl pour envoyer une requête POST :

```bash
curl -X POST -H "Content-Type: application/json" -d '{"text": "Tell me a joke about cats."}' http://127.0.0.1:8000/generate

Vous devriez recevoir une réponse JSON contenant le texte généré.

Étape 5 : Déploiement en production

Déployez votre application FastAPI dans un environnement de production, par exemple :

• Docker: Utilisez Docker pour conteneuriser votre application, ce qui facilite le déploiement et la gestion.
• Plateforme cloud: Déployez sur une plateforme cloud, par exemple AWS, Google Cloud Platform ou Azure. Azure Cosmos DB et Azure Functions, mentionnés dans le texte, peuvent être utilisés pour construire une API serverless. Modal peut également être utilisé pour déployer des applications FastAPI à mise à l'échelle automatique.
• Serveur: Déployez sur votre propre serveur.

Bonnes pratiques

• Utiliser des variables d'environnement pour stocker les informations sensibles : Ne codez pas en dur les informations sensibles telles que les clés API dans votre code, mais utilisez plutôt des variables d'environnement.
• Ajouter des journaux : Utilisez le module de journalisation pour enregistrer l'état de fonctionnement de l'API, ce qui facilite le débogage et la surveillance.
• Ajouter la gestion des erreurs : Utilisez des blocs try...except pour gérer les exceptions potentielles et renvoyer des messages d'erreur appropriés.
• Limitation du débit : Utilisez un limiteur de débit pour empêcher l'utilisation abusive de l'API. FastAPI propose plusieurs bibliothèques de limitation de débit prêtes à l'emploi.
• Cache : Pour les requêtes répétées, vous pouvez utiliser le cache pour améliorer les performances.
• Surveillance : Utilisez des outils de surveillance pour surveiller les performances et la disponibilité de l'API.

Astuces avancées

• Traitement asynchrone : Pour les inférences LLM chronophages, utilisez les mots-clés async et await pour effectuer un traitement asynchrone, en évitant de bloquer le thread principal.
• Réponse en flux : L'utilisation de StreamingResponse permet de renvoyer le texte généré en temps réel, ce qui améliore l'expérience utilisateur.
• Multithreading/Multiprocessing : Pour les inférences LLM gourmandes en CPU, vous pouvez utiliser le multithreading ou le multiprocessing pour améliorer les performances.
• Accélération GPU : Si votre modèle LLM prend en charge l'accélération GPU, vous pouvez utiliser CUDA ou d'autres bibliothèques d'accélération GPU pour augmenter la vitesse d'inférence.

ConclusionFastAPI est un outil puissant pour construire des API LLM performantes et prêtes pour la production. Grâce à ce guide, vous pouvez rapidement mettre en place une API LLM et l'étendre et l'optimiser en fonction de vos besoins. N'oubliez pas que l'apprentissage continu et la pratique sont essentiels pour devenir un excellent développeur d'applications LLM. Hornbeam, mentionné dans l'article, est également un serveur ASGI qui mérite d'être surveillé, car il prétend être plus rapide et plus stable que Gunicorn et peut être utilisé pour déployer des applications FastAPI.