TP : Développer une API Flask pour servir
un modèle Sklearn
Modèle et du Jeu de Données Iris
Le jeu de données Iris est un jeu de données classique en apprentissage automatique,
largement utilisé pour illustrer et tester des modèles de classification. Ce jeu de données
contient des informations sur différentes fleurs d'iris, spécifiquement trois espèces : Setosa,
Versicolor, et Virginica. Le but est de prédire l'espèce d'une fleur en fonction de ses
caractéristiques physiques.
Description du Jeu de Données Iris
Le jeu de données Iris comprend 150 échantillons, répartis en trois classes, soit 50
échantillons pour chaque espèce. Les caractéristiques des fleurs sont mesurées par des quatre
attributs (ou features) :
1. Longueur du sépale (cm)
2. Largeur du sépale (cm)
3. Longueur du pétale (cm)
4. Largeur du pétale (cm)
Ces quatre caractéristiques sont les données d'entrée que l'on va utiliser pour entraîner le
modèle. En revanche, l'étiquette (ou la classe) est l'espèce de la fleur, représentée par un
nombre entier :
● 0 : Setosa
● 1 : Versicolor
● 2 : Virginica
Taille et Structure du Jeu de Données
● Nombre d'exemples : 150
● Nombre d'attributs (features) : 4 (longueur et largeur des sépales et des pétales)
● Nombre de classes : 3 (Setosa, Versicolor, Virginica)
● Type de tâche : Classification supervisée (prédire une classe à partir des
caractéristiques)
Objectif du Modèle
L'objectif principal de l'utilisation de ce jeu de données est de créer un modèle capable de
prédire l'espèce d'une fleur à partir des quatre caractéristiques mentionnées ci-dessus.
Modèle Utilisé : Random Forest (Forêt Aléatoire)
Dans le TP que nous avons suivi, nous avons utilisé le modèle RandomForestClassifier de la
bibliothèque scikit-learn pour entraîner notre modèle. Voici quelques détails sur ce modèle :
● Random Forest est un ensemble d'arbres de décision. Au lieu de se baser sur un seul
arbre de décision, ce modèle combine plusieurs arbres de décision pour améliorer la
précision et éviter le sur-apprentissage (overfitting).
● Chaque arbre de décision est construit sur un sous-ensemble aléatoire des données et
des caractéristiques, ce qui aide à améliorer la robustesse du modèle et à réduire les
biais.
Caractéristiques de Random Forest :
● Ensemble Learning : Random Forest combine plusieurs modèles simples (arbres de
décision) pour créer un modèle plus puissant.
● Robuste : Grâce à la moyenne des prédictions de plusieurs arbres, ce modèle est
moins sujet à l'overfitting.
● Facile à utiliser : Il n'est pas nécessaire de prétraiter beaucoup de données (comme la
normalisation ou la standardisation).
Entraînement du Modèle
Pour entraîner un modèle avec RandomForestClassifier sur le jeu de données Iris, voici les
étapes essentielles :
1. Chargement des données : Le jeu de données Iris est directement disponible via
[Link].load_iris().
2. Préparation des données :
○ Les données sont séparées en features (les attributs) et labels (les espèces).
3. Entraînement du modèle : Le modèle RandomForest est entraîné sur les features et
les labels du jeu de données Iris.
4. Sauvegarde du modèle : Une fois le modèle entraîné, il est souvent enregistré dans un
fichier pour pouvoir être utilisé plus tard, par exemple avec [Link]().
🎯 Objectif général du TP
L’objectif de ce TP est d’apprendre à déployer un modèle d’intelligence artificielle (Sklearn)
via une API REST avec Flask. Cela permet à d’autres applications (ou utilisateurs) d’envoyer
des données au modèle et de récupérer une prédiction automatique, par exemple dans un
site web ou une application mobile.
⚙️ Étape 1 – Création du projet et de l’environnement
virtuel
📚 Pourquoi ?
L’environnement virtuel permet d’isoler les bibliothèques utilisées dans ton projet pour ne pas
perturber les autres projets Python sur ton PC.
💡 Étapes :
1. Créer un dossier nommé project python sur le bureau.
2. Ouvrir ce dossier dans VS Code.
3. Ouvrir le terminal (Terminal > Nouveau terminal).
4. Tape :
bash
CopierModifier
python -m venv venv
5. Active l’environnement :
powershell
CopierModifier
.\venv\Scripts\activate
⚠️ Si tu obtiens une erreur "Impossible de charger le fichier" :
Tape dans PowerShell (en tant qu’admin) :
powershell
CopierModifier
Set-ExecutionPolicy RemoteSigned
Puis réessaye.
⚙️ Étape 2 – Installation des bibliothèques
📚 Pourquoi ?
On a besoin de bibliothèques pour :
● Créer un modèle IA : scikit-learn
● Le sauvegarder : joblib
● Créer l’API : flask
💡 Commande à taper dans le terminal :
bash
CopierModifier
pip install flask scikit-learn joblib requests
⚙️ Étape 3 – Entraîner et sauvegarder un modèle IA
📚 Pourquoi ?
Avant de prédire, il faut entraîner un modèle sur des données, ici on utilise l’iris (base
intégrée). Le modèle sera sauvegardé pour être utilisé dans l’API plus tard.
💻 Crée un fichier : train_model.py
python
import joblib
from [Link] import load_iris
from [Link] import RandomForestClassifier
from sklearn.model_selection import train_test_split
# Charger les données Iris (intégrées à sklearn)
iris = load_iris()
X = [Link]
y = [Link]
# Diviser les données en ensemble d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
# Entraîner un modèle Random Forest
model = RandomForestClassifier()
[Link](X_train, y_train)
# Sauvegarder le modèle entraîné dans un fichier
[Link](model, '[Link]')
print(" ✅ Modèle sauvegardé sous [Link]")
💡 Lance le script :
bash
CopierModifier
python train_model.py
Un fichier [Link] doit apparaître dans ton dossier. C’est ton modèle IA prêt à
être utilisé.
⚙️ Étape 4 – Créer une API Flask
📚 Pourquoi ?
L’API permettra à des applications externes (clients, sites web…) d’envoyer des données et de
recevoir la prédiction du modèle.
💻 Crée un fichier [Link]
python
from flask import Flask, request, jsonify
import joblib
import numpy as np
# Crée une instance de l'application Flask
app = Flask(__name__)
# Charge ton modèle Sklearn (assure-toi d'avoir un modèle sauvegardé en
tant que '[Link]')
model = [Link]('[Link]')
@[Link]('/')
def home():
return "API Flask pour prédictions Sklearn"
@[Link]('/predict', methods=['POST'])
def predict():
try:
# Récupérer les données envoyées en POST
data = request.get_json()
# Assurez-vous que les données sont sous forme de tableau
features = [Link](data['features']).reshape(1, -1)
# Faire la prédiction avec le modèle
prediction = [Link](features)
# Retourner la prédiction sous forme de JSON
return jsonify({'prediction': prediction[0]})
except Exception as e:
return jsonify({'error': str(e)}), 400
if __name__ == '__main__':
[Link](debug=False, port=5000) # Démarre le serveur sur le port 5000
⚙️ Étape 5 – Démarrer l’API
Dans le terminal :
bash
CopierModifier
python [Link]
Tu dois voir :
csharp
CopierModifier
* Running on [Link]
ÉTAPE 6 — Tester l’API Flask
🎯 Objectif de cette étape :
Tu as maintenant une API Flask qui tourne avec un modèle d’intelligence artificielle dedans.
L’objectif de cette étape est de vérifier que l’API fonctionne bien en lui envoyant des
données de test.
C’est comme dire :
« Hé API, voici les caractéristiques d'une fleur, dis-moi à quelle espèce elle
appartient ! »
Tu peux faire ça de deux manières :
✅ MÉTHODE A — Utiliser Postman (outil visuel pour tester les API)
📌 Postman, c’est quoi ?
C’est un logiciel gratuit qui permet d’envoyer des requêtes HTTP à ton API sans coder.
🧭 Étapes :
1. Télécharger Postman si tu ne l’as pas encore : 👉
[Link]
Lancer ton API avec :
python [Link]
Tu dois voir dans ton terminal :
* Running on [Link]
2.
3. Ouvre Postman, puis :
○ Méthode : POST
○ URL : [Link]
○ Clique sur l’onglet Body
■ Choisis raw
■ À droite, sélectionne JSON
Colle ce JSON :
○ Clique sur Send
🟢 Résultat attendu : Tu dois voir une réponse dans la partie inférieure, comme :