Upload folder using huggingface_hub

.gitignore

@@ -36,11 +36,9 @@ secrets.json
 data/raw/  # Pour datasets volumineux en data science (OC_P5)
 notebooks/*.ipynb_checkpoints/
 
-# MLflow
-mlflow.db
+# MLflow (logs seulement, garder DB et runs pour déploiement HF)
 mlflow.db-shm
 mlflow.db-wal
-mlruns/
 mlflow_ui.log
 mlflow_comparison.png
 nohup.out

app.py

@@ -8,42 +8,61 @@ Version de démonstration - Interface complète en développement.
 import gradio as gr
 import mlflow
 import mlflow.sklearn
+from huggingface_hub import hf_hub_download
+from pathlib import Path
 
-
-# Configuration MLflow
-mlflow.set_tracking_uri("sqlite:///mlflow.db")
-
-# Charger le modèle le plus récent
-MODEL_URI = "models:/Employee_Turnover_Model/latest"
-# Fallback: utiliser un run_id spécifique si le modèle n'est pas enregistré
-FALLBACK_RUN_ID = "2dd66b2b125646e19cf123c6944c9185"
+# Configuration
+HF_MODEL_REPO = "ASI-Engineer/employee-turnover-model"
+FALLBACK_RUN_ID = "40e43c8e425345bab3d19f27eb8fe5d8"
 
 
 def load_model():
-    """Charge le modèle depuis MLflow."""
+    """
+    Charge le modèle depuis Hugging Face Hub (prod) ou MLflow local (dev).
+
+    Ordre de priorité:
+    1. HF Hub (modèle déployé en production)
+    2. MLflow local (développement local)
+    """
+    # Essayer HF Hub en premier (production)
     try:
-        model = mlflow.sklearn.load_model(MODEL_URI)
-        print(f"✅ Modèle chargé depuis Model Registry: {MODEL_URI}")
-        return model
+        # Download model from HF Hub
+        model_path = hf_hub_download(
+            repo_id=HF_MODEL_REPO, filename="model/model.pkl", repo_type="model"
+        )
+        model = mlflow.sklearn.load_model(str(Path(model_path).parent))
+        print(f"✅ Modèle chargé depuis HF Hub: {HF_MODEL_REPO}")
+        return model, "HF Hub"
     except Exception as e:
-        print(f"⚠️ Model Registry non disponible, utilisation du run_id: {e}")
+        print(f"⚠️ HF Hub non disponible: {e}")
+
+    # Fallback: MLflow local (développement)
+    mlflow.set_tracking_uri("sqlite:///mlflow.db")
+    try:
+        # Essayer Model Registry d'abord
+        model = mlflow.sklearn.load_model("models:/XGBoost_Employee_Turnover/latest")
+        print("✅ Modèle chargé depuis MLflow Model Registry")
+        return model, "MLflow Registry"
+    except Exception:
         try:
+            # Fallback sur run ID
             model = mlflow.sklearn.load_model(f"runs:/{FALLBACK_RUN_ID}/model")
-            print(f"✅ Modèle chargé depuis run_id: {FALLBACK_RUN_ID}")
-            return model
+            print(f"✅ Modèle chargé depuis MLflow run: {FALLBACK_RUN_ID}")
+            return model, "MLflow Local"
         except Exception as e2:
-            print(f"❌ Erreur lors du chargement du modèle: {e2}")
-            return None
+            print(f"❌ Erreur chargement MLflow: {e2}")
+            return None, "Error"
 
 
 # Charger le modèle au démarrage
 try:
-    model = load_model()
+    model, model_source = load_model()
     MODEL_LOADED = model is not None
 except Exception as e:
     print(f"❌ Erreur lors du chargement du modèle: {e}")
     MODEL_LOADED = False
     model = None
+    model_source = "Error"
 
 
 def get_model_info():
@@ -51,35 +70,43 @@ def get_model_info():
     if not MODEL_LOADED:
         return {
             "status": "❌ Modèle non disponible",
-            "error": "Le modèle n'a pas pu être chargé depuis MLflow",
-            "solution": "Vérifiez que main.py a bien été exécuté pour entraîner le modèle",
+            "error": "Le modèle n'a pas pu être chargé",
+            "solution": "Vérifiez que le modèle est bien enregistré sur HF Hub ou entraîné localement",
         }
 
     try:
-        # Obtenir des informations sur le modèle
-        client = mlflow.MlflowClient()
-        runs = client.search_runs(
-            experiment_ids=["1"], order_by=["start_time DESC"], max_results=1
-        )
+        info = {
+            "status": "✅ Modèle chargé avec succès",
+            "source": model_source,
+            "model_type": type(model).__name__,
+            "features": "~50 features (après preprocessing)",
+            "algorithme": "XGBoost + SMOTE",
+            "hf_hub_repo": HF_MODEL_REPO if model_source == "HF Hub" else "N/A",
+        }
 
-        if runs:
-            run = runs[0]
-            metrics = run.data.metrics
-            return {
-                "status": "✅ Modèle chargé avec succès",
-                "run_id": run.info.run_id[:8],
-                "f1_score": f"{metrics.get('f1_score', 0):.4f}",
-                "accuracy": f"{metrics.get('accuracy', 0):.4f}",
-                "features": "~50 features (après preprocessing)",
-                "algorithme": "XGBoost + SMOTE",
-                "info": "Interface de prédiction en développement - API FastAPI à venir",
-            }
-        else:
-            return {
-                "status": "✅ Modèle chargé",
-                "info": "Pas de métriques disponibles",
-                "run_id": FALLBACK_RUN_ID[:8],
-            }
+        # Si MLflow local, ajouter les métriques
+        if model_source == "MLflow Local":
+            mlflow.set_tracking_uri("sqlite:///mlflow.db")
+            client = mlflow.MlflowClient()
+            runs = client.search_runs(
+                experiment_ids=["1"], order_by=["start_time DESC"], max_results=1
+            )
+            if runs:
+                run = runs[0]
+                metrics = run.data.metrics
+                info.update(
+                    {
+                        "run_id": run.info.run_id[:8],
+                        "f1_score": f"{metrics.get('f1_score', 0):.4f}",
+                        "accuracy": f"{metrics.get('accuracy', 0):.4f}",
+                    }
+                )
+
+        info["info"] = "Interface de prédiction en développement - API FastAPI à venir"
+        return info
+
+    except Exception as e:
+        return {"status": "✅ Modèle chargé (info limitées)", "error": str(e)}
 
     except Exception as e:
         return {"status": "✅ Modèle chargé (info limitées)", "error": str(e)}

scripts/register_model_to_hf.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Script pour enregistrer le modèle MLflow dans Hugging Face Hub.
+
+Usage:
+    python scripts/register_model_to_hf.py
+
+Prérequis:
+    - HF_TOKEN configuré dans l'environnement ou .env
+    - Modèle entraîné dans MLflow
+"""
+import os
+import shutil
+from pathlib import Path
+
+import mlflow
+import mlflow.sklearn
+from huggingface_hub import HfApi, login
+
+
+def register_model_to_hf(
+    run_id: str,
+    hf_repo_id: str = "ASI-Engineer/employee-turnover-model",
+    model_name: str = "Employee_Turnover_XGBoost",
+):
+    """
+    Enregistre le modèle MLflow dans le Model Registry puis l'exporte vers HF Hub.
+
+    Args:
+        run_id: ID du run MLflow contenant le meilleur modèle
+        hf_repo_id: Repository Hugging Face (format: username/repo-name)
+        model_name: Nom du modèle dans MLflow Model Registry
+    """
+    print("=" * 80)
+    print("🚀 ENREGISTREMENT DU MODÈLE DANS HUGGING FACE HUB")
+    print("=" * 80)
+    print()
+
+    # Configuration MLflow
+    mlflow.set_tracking_uri("sqlite:///mlflow.db")
+
+    # 1. Enregistrer dans MLflow Model Registry
+    print("📦 Étape 1: Enregistrement dans MLflow Model Registry...")
+    model_uri = f"runs:/{run_id}/model"
+
+    try:
+        # Créer ou mettre à jour le modèle dans le registry
+        model_version = mlflow.register_model(model_uri, model_name)
+        print(f"   ✅ Modèle enregistré: {model_name} version {model_version.version}")
+        print(f"   📍 Run ID: {run_id}")
+    except Exception as e:
+        print(f"   ℹ️  Modèle déjà enregistré ou erreur: {e}")
+        model_version = None
+
+    print()
+
+    # 2. Charger le modèle
+    print("📥 Étape 2: Chargement du modèle depuis MLflow...")
+    # Essayer depuis le Model Registry d'abord
+    try:
+        model = mlflow.sklearn.load_model(f"models:/{model_name}/latest")
+        print(f"   ✅ Modèle chargé depuis Model Registry: {model_name}")
+    except Exception:
+        # Fallback: charger depuis le run
+        model = mlflow.sklearn.load_model(model_uri)
+        print(f"   ✅ Modèle chargé depuis run: {run_id[:8]}")
+    print(f"   📦 Type: {type(model).__name__}")
+    print()
+
+    # 3. Exporter vers dossier temporaire
+    print("💾 Étape 3: Export du modèle...")
+    export_dir = Path("./model_export")
+    export_dir.mkdir(exist_ok=True)
+
+    # Sauvegarder le modèle au format MLflow
+    mlflow.sklearn.save_model(model, str(export_dir / "model"))
+
+    # Créer un README pour HF
+    readme_content = f"""---
+tags:
+- employee-turnover
+- xgboost
+- mlflow
+- classification
+library_name: scikit-learn
+---
+
+# Employee Turnover Prediction Model
+
+Modèle XGBoost pour prédire le turnover des employés.
+
+## Métriques
+- **F1-Score**: Optimisé pour classes déséquilibrées
+- **Algorithme**: XGBoost avec SMOTE
+- **MLflow Run ID**: `{run_id}`
+
+## Utilisation
+
+```python
+import mlflow
+
+# Charger depuis Hugging Face Hub
+model = mlflow.sklearn.load_model("hf://{hf_repo_id}")
+
+# Prédiction
+predictions = model.predict(X)
+```
+
+## Preprocessing
+Les artifacts de preprocessing (scaler, encoders) sont disponibles dans MLflow.
+
+## Repository
+[GitHub - OC_P5](https://github.com/chaton59/OC_P5)
+"""
+
+    with open(export_dir / "README.md", "w", encoding="utf-8") as f:
+        f.write(readme_content)
+
+    print(f"   ✅ Modèle exporté vers: {export_dir}")
+    print()
+
+    # 4. Upload vers Hugging Face Hub
+    print("☁️  Étape 4: Upload vers Hugging Face Hub...")
+
+    # Login HF (utilise HF_TOKEN depuis env)
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        print("   ⚠️  HF_TOKEN non trouvé dans l'environnement")
+        print(
+            "   💡 Conseil: Créez un token sur https://huggingface.co/settings/tokens"
+        )
+        print("   💡 Puis: export HF_TOKEN='your_token_here'")
+        return False
+
+    try:
+        login(token=hf_token, add_to_git_credential=False)
+        print("   ✅ Authentification Hugging Face réussie")
+
+        # Upload
+        api = HfApi()
+        api.create_repo(
+            repo_id=hf_repo_id, repo_type="model", exist_ok=True, private=False
+        )
+
+        api.upload_folder(
+            repo_id=hf_repo_id,
+            folder_path=str(export_dir),
+            repo_type="model",
+        )
+
+        print(f"   ✅ Modèle uploadé vers: https://huggingface.co/{hf_repo_id}")
+        print()
+
+        # Nettoyage
+        shutil.rmtree(export_dir)
+        print("   🧹 Dossier temporaire nettoyé")
+
+        return True
+
+    except Exception as e:
+        print(f"   ❌ Erreur lors de l'upload: {e}")
+        return False
+
+    finally:
+        print()
+        print("=" * 80)
+        print("✅ ENREGISTREMENT TERMINÉ")
+        print("=" * 80)
+        print()
+        print(f"🔗 Modèle disponible sur: https://huggingface.co/{hf_repo_id}")
+        print("📝 Pour utiliser dans app.py:")
+        print(f'   model = mlflow.sklearn.load_model("hf://{hf_repo_id}")')
+
+
+if __name__ == "__main__":
+    # Utiliser le meilleur run (le plus récent avec modèle)
+    RUN_ID = "40e43c8e425345bab3d19f27eb8fe5d8"
+
+    success = register_model_to_hf(
+        run_id=RUN_ID, hf_repo_id="ASI-Engineer/employee-turnover-model"
+    )
+
+    if not success:
+        print("\n⚠️  Enregistrement incomplet. Vérifiez HF_TOKEN.")
+        exit(1)