Servir les modèles d’apprentissage automatique via des API REST en moins de 10 minutes

Si vous aimez construire des modèles d’apprentissage automatique et expérimenter de nouvelles choses, c’est vraiment cool – mais pour être honnête, cela ne devient utile que les autres une fois que vous en avez mis à leur disposition. Pour cela, vous devez le servir – l’expose via une API Web afin que d’autres programmes (ou humains) puissent envoyer des données et récupérer les prédictions. C’est là que les API REST entrent en jeu.

Dans cet article, vous apprendrez comment nous passerons d’un simple modèle d’apprentissage automatique à une API prête à la production en utilisant Fastapi, l’un des cadres Web les plus rapides et les plus adaptés aux développeurs de Python, en un peu moins de 10 minutes. Et nous ne nous arrêterons pas simplement à une démo «Make It Run», mais nous ajouterons des choses comme:

• Valider les données entrantes
• Enregistrement de chaque demande
• Ajout de tâches d’arrière-plan pour éviter les ralentissements
• Gérer gracieusement les erreurs

Alors, permettez-moi de vous montrer rapidement à quoi ressemblera notre structure de projet avant de passer à la partie du code:

ml-api/
│
├── model/
│   └── train_model.py        # Script to train and save the model
│   └── iris_model.pkl        # Trained model file
│
├── app/
│   └── main.py               # FastAPI app
│   └── schema.py             # Input data schema using Pydantic
│
├── requirements.txt          # All dependencies
└── README.md                 # Optional documentation

Étape 1: Installez ce dont vous avez besoin

Nous aurons besoin de quelques packages Python pour ce projet: Fastapi pour l’API, Scikit-Learn pour le modèle et quelques aides comme Joblib et Pyndantic. Vous pouvez les installer à l’aide de PIP:

pip install fastapi uvicorn scikit-learn joblib pydantic

Et enregistrez votre environnement:

pip freeze > requirements.txt

Étape 2: former et enregistrer un modèle simple

Gardons la partie d’apprentissage automatique simple afin que nous puissions nous concentrer sur le service du modèle. Nous utiliserons le célèbre Ensemble de données iris et entraîner un classificateur de forêt aléatoire pour prédire le type de fleur d’iris en fonction de ses mesures de pétale et sépale.

Voici le script d’entraînement. Créer un fichier appelé Train_model.py dans un modèle/ annuaire:

from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import joblib, os

X, y = load_iris(return_X_y=True)
clf = RandomForestClassifier()
clf.fit(*train_test_split(X, y, test_size=0.2, random_state=42)(:2))

os.makedirs("model", exist_ok=True)
joblib.dump(clf, "model/iris_model.pkl")
print("✅ Model saved to model/iris_model.pkl")

Ce script charge les données, le divise, forme le modèle et le sauve à l’aide de Joblib. Exécutez-le une fois pour générer le fichier du modèle:

python model/train_model.py

Étape 3: Définissez la saisie de votre API

Nous devons maintenant définir comment les utilisateurs interagiront avec votre API. Que devraient-ils envoyer et dans quel format?

Nous utiliserons Pydontic, une partie intégrée de Fastapi, pour créer un schéma qui décrit et valide les données entrantes. Plus précisément, nous veillerons à ce que les utilisateurs fournissent quatre valeurs de flottement positives – pour la longueur / largeur sépale et la longueur / largeur de pétale.

Dans un nouveau fichier app / schema.pyajouter:

from pydantic import BaseModel, Field

class IrisInput(BaseModel):
    sepal_length: float = Field(..., gt=0, lt=10)
    sepal_width: float = Field(..., gt=0, lt=10)
    petal_length: float = Field(..., gt=0, lt=10)
    petal_width: float = Field(..., gt=0, lt=10)

Ici, nous avons ajouté des contraintes de valeur (supérieures à 0 et moins de 10) pour garder nos entrées propres et réalistes.

Étape 4: Créez l’API

Il est maintenant temps de construire l’API réelle. Nous utiliserons Fastapi pour:

• Chargez le modèle
• Acceptez l’entrée JSON
• Prédire la classe et les probabilités
• Enregistrer la demande en arrière-plan
• Retourner une réponse JSON propre

Écrivons le code API principal à l’intérieur app / main.py:

from fastapi import FastAPI, HTTPException, BackgroundTasks
from fastapi.responses import JSONResponse
from app.schema import IrisInput
import numpy as np, joblib, logging

# Load the model
model = joblib.load("model/iris_model.pkl")

# Set up logging
logging.basicConfig(filename="api.log", level=logging.INFO,
                    format="%(asctime)s - %(message)s")

# Create the FastAPI app
app = FastAPI()

@app.post("/predict")
def predict(input_data: IrisInput, background_tasks: BackgroundTasks):
    try:
        # Format the input as a NumPy array
        data = np.array(((input_data.sepal_length,
                          input_data.sepal_width,
                          input_data.petal_length,
                          input_data.petal_width)))
        
        # Run prediction
        pred = model.predict(data)(0)
        proba = model.predict_proba(data)(0)
        species = ("setosa", "versicolor", "virginica")(pred)

        # Log in the background so it doesn’t block response
        background_tasks.add_task(log_request, input_data, species)

        # Return prediction and probabilities
        return {
            "prediction": species,
            "class_index": int(pred),
            "probabilities": {
                "setosa": float(proba(0)),
                "versicolor": float(proba(1)),
                "virginica": float(proba(2))
            }
        }

    except Exception as e:
        logging.exception("Prediction failed")
        raise HTTPException(status_code=500, detail="Internal error")

# Background logging task
def log_request(data: IrisInput, prediction: str):
    logging.info(f"Input: {data.dict()} | Prediction: {prediction}")

Arrêtons-nous et comprenons ce qui se passe ici.

Nous chargeons le modèle une fois lorsque l’application démarre. Lorsqu’un utilisateur frappe le /prédire Point de terminaison avec une entrée JSON valide, nous convertissons cela en un tableau Numpy, le traversons le modèle et renvoyons la classe et les probabilités prévues. Si quelque chose ne va pas, nous le enregistrons et renvoyons une erreur amicale.

Remarquez le Antécédents Partie – Il s’agit d’une fonctionnalité Fastapi soignée qui nous permet de travailler après l’envoi de la réponse (comme les journaux de sauvegarde). Cela maintient l’API réactif et évite les retards.

Étape 5: Exécutez votre API

Pour lancer le serveur, utilisez Uvicorn comme ceci:

uvicorn app.main:app --reload

Visite: http://127.0.0.1:8000/docs
Vous verrez une interface utilisateur de fanfaronnade interactive où vous pouvez tester l’API.
Essayez cet exemple d’entrée:

{
  "sepal_length": 6.1,
  "sepal_width": 2.8,
  "petal_length": 4.7,
  "petal_width": 1.2
}

Ou vous pouvez utiliser Curl pour faire la demande comme ceci:

curl -X POST "http://127.0.0.1:8000/predict" -H  "Content-Type: application/json" -d 
'{
  "sepal_length": 6.1,
  "sepal_width": 2.8,
  "petal_length": 4.7,
  "petal_width": 1.2
}'

Les deux génèrent la même réponse qui est la suivante:

{"prediction":"versicolor",
 "class_index":1,
 "probabilities": {
	 "setosa":0.0,
	 "versicolor":1.0,
	 "virginica":0.0 }
 }

Étape facultative: déployez votre API

Vous pouvez déployer l’application Fastapi sur:

• Render.com (déploiement de configuration zéro)
• Railway.app (pour une intégration continue)
• Heroku (via Docker)

Vous pouvez également étendre cela à un service prêt pour la production en ajoutant l’authentification (telle que les clés API ou OAuth) pour protéger vos points de terminaison, surveiller les demandes avec Prometheus et Grafana, et utiliser Redis ou Celeer pour des files d’attente de travaux de fond. Vous pouvez également vous référer à mon article: Guide étape par étape pour déployer des modèles d’apprentissage automatique avec Docker.

Emballage

C’est tout – et c’est déjà mieux que la plupart des démos. Ce que nous avons construit est plus qu’un simple exemple de jouet. Cependant, cela:

• Valide automatiquement les données d’entrée
• Renvoie des réponses significatives avec la confiance des prédictions
• Journaux chaque demande à un fichier (api.log)
• Utilise des tâches de fond pour que l’API reste rapide et réactif
• Gère les échecs gracieusement

Et tout cela en moins de 100 lignes de code.

Kanwal Mehreen Kanwal est ingénieur d’apprentissage automatique et écrivain technique avec une profonde passion pour la science des données et l’intersection de l’IA avec la médecine. Elle a co-écrit l’ebook « Maximiser la productivité avec Chatgpt ». En tant que Google Generation Scholar 2022 pour APAC, elle défend la diversité et l’excellence académique. Elle est également reconnue comme une diversité de Teradata dans Tech Scholar, le boursier de recherche Mitacs Globalink et le savant de Harvard WECODE. Kanwal est un ardent défenseur du changement, après avoir fondé des femmes pour autonomiser les femmes dans les champs STEM.