EIA - Exigences detaillees

Exigences Document de reference Avance

Apercu des exigences

Votre EIA est evaluee selon six composantes. Chaque composante a des exigences specifiques qui doivent etre satisfaites. Cette page fournit la grille d'evaluation detaillee et les listes de verification pour chacune.

A. Entrainement du modele (20 %)

Objectifs

Demontrer votre capacite a selectionner, entrainer, evaluer et serialiser des modeles d'apprentissage automatique en utilisant une methodologie structuree.

Exigences

Selection du jeu de donnees : Choisir un jeu de donnees approprie (au moins 500 echantillons, ≥ 5 caracteristiques)
Analyse exploratoire des donnees : Realiser une EDA approfondie avec des visualisations (distributions, correlations, valeurs manquantes)
Pretraitement des donnees : Gerer les valeurs manquantes, encoder les variables categorielles, normaliser/standardiser les caracteristiques
Entrainer au moins 2 modeles : Algorithmes differents (ex. : Regression logistique vs Random Forest)
evaluer avec au moins 3 metriques : Choisir des metriques appropriees pour votre type de probleme
Ajustement des hyperparametres : Tenter au moins un ajustement de base (GridSearch ou RandomizedSearch)
Serialiser le meilleur modele : Sauvegarder avec joblib, pickle ou ONNX
Documenter votre methodologie : Justifier chaque decision dans votre notebook et votre rapport

Metriques recommandees par type de probleme

Type de probleme	Metrique 1	Metrique 2	Metrique 3	Metrique 4 (bonus)
Classification binaire	Accuracy	Precision / Recall	F1-Score	AUC-ROC
Classification multiclasse	Accuracy	Macro F1-Score	Matrice de confusion	Rapport de classification
Regression	MAE	RMSE	R² Score	MAPE

Structure de code attendue

# notebooks/02_model_training.ipynb

# 1. Load and explore data
import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv("data/dataset.csv")
X = df.drop(columns=["target"])
y = df["target"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 2. Train Model A
from sklearn.linear_model import LogisticRegression
model_a = LogisticRegression(max_iter=1000)
model_a.fit(X_train, y_train)

# 3. Train Model B
from sklearn.ensemble import RandomForestClassifier
model_b = RandomForestClassifier(n_estimators=100, random_state=42)
model_b.fit(X_train, y_train)

# 4. Evaluate both models
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score

results = {
    "Model": ["Logistic Regression", "Random Forest"],
    "Accuracy": [accuracy_score(y_test, model_a.predict(X_test)),
                 accuracy_score(y_test, model_b.predict(X_test))],
    "F1-Score": [f1_score(y_test, model_a.predict(X_test)),
                 f1_score(y_test, model_b.predict(X_test))],
    "AUC-ROC": [roc_auc_score(y_test, model_a.predict_proba(X_test)[:, 1]),
                roc_auc_score(y_test, model_b.predict_proba(X_test)[:, 1])]
}
pd.DataFrame(results)

# 5. Serialize best model
import joblib
joblib.dump(model_b, "models/best_model.pkl")

Grille d'evaluation — Entrainement du modele

Critere	Excellent (18-20)	Bon (16-17)	Satisfaisant (14-15)	Insuffisant (< 14)
Jeu de donnees	Bien choisi, pertinent, correctement justifie	Jeu de donnees approprie	Le jeu de donnees convient mais est mal justifie	Jeu de donnees inapproprie ou trop petit
EDA	Analyse approfondie avec ≥ 5 visualisations, observations documentees	Bonne EDA avec 3-4 visualisations	EDA de base, peu de visualisations	Pas d'EDA ou exploration minimale
Pretraitement	Toutes les etapes justifiees, pipeline documente	La plupart des etapes presentes	Pretraitement de base uniquement	etapes de pretraitement critiques manquantes
Modeles	≥ 3 modeles compares, ajustement des hyperparametres effectue	2 modeles compares avec ajustement de base	2 modeles entraines, pas d'ajustement	1 seul modele, pas de comparaison
Metriques	≥ 4 metriques, interpretation correcte, tableau comparatif	3 metriques avec interpretation	3 metriques rapportees, interpretation minimale	< 3 metriques ou metriques incorrectes
Serialisation	Modele sauvegarde avec metadonnees (version, metriques, caracteristiques)	Modele sauvegarde correctement	Modele sauvegarde mais sans metadonnees	Modele non serialise
Methodologie	Narration claire, chaque decision justifiee	La plupart des decisions expliquees	Quelques explications fournies	Aucune documentation de la methodologie

B. Service API (25 %)

Objectifs

Construire une API REST prete pour la production qui sert des predictions a partir de votre modele entraine, avec une validation des entrees, une gestion des erreurs et une documentation auto-generee appropriees.

Exigences

Framework : Utiliser FastAPI (recommande) ou Flask
Endpoint /predict (POST) : Accepter les caracteristiques en entree, retourner la prediction et la confiance
Endpoint /health (GET) : Retourner l'etat de sante du service
Endpoint /model-info (GET) : Retourner les metadonnees du modele (nom, version, caracteristiques, metriques)
Validation des entrees : Utiliser des modeles Pydantic (FastAPI) ou une validation manuelle (Flask)
Gestion des erreurs : Retourner les codes de statut HTTP appropries (400, 404, 422, 500) avec des messages descriptifs
Documentation Swagger : Auto-generee et accessible a /docs
Code propre : Fonctions documentees, nommage coherent, pas de valeurs en dur

Specifications des endpoints API

Endpoint	Methode	Entree	Sortie	Codes de statut
`/predict`	POST	JSON avec les valeurs des caracteristiques	`[ prediction, confidence, model_version ]`	200, 400, 422, 500
`/health`	GET	Aucune	`[ status: "healthy", timestamp ]`	200
`/model-info`	GET	Aucune	`[ model_name, version, features, metrics ]`	200
`/predict/batch`	POST	Tableau d'entrees	Tableau de predictions	200, 400, 422

Endpoint bonus

Implementer un endpoint /predict/batch pour les predictions par lot rapporte des points bonus. Cela demontre une comprehension des modeles d'API du monde reel.

Code attendu — FastAPI

# src/app.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from datetime import datetime
import joblib
import numpy as np

app = FastAPI(
    title="My ML Prediction API",
    description="LIA Project — AI Model Deployment",
    version="1.0.0"
)

model = joblib.load("models/best_model.pkl")

class PredictionInput(BaseModel):
    feature_1: float = Field(..., description="Description of feature 1")
    feature_2: float = Field(..., description="Description of feature 2")
    feature_3: float = Field(..., ge=0, description="Must be non-negative")

    class Config:
        json_schema_extra = {
            "example": {
                "feature_1": 5.1,
                "feature_2": 3.5,
                "feature_3": 1.4
            }
        }

class PredictionOutput(BaseModel):
    prediction: int
    confidence: float
    model_version: str

@app.get("/health")
def health_check():
    return {
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "model_loaded": model is not None
    }

@app.get("/model-info")
def model_info():
    return {
        "model_name": "RandomForestClassifier",
        "version": "1.0.0",
        "features": ["feature_1", "feature_2", "feature_3"],
        "training_metrics": {
            "accuracy": 0.95,
            "f1_score": 0.93,
            "auc_roc": 0.97
        }
    }

@app.post("/predict", response_model=PredictionOutput)
def predict(data: PredictionInput):
    try:
        features = np.array([[data.feature_1, data.feature_2, data.feature_3]])
        prediction = model.predict(features)[0]
        confidence = float(model.predict_proba(features).max())
        return PredictionOutput(
            prediction=int(prediction),
            confidence=round(confidence, 4),
            model_version="1.0.0"
        )
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Prediction failed: {str(e)}")

Code attendu — Alternative Flask

# src/app.py
from flask import Flask, request, jsonify
from datetime import datetime
import joblib
import numpy as np

app = Flask(__name__)
model = joblib.load("models/best_model.pkl")

@app.route("/health", methods=["GET"])
def health_check():
    return jsonify({
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "model_loaded": model is not None
    })

@app.route("/predict", methods=["POST"])
def predict():
    data = request.get_json()
    if not data:
        return jsonify({"error": "No input data provided"}), 400

    required_fields = ["feature_1", "feature_2", "feature_3"]
    for field in required_fields:
        if field not in data:
            return jsonify({"error": f"Missing field: {field}"}), 400

    try:
        features = np.array([[data["feature_1"], data["feature_2"], data["feature_3"]]])
        prediction = model.predict(features)[0]
        confidence = float(model.predict_proba(features).max())
        return jsonify({
            "prediction": int(prediction),
            "confidence": round(confidence, 4),
            "model_version": "1.0.0"
        })
    except Exception as e:
        return jsonify({"error": f"Prediction failed: {str(e)}"}), 500

Grille d'evaluation — Service API

Critere	Excellent (22-25)	Bon (20-21)	Satisfaisant (18-19)	Insuffisant (< 18)
Endpoints	Les 3 requis + endpoints bonus	Les 3 endpoints requis fonctionnent	2 des 3 endpoints fonctionnent	< 2 endpoints fonctionnels
Validation	Modeles Pydantic avec contraintes, verification de types, exemples	Validation Pydantic de base	Validation minimale	Pas de validation des entrees
Gestion des erreurs	Tous les codes d'erreur corrects, messages descriptifs, cas limites geres	La plupart des erreurs gerees correctement	Gestion des erreurs de base	Pas de gestion des erreurs
Documentation	Swagger complet avec exemples, descriptions pour tous les champs	Swagger accessible et utile	Swagger auto-genere, personnalisation minimale	Pas de documentation API
Qualite du code	Architecture propre, separation des responsabilites, docstrings	Code bien organise	Le code fonctionne mais est desordonne	Code spaghetti, valeurs en dur
Format de reponse	Structure JSON coherente, codes de statut appropries, horodatages	Reponses coherentes	Formats de reponse incoherents	Reponses cassees ou manquantes

C. Tests (15 %)

Objectifs

Demontrer votre capacite a ecrire des tests automatises qui valident votre modele et votre API, et a utiliser Postman pour les tests d'API.

Exigences

Minimum 10 tests en utilisant pytest
Tests unitaires : Tester le chargement du modele, la logique de prediction, la validation des entrees
Tests d'integration : Tester les endpoints de l'API de bout en bout
Tests de cas limites : Tester avec des entrees invalides, des donnees vides, des valeurs extremes
Couverture de code > 70 % : Mesuree avec pytest-cov
Collection Postman : Export .json avec des tests pour tous les endpoints
Documentation des tests : Expliquer ce que chaque test valide

Categories de tests

Code de test attendu

# tests/test_api.py
import pytest
from fastapi.testclient import TestClient
from src.app import app

client = TestClient(app)

# --- Health Check Tests ---

def test_health_returns_200():
    response = client.get("/health")
    assert response.status_code == 200
    assert response.json()["status"] == "healthy"

def test_health_has_timestamp():
    response = client.get("/health")
    assert "timestamp" in response.json()

# --- Model Info Tests ---

def test_model_info_returns_200():
    response = client.get("/model-info")
    assert response.status_code == 200

def test_model_info_contains_version():
    response = client.get("/model-info")
    data = response.json()
    assert "version" in data
    assert "model_name" in data
    assert "features" in data

# --- Prediction Tests ---

def test_predict_valid_input():
    payload = {"feature_1": 5.1, "feature_2": 3.5, "feature_3": 1.4}
    response = client.post("/predict", json=payload)
    assert response.status_code == 200
    data = response.json()
    assert "prediction" in data
    assert "confidence" in data

def test_predict_confidence_range():
    payload = {"feature_1": 5.1, "feature_2": 3.5, "feature_3": 1.4}
    response = client.post("/predict", json=payload)
    confidence = response.json()["confidence"]
    assert 0.0 <= confidence <= 1.0

def test_predict_missing_field_returns_422():
    payload = {"feature_1": 5.1}  # Missing features
    response = client.post("/predict", json=payload)
    assert response.status_code == 422

def test_predict_wrong_type_returns_422():
    payload = {"feature_1": "not_a_number", "feature_2": 3.5, "feature_3": 1.4}
    response = client.post("/predict", json=payload)
    assert response.status_code == 422

def test_predict_empty_body_returns_422():
    response = client.post("/predict", json={})
    assert response.status_code == 422

# --- Edge Case Tests ---

def test_predict_extreme_values():
    payload = {"feature_1": 99999.0, "feature_2": -99999.0, "feature_3": 0.0}
    response = client.post("/predict", json=payload)
    assert response.status_code in [200, 400]

Execution des tests avec couverture

# Run all tests
pytest tests/ -v

# Run with coverage report
pytest tests/ --cov=src --cov-report=term-missing

# Generate HTML coverage report
pytest tests/ --cov=src --cov-report=html

Exigences de la collection Postman

Votre collection Postman doit inclure :

Requete	Methode	Tests
Verification de sante	GET `/health`	Le statut est 200, le corps contient « healthy »
Info du modele	GET `/model-info`	Le statut est 200, le corps contient le nom du modele
Prediction valide	POST `/predict`	Le statut est 200, la reponse contient prediction et confidence
Champs manquants	POST `/predict`	Le statut est 422, message d'erreur present
Mauvais types	POST `/predict`	Le statut est 422, erreur de validation
Corps vide	POST `/predict`	Le statut est 422

Scripts de test Postman

Chaque requete Postman devrait inclure des scripts de test. Exemple :

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response has prediction", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property("prediction");
    pm.expect(jsonData).to.have.property("confidence");
});

Grille d'evaluation — Tests

Critere	Excellent (14-15)	Bon (12-13)	Satisfaisant (11)	Insuffisant (< 11)
Nombre de tests	≥ 15 tests, couverture complete	10-14 tests, bonne variete	10 tests, couverture de base	< 10 tests
Tests unitaires	Modele + validation + fonctions utilitaires testes	Modele et validation testes	Test de base du modele uniquement	Pas de tests unitaires
Tests d'integration	Tous les endpoints testes avec plusieurs scenarios	Tous les endpoints testes une fois	La plupart des endpoints testes	Peu de tests d'endpoints
Cas limites	Entrees invalides, valeurs extremes, donnees vides, mauvais types	Quelques cas limites couverts	1-2 cas limites	Pas de cas limites
Couverture	> 80 %	> 70 %	> 60 %	< 60 %
Postman	Collection complete avec scripts de test pour toutes les requetes	Collection avec tests de base	La collection existe, peu de tests	Pas de collection Postman

D. Explicabilite (15 %)

Objectifs

Appliquer des techniques d'interpretabilite des modeles pour expliquer les predictions de votre modele et renforcer la confiance dans votre systeme IA.

Exigences

Appliquer LIME et/ou SHAP a votre modele entraine
Generer au moins 3 visualisations : Importance des caracteristiques, explications individuelles, graphiques de synthese
Interpreter les resultats : Expliquer en langage simple ce que le modele apprend
Identifier les biais potentiels : Verifier si certaines caracteristiques ont une influence inattendue
Documenter les resultats : Inclure l'analyse dans votre rapport et notebook

Exigences de visualisation

#	Visualisation	Outil	Description
1	Importance globale des caracteristiques	SHAP `summary_plot` ou `bar_plot`	Quelles caracteristiques comptent le plus globalement ?
2	Explication d'une prediction individuelle	LIME `explain_instance`	Pourquoi le modele a-t-il fait cette prediction specifique ?
3	Interaction entre caracteristiques	SHAP `dependence_plot`	Comment les caracteristiques interagissent-elles ?
4	Frontiere de decision (si applicable)	LIME ou personnalise	Comment le modele separe-t-il les classes ?
5	Graphique en cascade (bonus)	SHAP `waterfall_plot`	Contribution etape par etape de chaque caracteristique

Code attendu — SHAP

# notebooks/03_explainability.ipynb
import shap
import matplotlib.pyplot as plt

explainer = shap.TreeExplainer(model)  # For tree-based models
shap_values = explainer.shap_values(X_test)

# 1. Global feature importance (summary plot)
shap.summary_plot(shap_values, X_test, show=False)
plt.title("SHAP Feature Importance — Global View")
plt.tight_layout()
plt.savefig("docs/shap_summary.png", dpi=150)
plt.show()

# 2. Single prediction explanation (waterfall)
shap.plots.waterfall(shap.Explanation(
    values=shap_values[0],
    base_values=explainer.expected_value,
    data=X_test.iloc[0],
    feature_names=X_test.columns.tolist()
))

# 3. Feature dependence plot
shap.dependence_plot("feature_1", shap_values, X_test)

Code attendu — LIME

# notebooks/03_explainability.ipynb
from lime.lime_tabular import LimeTabularExplainer

explainer = LimeTabularExplainer(
    training_data=X_train.values,
    feature_names=X_train.columns.tolist(),
    class_names=["Class 0", "Class 1"],
    mode="classification"
)

# Explain a single prediction
instance = X_test.iloc[0].values
explanation = explainer.explain_instance(
    instance,
    model.predict_proba,
    num_features=10
)

# Show explanation
explanation.show_in_notebook()

# Save as HTML
explanation.save_to_file("docs/lime_explanation.html")

Guide d'interpretation

Lorsque vous interpretez vos resultats, repondez a ces questions :

Question	Ce qu'il faut rechercher
Quelles caracteristiques sont les plus importantes ?	Caracteristiques principales dans le resume SHAP ou LIME global
Les caracteristiques importantes sont-elles logiques ?	Ont-elles un sens metier ?
Y a-t-il des surprises ?	Une importance inattendue peut indiquer une fuite de donnees
Le modele est-il biaise ?	S'appuie-t-il fortement sur des attributs sensibles ?
Quelle est la confiance du modele ?	Les predictions sont-elles de haute confiance ou incertaines ?

Fuite de donnees

Si une caracteristique a une importance disproportionnee (par ex., une seule caracteristique a une valeur SHAP 10x superieure a toutes les autres), cela peut indiquer une fuite de donnees — une variable qui ne serait pas disponible au moment de la prediction. Enquetez avant de finaliser votre modele.

Grille d'evaluation — Explicabilite

Critere	Excellent (14-15)	Bon (12-13)	Satisfaisant (11)	Insuffisant (< 11)
Methodes	LIME et SHAP appliques	Une methode appliquee en profondeur	Une methode, utilisation de base	Pas d'analyse d'explicabilite
Visualisations	≥ 5 visualisations claires et bien etiquetees	3-4 visualisations	2-3 visualisations de base	< 2 ou mal formatees
Interpretation	Analyse approfondie, implications metier, verification des biais	Bonne interpretation, quelques perspectives	Interpretation superficielle	Pas d'interpretation, juste des graphiques
Documentation	Resultats integres dans le rapport avec recommandations	Resultats mentionnes dans le rapport	Breve mention dans le rapport	Non documente

E. Documentation et rapport (10 %)

Objectifs

Produire une documentation professionnelle qui permettrait a un autre developpeur de comprendre, executer et etendre votre projet.

Exigences

README.md : Description du projet, instructions d'installation, exemples d'utilisation, reference API
Rapport technique (5-8 pages) : Suit le gabarit fourni
Documentation API : Swagger/OpenAPI accessible a /docs
Documentation du code : Docstrings pour toutes les fonctions publiques
Redaction claire : Pas de fautes d'orthographe, mise en forme coherente, structure logique

Exigences du README.md

Votre README doit inclure :

Section	Contenu
Titre du projet	Nom clair et descriptif
Description	2-3 phrases expliquant le projet
Installation	Instructions d'installation etape par etape
Utilisation	Comment demarrer l'API, exemples de requetes
Endpoints API	Tableau avec tous les endpoints
Tests	Comment executer les tests
Structure du projet	Arborescence des repertoires
Informations sur le modele	Algorithme, metriques, jeu de donnees
Auteur	Votre nom et numero d'etudiant

Structure du rapport technique

Votre rapport doit suivre le gabarit fourni dans la section Gabarit de rapport :

Section	Pages	Contenu cle
Resume executif	0,5	Vue d'ensemble de l'ensemble du projet
Definition du probleme	1	Contexte metier, jeu de donnees, objectifs
Methodologie	1-1,5	Pretraitement, selection du modele, strategie d'evaluation
Resultats	1-1,5	Metriques, comparaisons, matrices de confusion
Conception de l'API	1	Architecture, endpoints, formats de reponse
Strategie de tests	0,5	Plan de tests, couverture, resultats Postman
Explicabilite	1	Resultats LIME/SHAP, interpretation
Deploiement	0,5	Comment executer, Docker, environnement
Conclusion	0,5	Resume, lecons apprises, travaux futurs

Grille d'evaluation — Documentation et rapport

Critere	Excellent (9-10)	Bon (8)	Satisfaisant (7)	Insuffisant (< 7)
README	Complet, clair, n'importe qui peut installer le projet	La plupart des sections presentes, lacunes mineures	README de base, sections manquantes	Pas de README ou inutilisable
Structure du rapport	Toutes les sections presentes, enchainement logique	La plupart des sections, lacunes mineures	1-2 sections manquantes	Plusieurs sections manquantes
Qualite de redaction	Professionnelle, claire, concise, sans erreurs	Bonne redaction, quelques erreurs mineures	Comprehensible, quelques erreurs	Redaction mediocre, nombreuses erreurs
Profondeur technique	Analyse approfondie, decisions justifiees	Bonne profondeur, la plupart des decisions expliquees	Analyse superficielle	Pas de profondeur, juste des descriptions
Mise en forme	Coherente, tableaux, figures avec legendes	Globalement coherente	Mise en forme incoherente	Aucun effort de mise en forme

F. Presentation orale (15 %)

Objectifs

Presenter votre projet de maniere professionnelle, demontrer un systeme fonctionnel et defendre vos decisions techniques pendant la periode de questions.

Exigences

Duree : 15 minutes de presentation + 5 minutes de questions
Diaporama : 10-15 diapositives, design epure
Demo en direct : Montrer l'API fonctionnant en temps reel
Profondeur technique : Expliquer le choix du modele, les metriques, les decisions d'architecture
Preparation aux questions : etre capable de repondre a des questions sur tout aspect de votre projet

Allocation du temps de presentation

Section	Duree	Contenu
Introduction et contexte	2 min	enonce du probleme, jeu de donnees, objectifs
Entrainement du modele et resultats	3 min	Points saillants de l'EDA, comparaison des modeles, meilleur modele
Architecture de l'API	2 min	Endpoints, validation, gestion des erreurs
Demo en direct	3 min	Montrer l'API fonctionnant : health, predict, model-info
Tests et explicabilite	3 min	Resultats des tests, couverture, analyses LIME/SHAP
Conclusion et lecons	2 min	Ce que vous avez appris, ce que vous feriez differemment
Questions	5 min	Repondre aux questions de l'enseignant

Grille d'evaluation — Presentation orale

Critere	Excellent (14-15)	Bon (12-13)	Satisfaisant (11)	Insuffisant (< 11)
Contenu	Complet, bien structure, couvre toutes les composantes	Bonne couverture, lacunes mineures	Couverture adequate, details manquants	Composantes majeures manquantes
Demo	L'API fonctionne parfaitement, plusieurs requetes montrees	La demo fonctionne, problemes mineurs	La demo fonctionne partiellement	La demo echoue ou n'est pas tentee
Communication	Confiant(e), clair(e), professionnel(le), bon rythme	Bonne livraison, nervosite mineure	Livraison adequate	Peu clair, lecture des diapositives
Diapositives	Design epure, visuels informatifs, pas de murs de texte	Bonnes diapositives, problemes mineurs	Acceptables mais trop de texte	Mauvais design, trop de texte
Questions	Repond a toutes les questions avec confiance, montre une comprehension approfondie	Repond bien a la plupart des questions	Repond a certaines questions	Ne peut pas repondre aux questions de base
Gestion du temps	14-16 minutes, bien rythme	12-18 minutes, rythme globalement bon	Moins de 10 ou plus de 20 minutes	Significativement au-dessus/en dessous du temps

Voir le guide de presentation

Pour des conseils detailles de presentation, des recommandations d'allocation du temps et des questions frequentes, consultez le Guide de presentation.

Liste de verification complete de soumission

Utilisez cette liste de verification avant de soumettre votre EIA :

Code et modele

Le depot Git est propre et organise
.gitignore exclut __pycache__, .env, les fichiers volumineux
requirements.txt avec toutes les dependances (versions epinglees)
Le fichier du modele entraine est dans le repertoire models/
Le notebook d'EDA est complet et s'execute sans erreurs
Le notebook d'entrainement est complet et s'execute sans erreurs

API

L'API demarre sans erreurs (uvicorn src.app:app --reload)
/health retourne 200 avec statut et horodatage
/predict accepte une entree valide et retourne prediction + confiance
/predict retourne 422 pour une entree invalide
/model-info retourne les metadonnees du modele
La documentation Swagger est accessible a /docs

Tests

Au moins 10 tests pytest passent
Couverture de code > 70 %
Collection Postman exportee dans postman/collection.json
Les cas limites sont testes (types invalides, champs manquants, valeurs extremes)

Explicabilite

Analyse LIME et/ou SHAP completee
Au moins 3 visualisations sauvegardees
Interpretations redigees dans le notebook et le rapport

Documentation

README.md complet avec instructions d'installation
Rapport technique de 5-8 pages, suit le gabarit
Tout le code a des docstrings

Presentation

Diaporama de 10-15 diapositives
Demo en direct preparee et testee
Pratique dans la limite de 15 minutes
Prepare(e) pour les questions potentielles

Verification finale

Avant de soumettre, clonez votre depot dans un repertoire neuf et suivez vos propres instructions du README pour configurer le projet a partir de zero. Si vous ne pouvez pas l'executer, votre enseignant ne pourra pas non plus.

Apercu des exigences​

A. Entrainement du modele (20 %)​

Objectifs​

Exigences​

Metriques recommandees par type de probleme​

Structure de code attendue​

Grille d'evaluation — Entrainement du modele​

B. Service API (25 %)​

Objectifs​

Exigences​

Specifications des endpoints API​

Code attendu — FastAPI​

Code attendu — Alternative Flask​

Grille d'evaluation — Service API​

C. Tests (15 %)​

Objectifs​

Exigences​

Categories de tests​

Code de test attendu​

Execution des tests avec couverture​

Exigences de la collection Postman​

Grille d'evaluation — Tests​

D. Explicabilite (15 %)​

Objectifs​

Exigences​

Exigences de visualisation​

Code attendu — SHAP​

Code attendu — LIME​

Guide d'interpretation​

Grille d'evaluation — Explicabilite​

E. Documentation et rapport (10 %)​

Objectifs​

Exigences​

Exigences du README.md​

Structure du rapport technique​

Grille d'evaluation — Documentation et rapport​

F. Presentation orale (15 %)​

Objectifs​

Exigences​

Allocation du temps de presentation​

Grille d'evaluation — Presentation orale​

Liste de verification complete de soumission​

Code et modele​

API​

Tests​

Explicabilite​

Documentation​

Presentation​

Apercu des exigences

A. Entrainement du modele (20 %)

Objectifs

Exigences

Metriques recommandees par type de probleme

Structure de code attendue

Grille d'evaluation — Entrainement du modele

B. Service API (25 %)

Objectifs

Exigences

Specifications des endpoints API

Code attendu — FastAPI

Code attendu — Alternative Flask

Grille d'evaluation — Service API

C. Tests (15 %)

Objectifs

Exigences

Categories de tests

Code de test attendu

Execution des tests avec couverture

Exigences de la collection Postman

Grille d'evaluation — Tests

D. Explicabilite (15 %)

Objectifs

Exigences

Exigences de visualisation

Code attendu — SHAP

Code attendu — LIME

Guide d'interpretation

Grille d'evaluation — Explicabilite

E. Documentation et rapport (10 %)

Objectifs

Exigences

Exigences du README.md

Structure du rapport technique

Grille d'evaluation — Documentation et rapport

F. Presentation orale (15 %)

Objectifs

Exigences

Allocation du temps de presentation

Grille d'evaluation — Presentation orale

Liste de verification complete de soumission

Code et modele

API

Tests

Explicabilite

Documentation

Presentation