Upload folder using huggingface_hub

Dockerfile

@@ -21,17 +21,17 @@ COPY .env.example .env
 # Créer le dossier logs
 RUN mkdir -p logs
 
-# Exposer le port
-EXPOSE 8000
+# Exposer le port (7860 = Gradio par défaut sur HuggingFace Spaces)
+EXPOSE 7860
 
 # Variables d'environnement par défaut
 ENV DEBUG=false
 ENV LOG_LEVEL=INFO
 ENV API_KEY=change-me-in-production
 
-# Healthcheck
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-  CMD curl -f http://localhost:8000/health || exit 1
+# Healthcheck - vérifier que FastAPI répond sur /health
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+  CMD curl -f http://localhost:7860/health || exit 1
 
-# Commande de démarrage
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "2"]
+# Commande de démarrage - FastAPI avec Gradio monté sur /ui
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,49 +1,274 @@
----
-title: Employee Turnover Prediction API
-emoji: 👔
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: true
-license: mit
-app_port: 8000
----
+# 🚀 Employee Turnover Prediction API - v2.2.0
 
-# Employee Turnover Prediction API 🚀
+## 📊 Vue d'ensemble
 
-API de prédiction du turnover des employés avec XGBoost + SMOTE.
+API REST de prédiction du turnover des employés basée sur un modèle XGBoost avec SMOTE.
 
-## 🎯 Fonctionnalités
+**✨ Nouveautés v2.2.0** :
+- 📦 **Endpoint batch CSV** : Envoyez directement vos 3 fichiers CSV bruts
+- 🔧 Correction du preprocessing (scaling + ordre des colonnes)
+- 📊 Prédictions plus précises (~90% accuracy)
 
-- ✅ Prédiction de turnover (0 = reste, 1 = part)
-- 📊 Probabilités et niveau de risque (Low/Medium/High)
+**✨ v2.1.0** :
+- 📝 Logging structuré JSON
+- 🛡️ Rate limiting (20 req/min par IP)
+- ⚡ Gestion d'erreurs améliorée
 - 🔐 Authentification API Key
-- 📝 Logs structurés JSON
-- 🛡️ Rate limiting (20 req/min)
-- 📚 Documentation OpenAPI/Swagger
 
-## 🔗 Endpoints
+## 🏗️ Architecture
 
-- **Docs** : `/docs` - Documentation interactive
-- **Health** : `/health` - Status de l'API
-- **Predict** : `/predict` - Prédiction de turnover
+```
+OC_P5/
+├── app.py                    # Point d'entrée FastAPI
+├── src/
+│   ├── auth.py              # Authentification API Key
+│   ├── config.py            # Configuration centralisée
+│   ├── logger.py            # Logging structuré (NOUVEAU)
+│   ├── models.py            # Chargement modèle HF Hub
+│   ├── preprocessing.py     # Pipeline preprocessing
+│   ├── rate_limit.py        # Rate limiting (NOUVEAU)
+│   └── schemas.py           # Validation Pydantic
+├── tests/                   # Suite pytest (33 tests, 88% couverture)
+├── logs/                    # Logs JSON (NOUVEAU)
+│   ├── api.log              # Tous les logs
+│   └── error.log            # Erreurs uniquement
+├── docs/                    # Documentation
+├── ml_model/                # Scripts training
+└── data/                    # Données sources
+```
+
+## 🚀 Installation
 
-## 🚀 Utilisation
+### Prérequis
+- Python 3.12+
+- Poetry 1.7+
+- Git
+
+### Setup rapide
 
 ```bash
-# Health check
-curl https://asi-engineer-employee-turnover-api.hf.space/health
+# 1. Cloner le repo
+git clone https://github.com/chaton59/OC_P5.git
+cd OC_P5
+
+# 2. Installer les dépendances
+poetry install
+
+# 3. Configurer l'environnement
+cp .env.example .env
+# Éditer .env avec vos valeurs
+
+# 4. Lancer l'API
+poetry run uvicorn app:app --reload
+
+# 5. Accéder à la documentation
+# http://localhost:8000/docs
+```
+
+## 📝 Configuration (.env)
+
+```bash
+# Mode développement (désactive auth + active logs détaillés)
+DEBUG=true
+
+# API Key (requis en production)
+API_KEY=your-secret-key-here
+
+# Logging (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+LOG_LEVEL=INFO
+
+# HuggingFace Model
+HF_MODEL_REPO=ASI-Engineer/employee-turnover-model
+MODEL_FILENAME=model/model.pkl
+```
+
+## 🔒 Authentification
 
-# Prédiction
-curl -X POST https://asi-engineer-employee-turnover-api.hf.space/predict \
+### Mode DEBUG (développement)
+```bash
+# L'API Key n'est PAS requise
+curl http://localhost:8000/predict -H "Content-Type: application/json" -d '{...}'
+```
+
+### Mode PRODUCTION
+```bash
+# L'API Key est REQUISE
+curl http://localhost:8000/predict \
+  -H "X-API-Key: your-secret-key" \
   -H "Content-Type: application/json" \
-  -d '{
-    "satisfaction_employee_environnement": 3,
-    "satisfaction_employee_nature_travail": 4,
-    ...
-  }'
+  -d '{...}'
+```
+
+## 📡 Endpoints
+
+### 🏥 Health Check
+```bash
+GET /health
+
+# Réponse
+{
+  "status": "healthy",
+  "model_loaded": true,
+  "model_type": "Pipeline",
+  "version": "2.2.0"
+}
+```
+
+### 🔮 Prédiction unitaire
+```bash
+POST /predict
+Content-Type: application/json
+X-API-Key: your-key (en production)
+
+# Payload (tous les champs d'un employé)
+{
+  "nombre_participation_pee": 0,
+  "nb_formations_suivies": 2,
+  "satisfaction_employee_environnement": 3,
+  ...
+}
+
+# Réponse
+{
+  "prediction": 0,                    # 0 = reste, 1 = part
+  "probability_0": 0.85,              # Probabilité de rester
+  "probability_1": 0.15,              # Probabilité de partir
+  "risk_level": "Low"                 # Low, Medium, High
+}
+```
+
+### 📦 Prédiction batch (NOUVEAU)
+```bash
+POST /predict/batch
+X-API-Key: your-key (en production)
+
+# Envoi des 3 fichiers CSV bruts
+curl -X POST "http://localhost:8000/predict/batch" \
+  -H "X-API-Key: your-key" \
+  -F "sondage_file=@data/extrait_sondage.csv" \
+  -F "eval_file=@data/extrait_eval.csv" \
+  -F "sirh_file=@data/extrait_sirh.csv"
+
+# Réponse
+{
+  "total_employees": 1470,
+  "predictions": [
+    {"employee_id": 1, "prediction": 1, "probability_leave": 0.84, "risk_level": "High"},
+    {"employee_id": 2, "prediction": 0, "probability_leave": 0.11, "risk_level": "Low"}
+  ],
+  "summary": {
+    "total_stay": 1169,
+    "total_leave": 301,
+    "high_risk_count": 222,
+    "medium_risk_count": 233,
+    "low_risk_count": 1015
+  }
+}
 ```
 
-## 📚 Documentation complète
+## 📊 Logging
+
+### Logs structurés JSON
+
+**Fichiers** :
+- `logs/api.log` : Tous les logs
+- `logs/error.log` : Erreurs uniquement
+
+**Format** :
+```json
+{
+  "timestamp": "2025-12-26T10:30:45",
+  "level": "INFO",
+  "logger": "employee_turnover_api",
+  "message": "Request POST /predict",
+  "method": "POST",
+  "path": "/predict",
+  "status_code": 200,
+  "duration_ms": 23.45,
+  "client_host": "127.0.0.1"
+}
+```
+
+## 🛡️ Rate Limiting
+
+**Configuration** :
+- **Développement** : Désactivé (DEBUG=true)
+- **Production** : 20 requêtes/minute par IP ou API Key
+
+**En cas de dépassement** :
+```json
+{
+  "error": "Rate limit exceeded",
+  "message": "20 per 1 minute"
+}
+```
+
+## ✅ Tests
+
+```bash
+# Tous les tests
+poetry run pytest tests/ -v
+
+# Avec couverture
+poetry run pytest tests/ --cov --cov-report=html
+
+# Voir rapport HTML
+open htmlcov/index.html
+```
+
+**Résultats** :
+- ✅ 33 tests passés
+- 📊 88% de couverture globale
+
+## 🚀 Déploiement
+
+### Variables d'environnement requises
+```bash
+DEBUG=false
+API_KEY=<votre-clé-sécurisée>
+LOG_LEVEL=INFO
+```
+
+### HuggingFace Spaces
+Prêt pour déploiement avec `app.py` et `requirements.txt`
+
+## 📚 Documentation
+
+- **API Interactive** : http://localhost:8000/docs
+- **ReDoc** : http://localhost:8000/redoc
+- **Guide complet** : [docs/API_GUIDE.md](docs/API_GUIDE.md)
+- **Standards** : [docs/standards.md](docs/standards.md)
+- **Couverture tests** : [docs/TEST_COVERAGE.md](docs/TEST_COVERAGE.md)
+
+## 📦 Dépendances principales
+
+- **FastAPI** 0.115.14 : Framework web
+- **Pydantic** 2.12.5 : Validation données
+- **XGBoost** 2.1.3 : Modèle ML
+- **SlowAPI** 0.1.9 : Rate limiting
+- **python-json-logger** 4.0.0 : Logs structurés
+- **pytest** 9.0.2 : Tests
+
+## 🔄 Changelog
+
+### v2.2.0 (27 décembre 2025)
+- 📦 Nouvel endpoint `/predict/batch` pour traitement CSV direct
+- 🔧 Fix preprocessing : ajout du scaling des features
+- 🔧 Fix preprocessing : correction de l'ordre des colonnes
+- 📊 Amélioration précision des prédictions (~90%)
+
+### v2.1.0 (26 décembre 2025)
+- ✨ Système de logging structuré JSON
+- 🛡️ Rate limiting avec SlowAPI
+- ⚡ Amélioration gestion d'erreurs
+- 📊 Monitoring des performances
+
+### v2.0.0 (26 décembre 2025)
+- ✅ Suite de tests complète (36 tests)
+- 🔐 Authentification API Key
+- 📊 88% de couverture de code
+
+## 👥 Auteurs
 
-Voir [GitHub Repository](https://github.com/chaton59/OC_P5) pour la documentation complète.
+- **Projet** : OpenClassrooms P5
+- **Repo** : [github.com/chaton59/OC_P5](https://github.com/chaton59/OC_P5)

README_HF.md

@@ -6,7 +6,7 @@ colorTo: purple
 sdk: docker
 pinned: true
 license: mit
-app_port: 8000
+app_port: 7860
 ---
 
 # Employee Turnover Prediction API 🚀
@@ -16,6 +16,7 @@ API de prédiction du turnover des employés avec XGBoost + SMOTE.
 ## 🎯 Fonctionnalités
 
 - ✅ Prédiction de turnover (0 = reste, 1 = part)
+- 📦 **Nouveau** : Endpoint batch pour traiter vos fichiers CSV directement
 - 📊 Probabilités et niveau de risque (Low/Medium/High)
 - 🔐 Authentification API Key
 - 📝 Logs structurés JSON
@@ -24,26 +25,49 @@ API de prédiction du turnover des employés avec XGBoost + SMOTE.
 
 ## 🔗 Endpoints
 
-- **Docs** : `/docs` - Documentation interactive
-- **Health** : `/health` - Status de l'API
-- **Predict** : `/predict` - Prédiction de turnover
+| Endpoint | Description |
+|----------|-------------|
+| `/docs` | Documentation interactive Swagger |
+| `/health` | Status de l'API |
+| `/ui` | Interface Gradio interactive |
+| `/predict` | Prédiction unitaire (JSON) |
+| `/predict/batch` | Prédiction batch (3 fichiers CSV) |
 
 ## 🚀 Utilisation
 
+### Prédiction unitaire
 ```bash
-# Health check
-curl https://asi-engineer-employee-turnover-api.hf.space/health
-
-# Prédiction
-curl -X POST https://asi-engineer-employee-turnover-api.hf.space/predict \
+curl -X POST https://asi-engineer-oc-p5-dev.hf.space/predict \
   -H "Content-Type: application/json" \
   -d '{
+    "nombre_participation_pee": 0,
+    "nb_formations_suivies": 2,
     "satisfaction_employee_environnement": 3,
-    "satisfaction_employee_nature_travail": 4,
     ...
   }'
 ```
 
+### Prédiction batch (fichiers CSV)
+```bash
+curl -X POST https://asi-engineer-oc-p5-dev.hf.space/predict/batch \
+  -F "sondage_file=@extrait_sondage.csv" \
+  -F "eval_file=@extrait_eval.csv" \
+  -F "sirh_file=@extrait_sirh.csv"
+```
+
+**Réponse :**
+```json
+{
+  "total_employees": 1470,
+  "predictions": [...],
+  "summary": {
+    "total_stay": 1169,
+    "total_leave": 301,
+    "high_risk_count": 222
+  }
+}
+```
+
 ## 📚 Documentation complète
 
 Voir [GitHub Repository](https://github.com/chaton59/OC_P5) pour la documentation complète.

app.py

@@ -8,12 +8,15 @@ Cette API expose le modèle de prédiction de départ des employés avec :
 - Health check pour monitoring
 - Documentation OpenAPI/Swagger automatique
 - Interface Gradio pour utilisation interactive
+- Endpoint batch pour traitement de fichiers CSV
 """
+import io
 import time
 from contextlib import asynccontextmanager
 
 import gradio as gr
-from fastapi import Depends, FastAPI, HTTPException, Request
+import pandas as pd
+from fastapi import Depends, FastAPI, File, HTTPException, Request, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from slowapi import _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
@@ -23,9 +26,19 @@ from src.config import get_settings
 from src.gradio_ui import create_gradio_interface
 from src.logger import logger, log_model_load, log_request
 from src.models import get_model_info, load_model
-from src.preprocessing import preprocess_for_prediction
+from src.preprocessing import (
+    merge_csv_dataframes,
+    preprocess_dataframe_for_prediction,
+    preprocess_for_prediction,
+)
 from src.rate_limit import limiter
-from src.schemas import EmployeeInput, HealthCheck, PredictionOutput
+from src.schemas import (
+    BatchPredictionOutput,
+    EmployeeInput,
+    EmployeePrediction,
+    HealthCheck,
+    PredictionOutput,
+)
 
 # Charger la configuration
 settings = get_settings()
@@ -112,20 +125,6 @@ async def log_requests(request: Request, call_next):
     return response
 
 
-@app.get("/", tags=["Root"])
-async def root():
-    """
-    Endpoint racine avec informations sur l'API.
-    """
-    return {
-        "message": "Employee Turnover Prediction API",
-        "version": API_VERSION,
-        "docs": "/docs",
-        "health": "/health",
-        "predict": "/predict (POST)",
-    }
-
-
 @app.get("/health", response_model=HealthCheck, tags=["Monitoring"])
 async def health_check():
     """
@@ -240,17 +239,159 @@ async def predict(request: Request, employee: EmployeeInput):
         )
 
 
-# Monter l'interface Gradio sur /ui
+@app.post(
+    "/predict/batch",
+    response_model=BatchPredictionOutput,
+    tags=["Prediction"],
+    dependencies=[Depends(verify_api_key)] if settings.is_api_key_required else [],
+)
+@limiter.limit("5/minute")
+async def predict_batch(
+    request: Request,
+    sondage_file: UploadFile = File(..., description="Fichier CSV du sondage"),
+    eval_file: UploadFile = File(..., description="Fichier CSV des évaluations"),
+    sirh_file: UploadFile = File(..., description="Fichier CSV SIRH"),
+):
+    """
+    Endpoint de prédiction batch à partir de fichiers CSV.
+
+    **PROTÉGÉ PAR API KEY** : Requiert le header `X-API-Key` en production.
+
+    Prend en entrée les 3 fichiers CSV (sondage, évaluation, SIRH),
+    les fusionne, applique le preprocessing et retourne les prédictions
+    pour tous les employés.
+
+    Args:
+        sondage_file: Fichier CSV contenant les données de sondage.
+        eval_file: Fichier CSV contenant les données d'évaluation.
+        sirh_file: Fichier CSV contenant les données SIRH.
+
+    Returns:
+        BatchPredictionOutput: Prédictions pour tous les employés.
+
+    Raises:
+        HTTPException: 400 si les fichiers sont invalides.
+        HTTPException: 500 si erreur lors du traitement.
+    """
+    try:
+        # 1. Lire les fichiers CSV
+        sondage_content = await sondage_file.read()
+        eval_content = await eval_file.read()
+        sirh_content = await sirh_file.read()
+
+        sondage_df = pd.read_csv(io.BytesIO(sondage_content))
+        eval_df = pd.read_csv(io.BytesIO(eval_content))
+        sirh_df = pd.read_csv(io.BytesIO(sirh_content))
+
+        logger.info(
+            f"Fichiers CSV chargés: sondage={len(sondage_df)}, "
+            f"eval={len(eval_df)}, sirh={len(sirh_df)} lignes"
+        )
+
+        # 2. Fusionner les DataFrames
+        merged_df = merge_csv_dataframes(sondage_df, eval_df, sirh_df)
+        employee_ids = merged_df["original_employee_id"].tolist()
+        merged_df = merged_df.drop(columns=["original_employee_id"])
+
+        # Supprimer la colonne cible si présente
+        if "a_quitte_l_entreprise" in merged_df.columns:
+            merged_df = merged_df.drop(columns=["a_quitte_l_entreprise"])
+
+        logger.info(f"DataFrame fusionné: {len(merged_df)} employés")
+
+        # 3. Preprocessing
+        X = preprocess_dataframe_for_prediction(merged_df)
+
+        # 4. Charger le modèle et prédire
+        model = load_model()
+        predictions = model.predict(X.values)
+        probabilities = model.predict_proba(X.values)
+
+        # 5. Construire la réponse
+        results = []
+        risk_counts = {"Low": 0, "Medium": 0, "High": 0}
+        leave_count = 0
+
+        for i, emp_id in enumerate(employee_ids):
+            prob_stay = float(probabilities[i][0])
+            prob_leave = float(probabilities[i][1])
+            pred = int(predictions[i])
+
+            if prob_leave < 0.3:
+                risk = "Low"
+            elif prob_leave < 0.7:
+                risk = "Medium"
+            else:
+                risk = "High"
+
+            risk_counts[risk] += 1
+            if pred == 1:
+                leave_count += 1
+
+            results.append(
+                EmployeePrediction(
+                    employee_id=int(emp_id),
+                    prediction=pred,
+                    probability_stay=prob_stay,
+                    probability_leave=prob_leave,
+                    risk_level=risk,
+                )
+            )
+
+        summary = {
+            "total_stay": len(results) - leave_count,
+            "total_leave": leave_count,
+            "high_risk_count": risk_counts["High"],
+            "medium_risk_count": risk_counts["Medium"],
+            "low_risk_count": risk_counts["Low"],
+        }
+
+        logger.info(f"Prédictions terminées: {summary}")
+
+        return BatchPredictionOutput(
+            total_employees=len(results),
+            predictions=results,
+            summary=summary,
+        )
+
+    except pd.errors.EmptyDataError:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "Empty CSV file",
+                "message": "Un des fichiers CSV est vide.",
+            },
+        )
+    except KeyError as e:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "Missing column",
+                "message": f"Colonne manquante dans les CSV: {e}",
+            },
+        )
+    except Exception as e:
+        logger.exception("Unexpected error during batch prediction")
+        raise HTTPException(
+            status_code=500,
+            detail={
+                "error": "Batch prediction failed",
+                "message": str(e),
+            },
+        )
+
+
+# Monter l'interface Gradio sur / (racine pour HuggingFace Spaces)
 gradio_app = create_gradio_interface()
-app = gr.mount_gradio_app(app, gradio_app, path="/ui")
+app = gr.mount_gradio_app(app, gradio_app, path="/")
 
 
 if __name__ == "__main__":
     import uvicorn
 
-    print("🚀 Lancement de l'API en mode développement...")
-    print("📖 Documentation : http://localhost:8000/docs")
-    print("🎨 Interface Gradio : http://localhost:8000/ui")
+    print("\U0001f680 Lancement de l'API en mode d\u00e9veloppement...")
+    print("\U0001f4d6 Documentation : http://localhost:8000/docs")
+    print("\U0001f3a8 Interface Gradio : http://localhost:8000/")
 
     uvicorn.run(
         "app:app",

src/config.py

@@ -26,7 +26,7 @@ class Settings:
     API_KEY: str = os.getenv("API_KEY", "dev-key-change-me-in-production")
 
     # ===== API =====
-    API_VERSION: str = os.getenv("API_VERSION", "1.0.0")
+    API_VERSION: str = os.getenv("API_VERSION", "2.2.0")
     API_HOST: str = os.getenv("API_HOST", "0.0.0.0")
     API_PORT: int = int(os.getenv("API_PORT", "8000"))
 

src/gradio_ui.py

@@ -198,7 +198,7 @@ curl -X POST https://asi-engineer-oc-p5-dev.hf.space/predict \\
     "departement": "Commercial",
     "poste": "Manager",
     "nombre_experiences_precedentes": 3,
-    "nombre_heures_travailless": 45,
+    "nombre_heures_travailless": 80,
     "annee_experience_totale": 10,
     "annees_dans_l_entreprise": 5,
     "annees_dans_le_poste_actuel": 2
@@ -239,7 +239,7 @@ data = {
     "departement": "Commercial",
     "poste": "Manager",
     "nombre_experiences_precedentes": 3,
-    "nombre_heures_travailless": 45,
+    "nombre_heures_travailless": 80,
     "annee_experience_totale": 10,
     "annees_dans_l_entreprise": 5,
     "annees_dans_le_poste_actuel": 2
@@ -316,16 +316,18 @@ def create_gradio_interface():
                     with gr.Column():
                         gr.Markdown("#### 📋 Données Sondage")
                         nombre_participation_pee = gr.Slider(
-                            0, 10, value=0, step=1, label="Participations PEE"
+                            0, 3, value=0, step=1, label="Participations PEE"
                         )
                         nb_formations_suivies = gr.Slider(
-                            0, 10, value=2, step=1, label="Formations suivies"
+                            0, 6, value=2, step=1, label="Formations suivies"
                         )
-                        nombre_employee_sous_responsabilite = gr.Slider(
-                            0, 20, value=0, step=1, label="Employés sous responsabilité"
+                        nombre_employee_sous_responsabilite = gr.Number(
+                            value=1,
+                            label="Employés sous responsabilité",
+                            interactive=False,
                         )
                         distance_domicile_travail = gr.Slider(
-                            0, 50, value=15, step=1, label="Distance domicile (km)"
+                            1, 30, value=10, step=1, label="Distance domicile (km)"
                         )
                         niveau_education = gr.Slider(
                             1, 5, value=3, step=1, label="Niveau éducation (1-5)"
@@ -354,7 +356,7 @@ def create_gradio_interface():
                             0, 15, value=2, step=1, label="Années depuis promotion"
                         )
                         annes_sous_responsable_actuel = gr.Slider(
-                            0, 20, value=3, step=1, label="Années sous responsable"
+                            0, 17, value=3, step=1, label="Années sous responsable"
                         )
 
                     # Colonne EVALUATION
@@ -364,7 +366,7 @@ def create_gradio_interface():
                             1, 4, value=3, step=1, label="Satisfaction environnement"
                         )
                         note_evaluation_precedente = gr.Slider(
-                            1, 5, value=3, step=1, label="Évaluation précédente"
+                            1, 4, value=3, step=1, label="Évaluation précédente"
                         )
                         niveau_hierarchique_poste = gr.Slider(
                             1, 5, value=2, step=1, label="Niveau hiérarchique"
@@ -379,7 +381,7 @@ def create_gradio_interface():
                             1, 4, value=3, step=1, label="Équilibre pro/perso"
                         )
                         note_evaluation_actuelle = gr.Slider(
-                            1, 5, value=3, step=1, label="Évaluation actuelle"
+                            3, 4, value=3, step=1, label="Évaluation actuelle"
                         )
                         heure_supplementaires = gr.Radio(
                             ["Oui", "Non"], value="Non", label="Heures supplémentaires"
@@ -395,11 +397,11 @@ def create_gradio_interface():
                     # Colonne SIRH
                     with gr.Column():
                         gr.Markdown("#### 👤 Données SIRH")
-                        age = gr.Slider(18, 65, value=35, step=1, label="Âge")
+                        age = gr.Slider(18, 60, value=35, step=1, label="Âge")
                         genre = gr.Radio(["M", "F"], value="M", label="Genre")
                         revenu_mensuel = gr.Slider(
-                            1500,
-                            15000,
+                            1000,
+                            20000,
                             value=4500,
                             step=100,
                             label="Revenu mensuel (€)",
@@ -430,19 +432,19 @@ def create_gradio_interface():
                             label="Poste",
                         )
                         nombre_experiences_precedentes = gr.Slider(
-                            0, 10, value=2, step=1, label="Expériences précédentes"
+                            0, 9, value=2, step=1, label="Expériences précédentes"
                         )
-                        nombre_heures_travailless = gr.Slider(
-                            35, 80, value=40, step=1, label="Heures travaillées/sem"
+                        nombre_heures_travailless = gr.Number(
+                            value=80, label="Heures travaillées/sem", interactive=False
                         )
                         annee_experience_totale = gr.Slider(
                             0, 40, value=10, step=1, label="Années d'expérience totale"
                         )
                         annees_dans_l_entreprise = gr.Slider(
-                            0, 30, value=5, step=1, label="Années dans l'entreprise"
+                            0, 40, value=5, step=1, label="Années dans l'entreprise"
                         )
                         annees_dans_le_poste_actuel = gr.Slider(
-                            0, 20, value=2, step=1, label="Années dans le poste"
+                            0, 18, value=2, step=1, label="Années dans le poste"
                         )
 
                 # Bouton et résultat
@@ -531,13 +533,45 @@ def create_gradio_interface():
                 """
                 )
 
-    # Note: Pas de queue() car monté dans FastAPI via mount_gradio_app
-    # La queue SSE v3 ne fonctionne pas correctement avec le montage FastAPI
-
     return demo
 
 
+def launch_standalone():
+    """Lance Gradio en mode standalone (pour HuggingFace Spaces)."""
+    import sys
+
+    print("🚀 Démarrage de l'application Gradio...", flush=True)
+    print(f"Python version: {sys.version}", flush=True)
+
+    # Pré-charger le modèle pour éviter le timeout au premier appel
+    print("📦 Pré-chargement du modèle...", flush=True)
+    try:
+        from src.models import load_model
+
+        model = load_model()
+        print(f"✅ Modèle chargé: {type(model).__name__}", flush=True)
+    except Exception as e:
+        print(f"⚠️ Erreur chargement modèle: {e}", flush=True)
+
+    print("🎨 Création de l'interface Gradio...", flush=True)
+    demo = create_gradio_interface()
+
+    # Configuration pour HuggingFace Spaces
+    # Ne pas utiliser queue() qui peut causer des problèmes sur HF Spaces
+    # car il nécessite un serveur websocket supplémentaire
+
+    print("🌐 Lancement du serveur sur 0.0.0.0:7860...", flush=True)
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,  # Pas de tunnel Gradio sur HF Spaces
+        show_error=True,
+    )
+
+
 # Pour lancer en standalone
 if __name__ == "__main__":
-    demo = create_gradio_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    launch_standalone()

src/preprocessing.py

@@ -5,8 +5,7 @@ Module de preprocessing pour transformer les données d'entrée avant prédictio
 Ce module applique les mêmes transformations que le pipeline d'entraînement :
 - Feature engineering (ratios, moyennes)
 - Encoding (OneHot, Ordinal)
-
-Note: Pas de scaling car XGBoost est insensible à l'échelle des features.
+- Scaling (StandardScaler avec paramètres sauvegardés)
 """
 import numpy as np
 import pandas as pd
@@ -14,6 +13,98 @@ from sklearn.preprocessing import OneHotEncoder, OrdinalEncoder
 
 from src.schemas import EmployeeInput
 
+# Paramètres du scaler sauvegardés depuis l'entraînement
+# Ces valeurs doivent correspondre exactement à celles utilisées lors du training
+SCALER_PARAMS = {
+    "columns": [
+        "nombre_participation_pee",
+        "nb_formations_suivies",
+        "nombre_employee_sous_responsabilite",
+        "distance_domicile_travail",
+        "niveau_education",
+        "annees_depuis_la_derniere_promotion",
+        "annes_sous_responsable_actuel",
+        "satisfaction_employee_environnement",
+        "note_evaluation_precedente",
+        "niveau_hierarchique_poste",
+        "satisfaction_employee_nature_travail",
+        "satisfaction_employee_equipe",
+        "satisfaction_employee_equilibre_pro_perso",
+        "note_evaluation_actuelle",
+        "augementation_salaire_precedente",
+        "age",
+        "revenu_mensuel",
+        "nombre_experiences_precedentes",
+        "nombre_heures_travailless",
+        "annee_experience_totale",
+        "annees_dans_l_entreprise",
+        "annees_dans_le_poste_actuel",
+        "revenu_par_anciennete",
+        "experience_par_anciennete",
+        "satisfaction_moyenne",
+        "promo_par_anciennete",
+        "frequence_deplacement",
+    ],
+    "mean": [
+        0.7938775510204081,
+        2.7993197278911564,
+        1.0,
+        9.19251700680272,
+        2.912925170068027,
+        2.1789115646258503,
+        4.102721088435374,
+        2.721768707482993,
+        2.7299319727891156,
+        2.0639455782312925,
+        2.7285714285714286,
+        2.7122448979591836,
+        2.7612244897959184,
+        3.1537414965986397,
+        15.209523809523809,
+        36.923809523809524,
+        6502.931292517007,
+        2.6931972789115646,
+        80.0,
+        11.268707482993197,
+        6.980272108843537,
+        4.214965986394557,
+        1170.0019803036198,
+        1.9285635921785853,
+        2.730952380952381,
+        0.23624418065415922,
+        1.0863945578231293,
+    ],
+    "scale": [
+        0.8517867966287158,
+        1.2888320187689346,
+        1.0,
+        8.104106529671768,
+        1.0238165299102608,
+        3.1873417003246085,
+        3.502524756587405,
+        1.0927103547111134,
+        0.7113190741884202,
+        1.1065633247112856,
+        1.1024709415085499,
+        1.0808410657505316,
+        0.7062354909319911,
+        0.3607007746349458,
+        3.658692627979528,
+        9.132265690615387,
+        4706.355164823003,
+        2.497159198593844,
+        1.0,
+        7.7078836108215345,
+        6.0028580432875085,
+        3.575242796407657,
+        1353.331540788815,
+        2.2050718706188372,
+        0.5056427624070211,
+        0.2687717006578023,
+        0.5319888822661019,
+    ],
+}
+
 
 def create_input_dataframe(employee: EmployeeInput) -> pd.DataFrame:
     """
@@ -119,7 +210,7 @@ def encode_and_scale(df: pd.DataFrame) -> pd.DataFrame:
         df: DataFrame avec features engineered.
 
     Returns:
-        DataFrame transformé avec 50 colonnes (comme training).
+        DataFrame transformé avec 50 colonnes dans l'ordre exact du modèle.
     """
     df = df.copy()
 
@@ -184,10 +275,71 @@ def encode_and_scale(df: pd.DataFrame) -> pd.DataFrame:
     # Concaténer les encodages OneHot
     df = pd.concat([df, encoded_non_ord], axis=1)
 
-    # NOTE: PAS de scaling !
-    # XGBoost est un modèle basé sur des arbres, insensible à l'échelle.
-    # Le scaling sur une seule observation causait des valeurs constantes
-    # car StandardScaler.fit_transform() sur 1 ligne donne toujours 0.
+    # === RÉORDONNER LES COLONNES SELON L'ORDRE DU MODÈLE ===
+    # Ordre exact des features attendues par le modèle (50 colonnes)
+    expected_columns = [
+        "nombre_participation_pee",
+        "nb_formations_suivies",
+        "nombre_employee_sous_responsabilite",
+        "distance_domicile_travail",
+        "niveau_education",
+        "annees_depuis_la_derniere_promotion",
+        "annes_sous_responsable_actuel",
+        "satisfaction_employee_environnement",
+        "note_evaluation_precedente",
+        "niveau_hierarchique_poste",
+        "satisfaction_employee_nature_travail",
+        "satisfaction_employee_equipe",
+        "satisfaction_employee_equilibre_pro_perso",
+        "note_evaluation_actuelle",
+        "augementation_salaire_precedente",
+        "age",
+        "revenu_mensuel",
+        "nombre_experiences_precedentes",
+        "nombre_heures_travailless",
+        "annee_experience_totale",
+        "annees_dans_l_entreprise",
+        "annees_dans_le_poste_actuel",
+        "revenu_par_anciennete",
+        "experience_par_anciennete",
+        "satisfaction_moyenne",
+        "promo_par_anciennete",
+        "genre_F",
+        "genre_M",
+        "statut_marital_Célibataire",
+        "statut_marital_Divorcé(e)",
+        "statut_marital_Marié(e)",
+        "departement_Commercial",
+        "departement_Consulting",
+        "departement_Ressources Humaines",
+        "poste_Assistant de Direction",
+        "poste_Cadre Commercial",
+        "poste_Consultant",
+        "poste_Directeur Technique",
+        "poste_Manager",
+        "poste_Représentant Commercial",
+        "poste_Ressources Humaines",
+        "poste_Senior Manager",
+        "poste_Tech Lead",
+        "domaine_etude_Autre",
+        "domaine_etude_Entrepreunariat",
+        "domaine_etude_Infra & Cloud",
+        "domaine_etude_Marketing",
+        "domaine_etude_Ressources Humaines",
+        "domaine_etude_Transformation Digitale",
+        "frequence_deplacement",
+    ]
+
+    # Réordonner les colonnes
+    df = df[expected_columns]
+
+    # === SCALING ===
+    # Appliquer le StandardScaler avec les paramètres sauvegardés
+    for i, col in enumerate(SCALER_PARAMS["columns"]):
+        if col in df.columns:
+            mean = SCALER_PARAMS["mean"][i]
+            scale = SCALER_PARAMS["scale"][i]
+            df[col] = (df[col] - mean) / scale
 
     return df
 
@@ -221,12 +373,71 @@ def preprocess_for_prediction(employee: EmployeeInput) -> np.ndarray:
     return df.values
 
 
-# TODO: Implémenter le chargement des artifacts sauvegardés
-# def load_preprocessing_artifacts(run_id: str) -> dict:
-#     """
-#     Charge les encoders et scaler depuis MLflow.
-#
-#     Returns:
-#         dict avec keys: 'onehot_encoder', 'ordinal_encoder', 'scaler'
-#     """
-#     pass
+def preprocess_dataframe_for_prediction(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Préprocess un DataFrame complet (issu de CSV fusionnés) pour prédiction batch.
+
+    Args:
+        df: DataFrame avec toutes les colonnes nécessaires.
+
+    Returns:
+        DataFrame transformé prêt pour model.predict().
+    """
+    # Feature engineering
+    df_processed = engineer_features(df)
+
+    # Encoding et scaling
+    df_processed = encode_and_scale(df_processed)
+
+    return df_processed
+
+
+def merge_csv_dataframes(
+    sondage_df: pd.DataFrame,
+    eval_df: pd.DataFrame,
+    sirh_df: pd.DataFrame,
+) -> pd.DataFrame:
+    """
+    Fusionne les 3 DataFrames CSV comme lors de l'entraînement.
+
+    Args:
+        sondage_df: DataFrame du fichier sondage.
+        eval_df: DataFrame du fichier évaluation.
+        sirh_df: DataFrame du fichier SIRH.
+
+    Returns:
+        DataFrame fusionné avec toutes les colonnes.
+    """
+    # Nettoyage de l'évaluation
+    eval_df = eval_df.copy()
+    eval_df["augementation_salaire_precedente"] = eval_df[
+        "augementation_salaire_precedente"
+    ].apply(lambda x: float(str(x).replace(" %", "")) if isinstance(x, str) else x)
+    eval_df["employee_id"] = eval_df["eval_number"].apply(
+        lambda x: int(str(x).replace("E_", "")) if isinstance(x, str) else x
+    )
+
+    # Nettoyage du sondage
+    sondage_df = sondage_df.copy()
+    sondage_df["employee_id"] = sondage_df["code_sondage"].apply(
+        lambda x: int(x) if isinstance(x, (str, int)) else None
+    )
+
+    # Fusion
+    central_df = pd.merge(sondage_df, eval_df, on="employee_id", how="inner")
+    central_df = pd.merge(
+        central_df, sirh_df, left_on="employee_id", right_on="id_employee", how="inner"
+    )
+
+    # Conserver l'ID pour le retour
+    central_df["original_employee_id"] = central_df["employee_id"]
+
+    # Supprimer les colonnes de jointure
+    central_df.drop(
+        ["code_sondage", "eval_number", "id_employee", "employee_id"],
+        axis=1,
+        inplace=True,
+        errors="ignore",
+    )
+
+    return central_df

src/schemas.py

@@ -78,16 +78,19 @@ class EmployeeInput(BaseModel):
 
     # === Données SONDAGE ===
     nombre_participation_pee: int = Field(
-        ..., ge=0, description="Nombre de participations au PEE"
+        ..., ge=0, le=3, description="Nombre de participations au PEE (0-3)"
     )
     nb_formations_suivies: int = Field(
-        ..., ge=0, le=10, description="Nombre de formations suivies"
+        ..., ge=0, le=6, description="Nombre de formations suivies (0-6)"
     )
     nombre_employee_sous_responsabilite: int = Field(
-        ..., ge=0, description="Nombre d'employés sous responsabilité"
+        default=1,
+        ge=1,
+        le=1,
+        description="Nombre d'employés sous responsabilité (fixe: 1)",
     )
     distance_domicile_travail: int = Field(
-        ..., ge=0, le=50, description="Distance domicile-travail en km"
+        ..., ge=1, le=30, description="Distance domicile-travail en km (1-30)"
     )
     niveau_education: int = Field(
         ..., ge=1, le=5, description="Niveau d'éducation (1-5)"
@@ -101,7 +104,7 @@ class EmployeeInput(BaseModel):
         ..., ge=0, description="Années depuis la dernière promotion"
     )
     annes_sous_responsable_actuel: int = Field(
-        ..., ge=0, description="Années sous le responsable actuel"
+        ..., ge=0, le=17, description="Années sous le responsable actuel (0-17)"
     )
 
     # === Données EVALUATION ===
@@ -109,7 +112,7 @@ class EmployeeInput(BaseModel):
         ..., ge=1, le=4, description="Satisfaction environnement (1-4)"
     )
     note_evaluation_precedente: int = Field(
-        ..., ge=1, le=5, description="Note évaluation précédente (1-5)"
+        ..., ge=1, le=4, description="Note évaluation précédente (1-4)"
     )
     niveau_hierarchique_poste: int = Field(
         ..., ge=1, le=5, description="Niveau hiérarchique (1-5)"
@@ -124,7 +127,7 @@ class EmployeeInput(BaseModel):
         ..., ge=1, le=4, description="Satisfaction équilibre pro/perso (1-4)"
     )
     note_evaluation_actuelle: int = Field(
-        ..., ge=1, le=5, description="Note évaluation actuelle (1-5)"
+        ..., ge=3, le=4, description="Note évaluation actuelle (3-4)"
     )
     heure_supplementaires: Literal["Oui", "Non"] = Field(
         ..., description="Fait des heures supplémentaires"
@@ -134,26 +137,31 @@ class EmployeeInput(BaseModel):
     )
 
     # === Données SIRH ===
-    age: int = Field(..., ge=18, le=70, description="Âge de l'employé")
+    age: int = Field(..., ge=18, le=60, description="Âge de l'employé (18-60)")
     genre: GenreEnum = Field(..., description="Genre")
-    revenu_mensuel: float = Field(..., ge=1000, description="Revenu mensuel (€)")
+    revenu_mensuel: float = Field(
+        ..., ge=1000, le=20000, description="Revenu mensuel (€) (1000-20000)"
+    )
     statut_marital: StatutMaritalEnum = Field(..., description="Statut marital")
     departement: DepartementEnum = Field(..., description="Département")
     poste: PosteEnum = Field(..., description="Intitulé du poste")
     nombre_experiences_precedentes: int = Field(
-        ..., ge=0, description="Nombre d'expériences précédentes"
+        ..., ge=0, le=9, description="Nombre d'expériences précédentes (0-9)"
     )
     nombre_heures_travailless: int = Field(
-        ..., ge=35, le=80, description="Nombre d'heures travaillées par semaine"
+        default=80,
+        ge=80,
+        le=80,
+        description="Nombre d'heures travaillées par semaine (fixe: 80)",
     )
     annee_experience_totale: int = Field(
         ..., ge=0, description="Années d'expérience totale"
     )
     annees_dans_l_entreprise: int = Field(
-        ..., ge=0, description="Années dans l'entreprise"
+        ..., ge=0, le=40, description="Années dans l'entreprise (0-40)"
     )
     annees_dans_le_poste_actuel: int = Field(
-        ..., ge=0, description="Années dans le poste actuel"
+        ..., ge=0, le=18, description="Années dans le poste actuel (0-18)"
     )
 
     @field_validator("augementation_salaire_precedente")
@@ -248,3 +256,52 @@ class HealthCheck(BaseModel):
                 "version": "1.0.0",
             }
         }
+
+
+class EmployeePrediction(BaseModel):
+    """Prédiction pour un employé dans le batch."""
+
+    employee_id: int = Field(..., description="ID de l'employé")
+    prediction: int = Field(..., description="Classe prédite (0=reste, 1=part)")
+    probability_stay: float = Field(
+        ..., ge=0, le=1, description="Probabilité de rester"
+    )
+    probability_leave: float = Field(
+        ..., ge=0, le=1, description="Probabilité de partir"
+    )
+    risk_level: str = Field(..., description="Niveau de risque (Low/Medium/High)")
+
+
+class BatchPredictionOutput(BaseModel):
+    """Schéma de sortie pour les prédictions par lots (CSV)."""
+
+    total_employees: int = Field(..., description="Nombre total d'employés traités")
+    predictions: list[EmployeePrediction] = Field(
+        ..., description="Liste des prédictions"
+    )
+    summary: dict = Field(..., description="Résumé des prédictions")
+
+    class Config:
+        """Configuration Pydantic."""
+
+        json_schema_extra = {
+            "example": {
+                "total_employees": 100,
+                "predictions": [
+                    {
+                        "employee_id": 1,
+                        "prediction": 0,
+                        "probability_stay": 0.85,
+                        "probability_leave": 0.15,
+                        "risk_level": "Low",
+                    }
+                ],
+                "summary": {
+                    "total_stay": 80,
+                    "total_leave": 20,
+                    "high_risk_count": 15,
+                    "medium_risk_count": 10,
+                    "low_risk_count": 75,
+                },
+            }
+        }