Comment déployer un modèle d’apprentissage automatique ?

Ces dernières années, l’apprentissage automatique et l’intelligence artificielle ont gagné en popularité. Cela est probablement dû aux progrès réalisés dans le domaine du traitement du langage naturel et des systèmes de recommandation.

Cet article présente l’apprentissage automatique, ses applications, les options de déploiement et montre comment déployer un modèle simple d’apprentissage automatique dans les conteneurs Back4app.

Qu’est-ce que l’apprentissage automatique ?

L’apprentissage automatique est un sous-domaine de l’intelligence artificielle. Il s’appuie sur des algorithmes statistiques pour apprendre à partir de données et faire des prédictions sur de nouvelles données inédites.

En d’autres termes, elle donne aux ordinateurs la capacité d’apprendre sans être explicitement programmés.

Bien que l’apprentissage automatique et l’intelligence artificielle soient souvent utilisés de manière interchangeable, il ne s’agit pas de la même chose.

L’apprentissage automatique se concentre sur les algorithmes et les structures de données, tandis que l’intelligence artificielle est une tentative générale de créer des machines capables de penser comme des humains.

Les techniques typiques d’apprentissage automatique sont la régression (prédiction d’une valeur continue, par exemple le prix d’un logement) et la classification (prédiction d’une classe à partir d’un ensemble fini de classes, par exemple le genre d’un film).

D’une manière générale, nous pouvons diviser l’apprentissage automatique en trois types :

• Apprentissage supervisé: les algorithmes apprennent à l’aide d’un ensemble de données étiquetées. Chaque exemple de l’ensemble de données contient une étiquette (ou ce que l’on appelle une variable cible). L’algorithme s’en sert pour prédire les étiquettes des exemples non vus. Les algorithmes d’apprentissage supervisé comprennent les kNN, decision trees, etc.

• Apprentissage non supervisé: les algorithmes apprennent sans aucune orientation explicite. C’est à l’algorithme de trouver des modèles dans les données et de faire des prédictions sur cette base. Un exemple d’algorithme est le regroupement par k-means.

• Apprentissage par renforcement: les algorithmes apprennent par essais et erreurs. Ils sont généralement basés sur la récompense et l’objectif de l’algorithme est de maximiser la récompense. Exemple : algorithmes génétiques.

Dans la partie pratique de l’article, nous allons suivre un processus typique de construction de modèle. Nous allons résoudre une tâche de classification en utilisant l’apprentissage supervisé.

Applications de l’apprentissage automatique

Voyons quelques applications réelles de l’apprentissage automatique !

Systèmes de recommandation

Les systèmes de recommandation suggèrent les éléments (films, produits, etc.) qu’un utilisateur devrait consommer. Ces systèmes peuvent être basés sur le contenu ou sur la collaboration.

De nos jours, les systèmes de recommandation sont utilisés par presque toutes les entreprises. Ils permettent aux entreprises d’accroître leur succès commercial, de créer une demande supplémentaire, d’augmenter l’engagement des utilisateurs, d’apprendre à connaître les clients, et bien plus encore.

Netflix, par exemple, les utilise pour recommander des films, Spotify pour recommander des chansons et YouTube pour suggérer des vidéos à regarder en fonction de vos centres d’intérêt.

Traitement du langage naturel (NLP)

Le traitement du langage naturel (NLP) permet aux ordinateurs de traiter et de comprendre le langage humain. La génération de langage naturel (NLG) permet aux ordinateurs de générer du langage humain.

Cette technologie est utilisée par les chatbots, les outils de traduction linguistique, les outils d’analyse des sentiments, etc. ChatGPT est l’un des exemples les plus célèbres qui exploitent le NLP et le NLG.

Vous voulez en savoir plus sur ChatGPT ? Consultez notre autre article intitulé Comment créer une application en utilisant ChatGPT ?

Vision par ordinateur et reconnaissance d’images

La vision par ordinateur donne aux ordinateurs la capacité de “voir” et de “comprendre” les images et les vidéos. Elle leur permet d’effectuer une segmentation (en temps réel), de reconnaître des objets, des visages et même des émotions.

C’est la technologie utilisée par les applications photo pour étiqueter automatiquement vos amis. Elle est également utilisée par les systèmes de surveillance pour détecter les comportements suspects.

Détection de la fraude

Les entreprises utilisent l’apprentissage automatique pour détecter les activités suspectes dans les transactions ou le comportement des utilisateurs. Ces systèmes peuvent détecter des actes potentiellement frauduleux en étudiant les tendances et les anomalies, protégeant ainsi les entreprises et les clients contre la fraude et la cybercriminalité.

Voitures auto-conduites

La conduite automobile autonome est l’un des problèmes d’apprentissage automatique les plus complexes. Elle combine plusieurs applications telles que la vision par ordinateur, la détection d’anomalies, la prédiction du comportement, la planification de la trajectoire, etc.

À l’heure où nous écrivons ces lignes, nous sommes loin des voitures entièrement autonomes. Les voitures “auto-conduites” actuelles ne fonctionnent bien que dans des zones géographiques restreintes.

Options de déploiement de l’apprentissage automatique

Pour déployer un modèle d’apprentissage automatique, vous le diffusez généralement à partir d’une application web. Par conséquent, les options de déploiement des modèles d’apprentissage automatique sont pratiquement les mêmes que pour les applications web. Examinons-les !

Sur place

Le déploiement sur site implique l’hébergement et la gestion des équipements informatiques, tels que les serveurs et les dispositifs de stockage, dans les locaux mêmes de l’entreprise.

Cette stratégie traditionnelle nécessite un investissement initial considérable en matériel et en logiciels, ainsi qu’une maintenance et une assistance permanentes.

Ses avantages sont un niveau de contrôle et de sécurité plus élevé et une personnalisation plus accessible. En revanche, les inconvénients sont le coût, l’évolutivité et la maintenance.

Nuage

En revanche, le déploiement en nuage fait appel à des services tiers pour héberger l’infrastructure et les applications via l’internet.

Ce modèle permet aux utilisateurs de payer au fur et à mesure pour des ressources et des services évolutifs, dont les fournisseurs de services en nuage s’occupent.

Ses avantages sont l’évolutivité, la facilité d’utilisation et l’absence de coût initial. En revanche, les inconvénients sont un niveau de contrôle plus faible, une flexibilité moindre et un éventuel verrouillage du fournisseur.

Voici quelques exemples de plateformes basées sur l’informatique en nuage :

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform (GCP)
• Microsoft Azure

Algorithmes populaires d’apprentissage automatique

Les algorithmes d’apprentissage automatique les plus répandus sont les suivants :

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

Dans l’exemple pratique, nous utiliserons les k-voisins les plus proches.

Comment déployer un modèle d’apprentissage automatique ?

Dans cette section de l’article, nous allons construire un modèle d’apprentissage automatique, le servir avec FastAPI, le dockeriser, et enfin le déployer sur Back4app Containers.

Conditions préalables

• Connaissance de base de l’apprentissage automatique
• Expérience avec Python et FastAPI
• Compréhension de base de Docker et de la technologie de conteneurisation
• Git et Docker Desktop installés sur votre machine locale

Aperçu du projet

Avant de montrer comment déployer un modèle d’apprentissage automatique, nous allons en construire un. Nous allons créer un simple classificateur kNN en utilisant le populaire jeu de données Iris. L’objectif du modèle est de prédire si une observation est “setosa”, “versicolor” ou “virginica” en fonction de différentes caractéristiques.

Nous allons ensuite sauvegarder le modèle dans un fichier, le charger dans FastAPI et le servir via un endpoint. Après cela, nous allons dockeriser l’application, la pousser sur GitHub, et la déployer sur Back4app Containers.

Créer un modèle

Pour créer le modèle, nous utiliserons les Jupyter Notebooks. Vous pouvez installer Jupyter sur votre machine locale ou utiliser Google Colab gratuitement.

Créez d’abord un nouveau carnet Jupyter.

Chaque bloc de code dans cette section de l’article représente une cellule Jupyter. Vous pouvez les créer à partir du menu ou en utilisant le raccourci clavier “B” (en mode commande).

N’oubliez pas non plus de les exécuter (soit à partir du menu, soit en utilisant “ALT + ENTER”).

Ajoutez les importations suivantes dans la première cellule :

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Charger l’ensemble de données

L’ensemble de données Iris est inclus par défaut dans Scikit-learn. Il suffit d’appeler la fonction load_iris() et de transformer l’objet en un cadre.

Créer une nouvelle cellule :

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Lorsque vous chargez l’ensemble de données Iris, il est classé en fonction de la variable cible. Ce n’est pas une bonne chose car notre modèle d’apprentissage automatique pourrait ne voir que certains types d’exemples dans la phase d’apprentissage. Par exemple, seulement “setosa” et “versicolour”.

Pour éviter ce problème, nous pouvons le mélanger :

df = df.sample(frac=1, random_state=42)

L’attribut random_state est utilisé à des fins de reproductibilité. Vous pouvez utiliser le nombre de votre choix.

Explorer l’ensemble de données

Avant de créer un modèle, il est bon d’explorer les données auxquelles vous avez affaire. Pour ce faire, vous pouvez utiliser les fonctions Pandas intégrées, telles que head(), describe(), etc.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

En outre, vous devez visualiser l’ensemble de données pour déterminer quelles caractéristiques séparent le mieux les exemples et quel algorithme d’apprentissage automatique pourrait être utile pour votre problème.

L’image ci-dessus a été empruntée à l’article Guide to Data Visualization with Python. Ne manquez pas de le consulter pour en savoir plus sur la visualisation des données.

L’image montre que les points “rouges” sont linéairement séparables des deux autres. Les points “bleus” et “verts”, en revanche, ne sont pas linéairement séparables.

Ensemble de données fractionné

Définissons les caractéristiques (prédicteurs) et la variable cible :

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

Puis les extraire en X (données de caractéristiques) et en y (données de variables cibles) et les tester, les former et les diviser :

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

En utilisant test_size=0.25, 25% de l’ensemble de données est utilisé pour le test, tandis que 75% est utilisé pour la formation.

Construire un modèle

Ensuite, créez un pipeline qui met d’abord les données à l’échelle, puis utilise le classificateur kNN :

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

Pour savoir pourquoi la mise à l’échelle est essentielle, consultez cet article.

Utilisez ensuite la validation croisée 10 fois et vérifiez l’erreur de validation :

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Évaluer le modèle sur l’ensemble de tests :

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

La précision de la validation et celle du test sont à peu près égales. Cela indique que notre modèle n’est ni sous-adapté ni suradapté.

Sauvegarder le modèle

Enfin, réentraînez le modèle en utilisant toutes les données et enregistrez-le dans le fichier model.pkl:

knn.fit(X, y)
dump(knn, "model.pkl")

Si vous avez utilisé Google Colab, téléchargez le fichier model.pk car nous en aurons besoin à l’étape suivante.

Modèle de service

Comme indiqué précédemment, nous utiliserons FastAPI pour servir le modèle.

Créez un nouveau projet FastAPI et remplacez main.py comme suit :

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Démarrer le serveur de développement :

$ uvicorn app.main:app --reload

Naviguez jusqu’à http://localhost:8000/, et vous devriez obtenir la réponse suivante :

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Modèle de charge

Ensuite, chargeons le modèle et définissons les classes de modèle.

Copiez d’abord model.pkl de l’étape précédente à la racine de votre projet. Ensuite, chargez le modèle et définissez les classes juste sous l’initialisation de l’application FastAPI comme suit :

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Nous utiliserons model_classes pour traduire la variable cible de numérique en texte.

Modèle de charge

Créez ensuite le point de terminaison /predict, qui prend en compte les caractéristiques et utilise le modèle chargé pour faire une prédiction :

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

Le point d’arrivée renvoie la prédiction numérique ainsi qu’une prédiction de test conviviale.

N’oubliez pas les importations en tête de fichier :

from joblib import load
from pydantic import BaseModel

Votre fichier main.py final devrait ressembler à ceci.

Redémarrez le serveur de développement et accédez à http://localhost:8000/docs dans votre navigateur web préféré. FastAPI génère automatiquement une documentation interactive pour tous vos points de terminaison.

Testez le modèle en soumettant une demande comme celle-ci :

Super, notre application web est maintenant pleinement opérationnelle !

Dockerize App

Dans cette section de l’article, nous allons dockeriser l’application web. Nous allons créer un fichier Docker et configurer le fichier .dockerignore.

Fichier Docker

Un Dockerfile est un fichier qui contient des instructions que Docker Engine doit suivre pour construire l’image.

Il s’agit généralement de transférer des fichiers, de définir l’image de base, de configurer le répertoire de travail, d’exécuter des commandes personnalisées, etc.

Les commandes Dockerfile sont généralement écrites en lettres capitales et sont directement suivies de leurs arguments correspondants.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Visitez la référence Dockerfile pour en savoir plus sur toutes les instructions.

Dans la racine du projet, créez un fichier Docker:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

Lorsque vous travaillez avec Docker, vous souhaitez créer des images aussi petites que possible.

Une façon de réduire la taille de l’image est d’utiliser un fichier .dockerignore. Ce fichier fonctionne de la même manière qu’un fichier .gitignore. Il vous permet d’omettre les fichiers qui n’ont pas besoin d’être inclus dans l’image.

À la racine du projet, créez un fichier .dockerignore:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

Veillez à adapter le fichier .dockerignore en fonction des exigences de votre projet (par exemple, si vous utilisez un IDE différent).

Construire, exécuter, tester

Avant de transférer l’image dans le nuage, il est conseillé de la tester localement.

Pour suivre, vous aurez besoin de Docker Desktop installé sur votre machine.

Ouvrez le terminal et vérifiez les images actuellement installées :

$ docker images

Ensuite, construisez l’image en utilisant le fichier Docker:

$ docker build -t iris-webapp:1.0 .

Il faudra un certain temps à Docker pour construire l’image. Ceci est principalement dû au fait que Scikit-learn n’est pas optimisé pour les conteneurs Docker. N’hésitez pas à faire une petite pause café.

Une fois la commande terminée, vérifiez à nouveau les images. L’image nouvellement construite devrait s’y trouver.

Enfin, utilisez l’image pour créer un nouveau conteneur :

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

C’est tout !

Votre application web est maintenant conteneurisée. Elle devrait être accessible à l’adresse http://localhost:8000/ et fonctionner de la même manière qu’auparavant.

Pousser vers GitHub

Tout d’abord, naviguez sur GitHub et créez un nouveau dépôt. Prenez note de l’URL distante car nous en aurons besoin dans une étape ultérieure.

Retournez ensuite à la racine de votre projet.

Avant de transférer le code source dans le nuage, créez un fichier .gitignore. Un fichier .gitignore vous permet de spécifier quels fichiers et répertoires doivent être omis du contrôle de version.

Ce type de fichier fonctionne de la même manière que les fichiers .dockerignore.

À la racine du projet, créez un fichier .gitignore:

#.dockerignore

.idea/
__pycache__/
venv/

Ouvrez le terminal et exécutez la commande suivante pour initialiser Git :

$ git init

Ajouter tous les fichiers au VCS et les livrer :

$ git add .
$ git commit -m "first commit"

Enfin, ajoutez l’origine GitHub distante en utilisant l’URL précédente et poussez le code source :

$ git remote add origin <remote_url>
$ git push origin master

Veillez à ce que l’URL distante de l’étape précédente soit utilisée à la place de .

Voilà, c’est fait. Si vous visitez maintenant la page du dépôt GitHub, vous devriez voir que tous les fichiers ont été ajoutés.

Déployer l’application

Pour déployer une application sur Back4app Containers, vous devez d’abord vous enregistrer ou vous connecter (si vous avez déjà un compte).

Lorsque vous vous authentifiez avec votre compte Back4app, vous accédez au tableau de bord de votre application. Pour créer une nouvelle application, cliquez sur “Créer une nouvelle application”.

Back4app permet le déploiement de Backend as a Service et de Containers as a Service. Puisque nous déployons une application conteneurisée, nous choisirons cette dernière option.

Ensuite, vous devez connecter votre compte GitHub à Back4app. Cela permettra à Back4app d’extraire le code source de vos dépôts. Vous pouvez autoriser l’accès à tous les dépôts ou à certains d’entre eux.

Une fois les référentiels importés, cliquez sur “Sélectionner”.

Il n’est pas nécessaire de configurer l’environnement, si ce n’est pour fournir un nom d’application descriptif.

Cliquez ensuite sur “Créer”.

Back4app va avoir besoin de quelques minutes pour construire l’image, l’envoyer au registre des conteneurs, et démarrer un conteneur. Une fois le déploiement terminé, le statut de votre application devrait passer à “Prêt”.

Pour visiter votre application, cliquez sur l’URL comme indiqué dans l’image ci-dessous.

Vous avez déployé avec succès un modèle d’apprentissage automatique dans les conteneurs Back4app. L’application web devrait fonctionner de la même manière qu’en local. Assurez-vous de tester l’application une fois de plus.

Résumé

Dans cet article, vous avez appris les bases de l’apprentissage automatique, ses applications et comment déployer un modèle d’apprentissage automatique.

Vous devriez maintenant être en mesure de créer vos propres modèles simples, de les servir avec FastAPI et de les déployer dans les conteneurs Back4app.

Téléchargez le code source final depuis le dépôt GitHub de back4app-deploy-ml-model.