Recherche de site Web

Un guide pratique pour le déploiement de modèles d'apprentissage automatique

En tant que data scientist, vous savez probablement comment créer des modèles d'apprentissage automatique. Mais ce n’est que lorsque vous déployez le modèle que vous obtenez une solution d’apprentissage automatique utile. Et si vous souhaitez en savoir plus sur le déploiement de modèles de machine learning, ce guide est fait pour vous.

Les étapes impliquées dans la création et le déploiement de modèles ML peuvent généralement être résumées comme suit : créer le modèle, créer une API pour servir les prédictions du modèle, conteneuriser l'API et déployer sur le cloud.

Ce guide se concentre sur les éléments suivants :

  • Créer un modèle d'apprentissage automatique avec Scikit-learn
  • Création d'une API REST pour servir les prédictions du modèle à l'aide de FastAPI
  • Conteneuriser l'API à l'aide de Docker

Nous allons construire un modèle de régression simple sur l’ensemble de données sur le logement californien pour prédire les prix de l’immobilier. À la fin, vous disposerez d’une application conteneurisée qui fournit des prévisions de prix immobiliers en fonction de caractéristiques d’entrée sélectionnées.

Configuration de l'environnement du projet

Avant de commencer, assurez-vous que les éléments suivants sont installés :

  • Une version récente de Python (Python 3.11 ou version ultérieure de préférence)
  • Docker pour la conteneurisation ; Obtenez Docker pour votre système d'exploitation

⚙️ Pour suivre confortablement, il est utile d'avoir une compréhension de base de la création de modèles d'apprentissage automatique et de l'utilisation des API.

Commencer

Voici la structure (recommandée) pour le répertoire du projet :

project-dir/
│
├── app/
│   ├── __init__.py       	# Empty file
│   └── main.py           	# FastAPI code for prediction API
│
├── model/
│   └── linear_regression_model.pkl  # Saved trained model (after running model_training.py)
│
├── model_training.py      	# Script to train and save the model
├── requirements.txt       	# Dependencies for the project
└── Dockerfile             	# Docker configuration

Nous aurons besoin de quelques bibliothèques Python pour commencer. Installons-les tous ensuite.

Dans votre environnement de projet, créez et activez un environnement virtuel :

$ python3 -m venv v1
$ source v1/bin/activate

Pour le projet sur lequel nous allons travailler, nous avons besoin de pandas et de scikit-learn pour construire le modèle d'apprentissage automatique. Et FastAPI et Uvicorn pour créer l’API pour servir les prédictions du modèle.

Alors installons ces packages requis en utilisant pip :

$ pip3 install pandas scikit-learn fastapi uvicorn

Vous pouvez retrouver tout le code de ce tutoriel sur GitHub.

Construire un modèle d'apprentissage automatique

Nous allons maintenant former un modèle de régression linéaire à l'aide de l'ensemble de données California Housing intégré à scikit-learn. Ce modèle prédira les prix des logements en fonction des caractéristiques sélectionnées. Dans le répertoire du projet, créez un fichier appelé model_training.py :

# model_training.py
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import pickle
import os

# Load the dataset
data = fetch_california_housing(as_frame=True)
df = data['data']
target = data['target']

# Select a few features
selected_features = ['MedInc', 'AveRooms', 'AveOccup']
X = df[selected_features]
y = target

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the Linear Regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Create a 'model' folder to save the trained model
os.makedirs('model', exist_ok=True)

# Save the trained model using pickle
with open('model/linear_regression_model.pkl', 'wb') as f:
	pickle.dump(model, f)

print("Model trained and saved successfully.")

Ce script charge l'ensemble de données sur le logement californien, sélectionne trois fonctionnalités (MedInc, AveRooms, AveOccup), entraîne un modèle de régression linéaire et l'enregistre dans le dossier model/ sous le nom linear_regression_model.pkl.

Remarque : Pour simplifier les choses, nous n'avons utilisé qu'un petit sous-ensemble de fonctionnalités. Mais vous pouvez essayer d’en ajouter davantage.

Exécutez le script pour entraîner le modèle et enregistrez-le :

$ python3 model_training.py

Vous recevrez le message suivant et devriez pouvoir trouver le fichier .pkl dans le répertoire model/ :

Model trained and saved successfully.

Création de l'application FastAPI

Nous allons maintenant créer une API qui sert des prédictions à l'aide de FastAPI.

Dans le dossier app/, créez deux fichiers : __init__.py (vide) et main.py. Nous faisons cela parce que nous aimerions ensuite conteneuriser l'application FastAPI à l'aide de Docker.

Dans main.py, écrivez le code suivant :

# app/main.py
from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import os

# Define the input data schema using Pydantic
class InputData(BaseModel):
    MedInc: float
    AveRooms: float
    AveOccup: float

# Initialize FastAPI app
app = FastAPI(title="House Price Prediction API")

# Load the model during startup
model_path = os.path.join("model", "linear_regression_model.pkl")
with open(model_path, 'rb') as f:
    model = pickle.load(f)

@app.post("/predict")
def predict(data: InputData):
    # Prepare the data for prediction
    input_features = [[data.MedInc, data.AveRooms, data.AveOccup]]
    
    # Make prediction using the loaded model
    prediction = model.predict(input_features)
    
    # Return the prediction result
    return {"predicted_house_price": prediction[0]}

Cette application FastAPI expose un point de terminaison /predict qui prend trois fonctionnalités (MedInc, AveRooms, AveOccup). Il utilise le modèle entraîné pour prédire les prix de l'immobilier et renvoie le prix prédit.

Conteneuriser l'application avec Docker

Conteneurisons maintenant notre application FastAPI. Dans le répertoire racine du projet, créez un Dockerfile et un fichier requirements.txt.

Création du fichier Docker

Créons un Dockerfile :

# Use Python 3.11 as the base image
FROM python:3.11-slim

# Set the working directory inside the container
WORKDIR /code

# Copy the requirements file
COPY ./requirements.txt /code/requirements.txt

# Install the Python dependencies
RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

# Copy the app folder into the container
COPY ./app /code/app

# Copy the model directory (with the saved model file) into the container
COPY ./model /code/model

# Expose port 80 for FastAPI
EXPOSE 80

# Command to run the FastAPI app with Uvicorn
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

Cela crée un conteneur léger pour une application FastAPI utilisant Python 3.11 (version slim) comme image de base. Il définit le répertoire de travail sur /code, copie le fichier requirements.txt dans le conteneur et installe les dépendances Python nécessaires sans mise en cache.

L'application FastAPI et les fichiers de modèle sont ensuite copiés dans le conteneur. Le port 80 est exposé pour l'application et Uvicorn est utilisé pour exécuter l'application FastAPI. Cela rend l'API accessible au port 80. Cette configuration est efficace pour déployer une application FastAPI dans un environnement conteneurisé.

Création du fichier exigences.txt

Créez un fichier requirements.txt répertoriant toutes les dépendances :

fastapi
uvicorn
scikit-learn
pandas

Construire l'image Docker

Maintenant que nous avons le fichier Dockerfile, les exigences.txt et l'application FastAPI prêts, créons une image Docker et exécutons le conteneur.

Créez l'image Docker en exécutant la commande docker build suivante :

$ docker build -t house-price-prediction-api .

Exécutez ensuite le conteneur Docker :

$ docker run -d -p 80:80 house-price-prediction-api

Votre API devrait maintenant être exécutée et accessible sur http://127.0.0.1:80.

Vous pouvez utiliser curl ou Postman pour tester le point de terminaison /predict en envoyant une requête POST. Voici un exemple de demande :

curl -X 'POST' \
  'http://127.0.0.1:80/predict' \
  -H 'Content-Type: application/json' \
  -d '{
  "MedInc": 3.5,
  "AveRooms": 5.0,
  "AveOccup": 2.0
}'

Cela devrait renvoyer une réponse avec le prix de l'immobilier prévu, comme ceci :

{
  "predicted_house_price": 2.3248705765077062
}

Balisage et transfert de l'image Docker vers Docker Hub

Après avoir créé l'image Docker, exécuté le conteneur et l'avoir testé. Vous pouvez désormais le transférer vers Docker Hub pour un partage et un déploiement plus faciles sur les plateformes cloud.

Tout d’abord, connectez-vous à Docker Hub :

$ docker login

Vous serez invité à saisir les informations d’identification.

Marquez l'image Docker :

$ docker tag house-price-prediction-api your_username/house-price-prediction-api:v1

Remplacez your_username par votre nom d'utilisateur Docker Hub.

Remarque : Il est également judicieux d'ajouter des versions à vos fichiers de modèle. Lorsque vous mettez à jour le modèle, vous pouvez reconstruire l'image avec une nouvelle balise et transférer l'image mise à jour vers Docker Hub.

Transférez l'image vers Docker Hub :

$ docker push your_username/house-price-prediction-api:v1

D'autres développeurs peuvent désormais extraire et exécuter l'image comme ceci :

$ docker pull your_username/house-price-prediction-api:v1
$ docker run -d -p 80:80 your_username/house-price-prediction-api:v1

Toute personne ayant accès à votre référentiel Docker Hub peut désormais extraire l'image et exécuter le conteneur.

Récapitulatif et prochaines étapes

Voici un bref aperçu de ce que nous avons fait dans ce didacticiel :

  • Former un modèle d'apprentissage automatique à l'aide de scikit-learn
  • Créez une application FastAPI pour servir des prédictions
  • Conteneuriser l'application avec Docker

Nous avons également envisagé de transférer l'image Docker vers Docker Hub pour une distribution plus facile. La prochaine étape logique consiste à déployer cette application conteneurisée sur le cloud.

Et pour cela, vous pouvez utiliser des services comme AWS ECS, GCP ou Azure pour déployer l'API dans un environnement de production. Faites-nous savoir si vous souhaitez un didacticiel sur le déploiement de modèles d'apprentissage automatique dans le cloud.

Bon déploiement !

Références et lectures complémentaires

  • Tutoriel FastAPI : Créez des API avec Python en quelques minutes
  • Conteneurisez des applications Python avec Docker en 5 étapes faciles
  • FastAPI dans les conteneurs

Articles connexes