Chargement et utilisation du modèle IA (Fast API)

Dans FastAPI, lorsqu’on intègre de l’IA :

Chargement du modèle : récupérer un modèle pré-entraîné depuis un fichier ou un service externe.
Utilisation du modèle : envoyer des données au modèle pour obtenir des prédictions ou résultats.

Le modèle est utilisé directement dans les endpoints pour répondre aux requêtes des clients.

Comment ça fonctionne ?

Charger le modèle au démarrage de l’application pour éviter de le recharger à chaque requête (gain de performance).
- Ex. : model = joblib.load('mon_modele.pkl') pour scikit-learn
- Ex. : model = torch.load('mon_modele.pt') pour PyTorch
Recevoir des données via un endpoint FastAPI (souvent avec POST).
Valider et transformer les données pour qu’elles correspondent au format attendu par le modèle (pandas, numpy, tensors…).
Faire une prédiction en passant les données au modèle.
Retourner la réponse avec le résultat de la prédiction (JSON + code HTTP).

Exemple conceptuel

URL / endpoint : /predict/
Fonction Python : reçoit des données clients, les prépare, les passe au modèle et renvoie la prédiction.
Méthode HTTP : POST
Réponse : JSON contenant la valeur prédite et éventuellement un score ou confiance.

Bonnes pratiques

Charger le modèle une seule fois au démarrage avec startup event si nécessaire.
Valider et nettoyer les données entrantes pour éviter les erreurs du modèle.
Gérer les exceptions pour que l’API ne plante pas si le modèle échoue.
Retour clair : prédiction + code HTTP (200 pour succès, 400 pour données invalides).
Versionner le modèle pour pouvoir mettre à jour sans casser l’API.

Pourquoi c’est important

Permet de créer une API prédictive rapide et fiable.
Les clients peuvent utiliser l’IA sans connaître ses détails internes.
Facilite le débogage et la maintenance, car le point d’utilisation du modèle est clair.

En résumé :

Le modèle IA est chargé une seule fois et utilisé par les endpoints.
Les endpoints reçoivent les données, les préparent et les passent au modèle.
La réponse est structurée (JSON + code HTTP).
Une bonne gestion du modèle et des données rend l’API stable et performante.

Fonctions :

Chargement et utilisation d'un modèle IA avec Fast API (exemple)

Exemple de code :

from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import numpy as np

# 1️⃣ Définir un modèle de données pour la requête
class InputData(BaseModel):
    feature1: float
    feature2: float
    feature3: float

app = FastAPI()

# 2️⃣ Charger le modèle IA pré-entraîné
with open("model.pkl", "rb") as f:
    model = pickle.load(f)

# 3️⃣ Créer une route POST pour la prédiction
@app.post("/predict/")
def predict(data: InputData):
    # Convertir les données en tableau numpy
    input_array = np.array([[data.feature1, data.feature2, data.feature3]])
    # Faire la prédiction
    prediction = model.predict(input_array)
    # Retourner le résultat
    return {"prediction": prediction.tolist()}

Explication du code :

from fastapi import FastAPI importe la classe FastAPI qui permet de créer une application web API.
 from pydantic import BaseModel importe BaseModel de Pydantic, utilisé pour définir et valider les données d’entrée JSON.
 import pickle importe la bibliothèque pickle pour charger un modèle IA enregistré dans un fichier.
 import numpy as np importe numpy pour manipuler les tableaux numériques nécessaires au modèle.
Définir un modèle de données pour la requête
 class InputData(BaseModel): crée une classe qui définit les champs attendus dans la requête JSON.
 feature1, feature2, feature3 sont des nombres flottants que le client doit fournir.
 FastAPI valide automatiquement que les données reçues correspondent à ce format.
Créer l’application FastAPI
 app = FastAPI() crée une instance de l’application, qui servira à définir les routes et gérer les requêtes.
Charger le modèle IA pré-entraîné
 with open("model.pkl", "rb") as f: ouvre le fichier contenant le modèle sauvegardé en mode lecture binaire.
 model = pickle.load(f) charge le modèle dans la variable model pour pouvoir l’utiliser ensuite.
Créer une route POST pour la prédiction
 @app.post("/predict/") définit une route POST accessible à /predict/.
 def predict(data: InputData): la fonction reçoit les données JSON automatiquement converties en instance de InputData.
 input_array = np.array([[data.feature1, data.feature2, data.feature3]]) transforme les données reçues en tableau numpy, format attendu par la plupart des modèles ML.
 prediction = model.predict(input_array) effectue la prédiction avec le modèle chargé.
 return {"prediction": prediction.tolist()} renvoie le résultat sous forme JSON, en convertissant le tableau numpy en liste Python pour qu’il soit sérialisable.