FastApi_v2

Manage both scikit-learn and transformers models

Dockerfile

@@ -2,15 +2,19 @@ FROM python:3.10
 
 WORKDIR /home/app
 
-RUN apt-get update -y 
-RUN apt-get install nano unzip -y
-RUN apt install curl -y
+RUN apt-get update -y && \
+    apt-get install -y nano unzip libgl1 curl && \
+    rm -rf /var/lib/apt/lists/*
 
 RUN curl -fsSL https://get.deta.dev/cli.sh | sh
 
+RUN useradd -m appuser
+
 COPY requirements.txt /dependencies/requirements.txt
 RUN pip install -r /dependencies/requirements.txt
 
 COPY . /home/app
 
+USER appuser
+
 CMD gunicorn app:app  --bind 0.0.0.0:$PORT --worker-class uvicorn.workers.UvicornWorker 

app.py

@@ -1,130 +1,103 @@
 import os
-import mlflow
-import pickle
-from fastapi import FastAPI, HTTPException, status
+import uvicorn
+import pandas as pd
 from pydantic import BaseModel
+from fastapi import FastAPI, HTTPException, status
+import mlflow
 from dotenv import load_dotenv
-from typing import Optional
-import asyncio
-from contextlib import asynccontextmanager
 
-# Charge les variables d'environnement
-load_dotenv()
+description = """
+# [Détection des fausses informations sur le réchauffement climatique]
 
-# Configuration des variables d'environnement
-MLFLOW_TRACKING_APP_URI = os.getenv("MLFLOW_TRACKING_APP_URI")
-MODEL_NAME = os.getenv("MODEL_NAME")
-STAGE = os.getenv("STAGE")
+## À propos
+Les fausses informations et les contenus manipulateurs sur le climat se propagent rapidement,
+nuisant à la lutte contre le réchauffement climatique.
+Ce projet vise à automatiser la classification des articles en trois catégories : vrai, biaisé ou faux.
 
-# Configure les identifiants AWS pour accéder au bucket S3
-os.environ["AWS_ACCESS_KEY_ID"] = os.getenv("AWS_ACCESS_KEY_ID")
-os.environ["AWS_SECRET_ACCESS_KEY"] = os.getenv("AWS_SECRET_ACCESS_KEY")
+## Machine-Learning
+Where you can:
+* `/predict` : prediction for a single value
 
-# Variables globales pour stocker le modèle et le vectorizer
-model = None
-vectorizer = None
+Check out documentation for more information on each endpoint.
+"""
 
-# Fonction pour charger le modèle depuis MLflow
-def load_model():
-    global model
-    try:
-        # Configure l'URI de tracking MLflow
-        mlflow.set_tracking_uri(MLFLOW_TRACKING_APP_URI)
+tags_metadata = [
+    {
+        "name": "Predictions",
+        "description": "Endpoints that uses our Machine Learning model",
+    },
+]
 
-        # Charge le modèle depuis MLflow
-        model_uri = f"models:/{MODEL_NAME}@{STAGE}"
-        model = mlflow.sklearn.load_model(model_uri)
-        print("Modèle chargé avec succès depuis MLflow.")
-    except Exception as e:
-        print(f"Erreur lors du chargement du modèle depuis MLflow : {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Impossible de charger le modèle depuis MLflow : {e}"
-        )
-
-# Fonction pour charger le vectorizer depuis MLflow
-def load_vectorizer():
-    try:
-        # Initialise le client MLflow
-        client = mlflow.MlflowClient(MLFLOW_TRACKING_APP_URI)
-
-        # Récupère les informations sur le modèle
-        model_info = client.get_model_version_by_alias(MODEL_NAME, STAGE)
-        run_id = model_info.run_id
+load_dotenv()
 
-        # Télécharge le fichier vectorizer.pkl depuis MLflow
-        local_path = mlflow.artifacts.download_artifacts(
-            artifact_path="vectorizer.pkl",
-            run_id=run_id
-        )
+# Variables MLflow : URI de tracking, nom du modèle et stage
+MLFLOW_TRACKING_APP_URI = os.getenv("MLFLOW_TRACKING_APP_URI")
+MODEL_NAME = os.getenv("MODEL_NAME")
+STAGE = os.getenv("STAGE", "production")
 
-        # Charge le vectorizer depuis le fichier
-        with open(local_path, "rb") as f:
-            vectorizer = pickle.load(f)
+# Variables AWS pour accéder au bucket S3 qui contient les artifacts de MLflow
+os.environ["AWS_ACCESS_KEY_ID"] = os.getenv("AWS_ACCESS_KEY_ID")
+os.environ["AWS_SECRET_ACCESS_KEY"] = os.getenv("AWS_SECRET_ACCESS_KEY")
 
-        return vectorizer
-    except Exception as e:
-        print(f"Erreur lors du chargement du vectorizer : {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Impossible de charger le vectorizer : {e}"
-        )
+# Variables globales pour stocker le modèle
+mlflow.set_tracking_uri(MLFLOW_TRACKING_APP_URI)
+model_uri = f"models:/{MODEL_NAME}@{STAGE}"
 
-# Fonction asynchrone pour charger le modèle et le vectorizer
-async def load_model_and_vectorizer():
+# Chargement conditionnel du modèle
+try:
+    # Essayer de charger un modèle scikit-learn
+    model = mlflow.sklearn.load_model(model_uri)
+    print("Modèle scikit-learn chargé avec succès.")
+except mlflow.exceptions.MlflowException:
     try:
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, load_model)
-        global vectorizer
-        vectorizer = await loop.run_in_executor(None, load_vectorizer)
-        print("Modèle et vectorizer chargés avec succès.")
+        # Si échec, essayer de charger un modèle Transformers
+        model = mlflow.transformers.load_model(model_uri)
+        print("Modèle Transformers chargé avec succès.")
     except Exception as e:
-        print(f"Erreur lors du chargement : {e}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Impossible de charger le modèle ou le vectorizer : {e}"
+            detail=f"Erreur lors du chargement du modèle : {e}"
         )
 
-# Charge le modèle et le vectorizer au démarrage
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Code à exécuter au démarrage
-    await load_model_and_vectorizer()
-    yield
-
-# Initialise FastAPI
 app = FastAPI(
     title="Climate Fake News Detector API",
-    description="API pour détecter les fake news sur le climat avec un modèle XGBoost.",
-    version="1.0.0",
-    lifespan=lifespan
+    description="API pour détecter les fake news sur le climat",
+    version="1.0",
+    openapi_tags=tags_metadata,
 )
 
-# Modèle pour les données d'entrée
+@app.get("/")
+def index():
+    """
+    Renvoie un message de bienvenue sur l'API ainsi que le lien vers la documentation.
+    """
+    return "Hello world! Go to /docs to try the API."
+
 class TextInput(BaseModel):
     text: str
 
-@app.get("/")
-async def read_root():
-    return {
-        "message": "Bienvenue sur l'API Climate Fake News Detector !",
-        "documentation": "Consultez la documentation de l'API à l'adresse /docs."    
-    }
-
-@app.post("/predict")
-async def predict(input_data: TextInput):
-    global model, vectorizer
-    if model is None or vectorizer is None:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Le modèle ou le vectorizer n'est pas chargé."
-        )
+@app.post("/predict", tags=["Predictions"])
+def predict(features: TextInput):
+    """
+    Fait une prédiction sur un texte donné en utilisant le modèle chargé.
 
+    Args:
+        input_data (TextInput): Objet contenant le texte à prédire.
+
+    Returns:
+        dict: Dictionnaire contenant la prédiction (0 les articles avec un biais, 1 pour les articles faux, et 2 pour les articles fiable).
+
+    Raises:
+        HTTPException: Si une erreur survient lors de la prédiction.
+    """
     try:
-        X_vectorized = vectorizer.transform([input_data.text]).toarray()
-        prediction = model.predict(X_vectorized)
-        return {"prediction": int(prediction[0])}
-    
+        # Préparation des données pour la prédiction
+        df = pd.DataFrame({"text": [features.text]})
+
+        # Prédiction
+        prediction = model.predict(df["text"].tolist())[0]
+        return {"prediction": int(prediction)}
+
     except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
@@ -132,5 +105,4 @@ async def predict(input_data: TextInput):
         )
 
 if __name__ == "__main__":
-    import uvicorn
     uvicorn.run(app, host="localhost", port=8000)

requirements.txt

@@ -1,14 +1,16 @@
 mlflow==2.21.3
 scikit-learn==1.4.2
+transformers>=4.40.0
+torch>=2.0.0
+tokenizers>=0.15.0
 requests>=2.31.0,<3
-fastapi 
+fastapi
 uvicorn[standard]
-pydantic 
-typing 
-pandas 
-gunicorn 
-openpyxl 
+pydantic
+pandas
+gunicorn
+openpyxl
 boto3
 python-multipart
-dotenv
+python-dotenv
 xgboost