Chargement et utilisation du modèle IA (Flask)

Dans Flask, lorsqu’on veut intégrer de l’IA (machine learning ou deep learning) :

Chargement du modèle : consiste à récupérer un modèle pré-entraîné depuis un fichier ou une API.
Utilisation du modèle : consiste à envoyer des données à ce modèle pour obtenir une prédiction ou un résultat.

Le modèle devient alors un outil utilisé par les endpoints pour répondre aux requêtes des clients.

Comment ça fonctionne ?

Charger le modèle au démarrage de l’application Flask pour éviter de le recharger à chaque requête (gain de performance).
- Ex. : model = joblib.load('mon_modele.pkl') pour un modèle scikit-learn.
- Ex. : model = torch.load('mon_modele.pt') pour PyTorch.
Recevoir des données via une route (endpoint) Flask.
Traiter les données pour les mettre dans le format attendu par le modèle.
Faire une prédiction en appelant le modèle sur ces données.
Retourner la réponse avec le résultat de la prédiction (JSON, code HTTP, etc.).

Exemple conceptuel

URL : /predict/
View Python (endpoint) : reçoit des données clients, les prépare et les passe au modèle.
Méthode HTTP : POST
Réponse : JSON avec la prédiction et éventuellement la confiance ou le score associé.

Bonnes pratiques

Charger le modèle une seule fois au démarrage de Flask, pas à chaque requête.
Valider et nettoyer les données entrantes avant de les passer au modèle.
Gérer les exceptions du modèle pour éviter que Flask plante.
Retourner des résultats clairs : valeur prédite, score/confidence, code HTTP.
Versionner le modèle pour faciliter les mises à jour sans casser l’API.

Pourquoi c’est important

Permet de créer une API prédictive fiable et rapide.
Les clients peuvent utiliser l’IA sans connaître les détails techniques du modèle.
Facilite le débogage et la maintenance : on sait exactement où le modèle est utilisé et comment.

En résumé :

Le modèle IA est chargé une fois et utilisé par les endpoints.
Les routes reçoivent les données, les préparent et les passent au modèle.
La réponse est structurée (JSON + code HTTP).
La bonne gestion des données et du modèle rend l’API stable et performante.

Fonctions :

Chargement et utilisation d'un modèle IA avec Flask (exemple)

Exemple de code :

from flask import Flask, request, jsonify
import joblib  # pour charger un modèle sauvegardé avec scikit-learn
import numpy as np

app = Flask(__name__)

# 1️⃣ Chargement du modèle (entraîné et sauvegardé au préalable)
# Exemple : modèle entraîné avec sklearn et sauvegardé via joblib.dump(model, "model.pkl")
model = joblib.load("model.pkl")

# 2️⃣ Route d’accueil
@app.route("/")
def home():
    return "API Flask - Utilisation d'un modèle IA pour prédire"


# 3️⃣ Route pour faire une prédiction
@app.route("/predict", methods=["POST"])
def predict():
    try:
        # Récupération des données envoyées en JSON
        data = request.get_json()

        # On attend une liste de features numériques, ex: {"features": [5.1, 3.5, 1.4, 0.2]}
        features = np.array(data["features"]).reshape(1, -1)

        # Utilisation du modèle pour prédire
        prediction = model.predict(features)

        # Retour de la prédiction au client
        return jsonify({
            "input": data["features"],
            "prediction": prediction.tolist()
        })

    except Exception as e:
        return jsonify({"error": str(e)}), 400


if __name__ == "__main__":
    app.run(debug=True)

Explication du code :

from flask import Flask, request, jsonify importe la classe Flask pour créer l’application web, request pour accéder aux données envoyées par le client (ici en JSON), et jsonify pour renvoyer facilement une réponse au format JSON.
 import joblib permet de charger un modèle sauvegardé avec scikit-learn.
 import numpy as np sert à manipuler les données numériques avant de les donner au modèle.
 app = Flask(__name__) crée une instance de l’application Flask.
1️⃣ Chargement du modèle
 model = joblib.load("model.pkl") charge un modèle préalablement entraîné et sauvegardé dans le fichier model.pkl.
 Ce modèle peut être un classifieur, une régression ou tout autre algorithme de scikit-learn.
2️⃣ Route d’accueil
 @app.route("/") définit une route simple qui renvoie un message d’accueil.
 La fonction home() retourne une chaîne de caractères indiquant que l’API est prête à être utilisée.
3️⃣ Route de prédiction
 @app.route("/predict", methods=["POST"]) définit une route qui accepte uniquement des requêtes POST (envoi de données par le client).
 La fonction predict() fait les étapes suivantes :
  data = request.get_json() récupère les données envoyées en JSON.
 On suppose que ces données contiennent une liste de features, par exemple {"features": [5.1, 3.5, 1.4, 0.2]}.
 features = np.array(data["features"]).reshape(1, -1) transforme cette liste en un tableau NumPy au bon format pour le modèle.
 prediction = model.predict(features) exécute la prédiction du modèle.
 return jsonify({...}) renvoie la prédiction au format JSON, avec l’entrée et la sortie.
 
 Si une erreur survient (par exemple si la clé features est absente ou mal formatée), le bloc except renvoie une réponse JSON avec un message d’erreur et un code 400 Bad Request.
4️⃣ Lancer l’application Flask
 if __name__ == "__main__": vérifie que le fichier est exécuté directement.
 app.run(debug=True) lance le serveur Flask en mode debug, accessible sur http://127.0.0.1:5000/. Le mode debug permet d’afficher les erreurs et de recharger automatiquement le serveur lors des modifications du code.