Leçon 3: Mise en route et déploiement d'un modèle IA via FastAPI et Uvicorn

^{Toutes les leçons}

Déploiement des modèles IA en Backend avec FastAPI et Uvicorn

Leçon 1
Déploiement backend des modèles IA avec FastAPI, ASGI et Uvicorn

Leçon 2
Préparer l'environnement de travail: installer les outils nécessaires et vérifier les dépendances

Leçon 3
Mise en route et déploiement d'un modèle IA via FastAPI et Uvicorn

Déploiement d’un modèle Random Forest sur le dataset Iris avec FastAPI

Du dataset Iris au service web

Nous allons reprendre le modèle Random Forest que nous avons entraîné puis sauvegardé au format .joblib dans la leçon Sauvegarder et recharger un modèle de Machine Learning avec Joblib.

L’objectif est de l’intégrer dans une application backend avec FastAPI afin de transformer ce modèle en un service web interactif.

Concrètement, au lieu de lancer des prédictions directement dans un script Python, nous allons créer une API qui recevra des données en entrée (les caractéristiques d’une fleur de l’iris dans notre cas), les transmettra au modèle, puis renverra la prédiction sous forme de réponse JSON.

Rappelons d’abord le code Python que nous avons utilisé pour entraîner et sauvegarder le modèle:

import joblib
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

X, y = load_iris(return_X_y=True)

# Entrainement du modèle
model = RandomForestClassifier()
model.fit(X,y)

# Sauvegarder le modèle dans un fichier .joblib
joblib.dump(model,"iris_model.joblib")
print("Modèle sauvegardé dans iris_model.joblib")

Avant de commencer le déploiement, il est indispensable de placer le fichier iris_model.joblib dans l’environnement Conda que nous avons créé pour ce projet.

Concrètement, cela signifie que le fichier doit être copié ou déplacé dans le répertoire de travail associé à l’environnement (par exemple le dossier du projet où sera situé le script main.py). Ainsi, lorsque l’on activera l’environnement et que l’on lancera l’application FastAPI, le modèle sera directement accessible et pourra être chargé sans erreur.

Créer le point d’entrée de l’application main.py

Avant tout, il faut créer un fichier nommé main.py. Ce fichier sera exécuté par le serveur et fera office de point d’entrée de notre application. C’est lui qui contiendra le code permettant de charger le modèle sauvegardé, de définir l’API avec FastAPI et d’exposer les routes nécessaires pour effectuer des prédictions. En d’autres termes, main.py constitue la porte d’accès principale à notre backend et centralise la logique de déploiement du modèle.

Le code à placer dans main.py ressemblera à ceci:

from fastapi import FastAPI
from pydantic import BaseModel
import joblib

# Charger le modèle sauvegardé
model = joblib.load("iris_model.joblib")

# Définir un schéma de données avec Pydantic
class IrisData(BaseModel):
   sepal_length: float
   sepal_width: float
   petal_length: float
   petal_width: float

# Créer l'application FastAPI
app = FastAPI()

# Endpoint de prédiction
@app.post("/predict")
def predict(data: IrisData):
   # Transformer les données reçues en liste
   # compatible avec le modèle
   sample = [[
      data.sepal_length,
      data.sepal_width,
      data.petal_length,
      data.petal_width
   ]]
   prediction = model.predict(sample)
   return {"prediction": int(prediction[0])}

Pour l’instant, nous allons simplement exécuter le fichier main.py afin de tester son fonctionnement et vérifier que notre API répond correctement aux requêtes. Les détails du code, ligne par ligne, seront expliqués en profondeur dans la leçon suivante.

Lancer l’API de l’application avec Uvicorn

Pour exécuter le code, il suffit d’ouvrir un terminal, de se placer dans le répertoire où se trouve le fichier main.py, puis de lancer le serveur avec la commande :

uvicorn main:app --reload

Cette commande démarre l’application FastAPI et rend l’API accessible à l’adresse http://127.0.0.1:8000.

L’option --reload permet de recharger automatiquement le serveur à chaque modification du code, ce qui est pratique en phase de développement.

Nous allons maintenant tester notre API en lui envoyant une requête CURL (via la commande Invoke-RestMethod dans PowerShell):

Invoke-RestMethod -Uri "http://localhost:8000/predict" `
   -Method POST `
   -Headers @{ "Content-Type" = "application/json" } `
   -Body '{"sepal_length": 5.1,"sepal_width": 3.5,"petal_length": 1.4,"petal_width": 0.2}'

Cette commande PowerShell envoie une requête HTTP POST vers l’endpoint /predict de notre API FastAPI. Elle utilise Invoke-RestMethod pour communiquer avec le serveur local (http://localhost:8000/predict) et précise dans l’en‑tête que le contenu est au format JSON. Le corps de la requête contient les quatre caractéristiques de la fleur Iris (sepal_length, sepal_width, petal_length, petal_width) avec les valeurs de test [5.1, 3.5, 1.4, 0.2].

Il existe de nombreux moyens pour tester notre API, et l’utilisation de CURL ou de Invoke-RestMethod n’est qu’une option parmi d’autres. On peut par exemple passer directement par l’interface interactive Swagger UI générée automatiquement par FastAPI, utiliser un outil spécialisé comme Postman, ou encore développer un front‑end personnalisé.

Une fois exécutée, la commande précédente transmet ces données au modèle Random Forest déployé, qui calcule la prédiction et renvoie une réponse JSON indiquant la classe de la fleur. Autrement dit, c’est un moyen simple de tester le bon fonctionnement de l’API directement depuis le terminal.

Dans la leçon qui va suivre, nous allons explorer en détail le code de notre API. Nous analyserons chaque partie du fichier main.py afin de comprendre son rôle, depuis le chargement du modèle jusqu’à la définition des endpoints et la gestion des requêtes.

Leçon 1
Déploiement backend des modèles IA avec FastAPI, ASGI et Uvicorn

Leçon 2
Préparer l'environnement de travail: installer les outils nécessaires et vérifier les dépendances

Leçon 3
Mise en route et déploiement d'un modèle IA via FastAPI et Uvicorn