Upload folder using huggingface_hub

exemples/demo_batch.py

@@ -1,160 +1,154 @@
 #!/usr/bin/env python3
 """
-📦 Prédiction BATCH - Le plus simple possible
+📦 Prédiction BATCH - API Locale
 
 Usage: python demo_batch.py
+Prérequis: API locale démarrée sur http://127.0.0.1:7860
 """
 
 import os
-import pandas as pd
-import requests
+import sys
 from datetime import datetime
 
+try:
+    import pandas as pd
+    from gradio_client import Client, handle_file
+except ImportError:
+    print("❌ Dépendances manquantes. Installez avec:")
+    print("   pip install gradio_client pandas")
+    sys.exit(1)
+
 # ═══════════════════════════════════════════════════════════════
 # CONFIGURATION
 # ═══════════════════════════════════════════════════════════════
-
-# Pour utiliser l'API Hugging Face Spaces, changez l'URL ci-dessous
-# API_URL = "https://asi-engineer-oc-p5.hf.space"
-API_URL = "http://127.0.0.1:7860"  # API locale par défaut
-API_KEY = None  # Pas besoin d'API key en mode DEBUG local
+API_URL = os.getenv("LOCAL_API_URL", "http://127.0.0.1:7860")
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Fichiers par défaut
+DEFAULT_FILES = {
+    "eval": os.path.join(SCRIPT_DIR, "02_predict_batch_eval.csv"),
+    "sirh": os.path.join(SCRIPT_DIR, "02_predict_batch_sirh.csv"),
+    "sondage": os.path.join(SCRIPT_DIR, "02_predict_batch_sondage.csv"),
+}
 
 print("╔══════════════════════════════════════════════════════════╗")
-print("║  📦 PRÉDICTION BATCH - Traitement CSV                    ║")
-print("╚══════════════════════════════════════════════════════════╝\n")
+print("║  📦 PRÉDICTION BATCH - API Locale                        ║")
+print("╚══════════════════════════════════════════════════════════╝")
+print(f"\n🌐 API: {API_URL}\n")
 
 # ═══════════════════════════════════════════════════════════════
-# COLLECTE DES FICHIERS
+# SÉLECTION DES FICHIERS
 # ═══════════════════════════════════════════════════════════════
-
-# Obtenir le dossier du script
-script_dir = os.path.dirname(os.path.abspath(__file__))
-
-# Chemins par défaut vers les fichiers d'exemple
-default_sondage = os.path.join(script_dir, "02_predict_batch_sondage.csv")
-default_eval = os.path.join(script_dir, "02_predict_batch_eval.csv")
-default_sirh = os.path.join(script_dir, "02_predict_batch_sirh.csv")
-
-print("📋 Voulez-vous utiliser les fichiers d'exemple du dossier ?")
-print(f"   - {os.path.basename(default_sondage)}")
-print(f"   - {os.path.basename(default_eval)}")
-print(f"   - {os.path.basename(default_sirh)}")
-use_defaults = input("\nUtiliser ces fichiers ? (O/n): ").strip().lower()
-
-if use_defaults in ["", "o", "oui", "y", "yes"]:
-    sondage_path = default_sondage
-    eval_path = default_eval
-    sirh_path = default_sirh
-    print("\n✅ Utilisation des fichiers d'exemple")
+print("═" * 60)
+print("📁 SÉLECTION DES FICHIERS CSV")
+print("═" * 60)
+
+use_default = (
+    input("\nUtiliser les fichiers exemples par défaut? [O/n]: ").strip().lower()
+)
+
+if use_default in ("", "o", "oui", "y", "yes"):
+    fichier_eval = DEFAULT_FILES["eval"]
+    fichier_sirh = DEFAULT_FILES["sirh"]
+    fichier_sondage = DEFAULT_FILES["sondage"]
+    print(f"\n📄 Évaluation: {os.path.basename(fichier_eval)}")
+    print(f"📄 SIRH:       {os.path.basename(fichier_sirh)}")
+    print(f"📄 Sondage:    {os.path.basename(fichier_sondage)}")
 else:
-    print("\nVeuillez fournir les 3 fichiers CSV:\n")
-    sondage_path = input("📋 Chemin du fichier SONDAGE (.csv): ").strip()
-    eval_path = input("📊 Chemin du fichier ÉVALUATION (.csv): ").strip()
-    sirh_path = input("💼 Chemin du fichier SIRH (.csv): ").strip()
-
-# Vérifier que les fichiers existent
-for path in [sondage_path, eval_path, sirh_path]:
+    print("\nEntrez les chemins des fichiers CSV:")
+    fichier_eval = input("📄 Fichier évaluation: ").strip()
+    fichier_sirh = input("📄 Fichier SIRH: ").strip()
+    fichier_sondage = input("📄 Fichier sondage: ").strip()
+
+# Vérification des fichiers
+for name, path in [
+    ("Évaluation", fichier_eval),
+    ("SIRH", fichier_sirh),
+    ("Sondage", fichier_sondage),
+]:
     if not os.path.exists(path):
-        print(f"\n❌ ERREUR: Fichier introuvable: {path}")
-        exit(1)
-
-print("\n✅ Fichiers chargés:")
-print(f"   - Sondage: {os.path.basename(sondage_path)}")
-print(f"   - Évaluation: {os.path.basename(eval_path)}")
-print(f"   - SIRH: {os.path.basename(sirh_path)}")
+        print(f"\n❌ Fichier {name} introuvable: {path}")
+        sys.exit(1)
 
 # ═══════════════════════════════════════════════════════════════
-# ENVOI À L'API
+# PRÉDICTION BATCH
 # ═══════════════════════════════════════════════════════════════
-
-print("\n⏳ Envoi des fichiers à l'API...")
-
-files = {
-    "sondage_file": open(sondage_path, "rb"),
-    "eval_file": open(eval_path, "rb"),
-    "sirh_file": open(sirh_path, "rb"),
-}
-
-headers = {}
-if API_KEY:
-    headers["X-API-Key"] = API_KEY
+print("\n" + "═" * 60)
+print("⏳ TRAITEMENT EN COURS...")
+print("═" * 60)
 
 try:
-    response = requests.post(
-        f"{API_URL}/predict/batch", files=files, headers=headers, timeout=120
+    print("\n⏳ Connexion à l'API...")
+    client = Client(API_URL)
+    print("✅ Connecté")
+
+    print("⏳ Envoi des fichiers...")
+    result = client.predict(
+        fichier_eval=handle_file(fichier_eval),
+        fichier_sirh=handle_file(fichier_sirh),
+        fichier_sondage=handle_file(fichier_sondage),
+        api_name="/predict_batch",
     )
-    response.raise_for_status()
-    result = response.json()
-
-    # ═══════════════════════════════════════════════════════════════
-    # CRÉATION DU CSV DE SORTIE
-    # ═══════════════════════════════════════════════════════════════
-
-    print("\n✅ Prédictions reçues!")
-    print(f"   Total employés traités: {result['total_employees']}")
-
-    # Créer un DataFrame avec les résultats
-    predictions_data = []
-    for pred in result["predictions"]:
-        predictions_data.append(
-            {
-                "employee_id": pred["employee_id"],
-                "prediction": "VA PARTIR" if pred["prediction"] == 1 else "VA RESTER",
-                "prediction_code": pred["prediction"],
-                "risk_level": pred["risk_level"],
-                "probability_stay": f"{pred['probability_stay']:.2%}",
-                "probability_leave": f"{pred['probability_leave']:.2%}",
-            }
-        )
-
-    df_results = pd.DataFrame(predictions_data)
-
-    # Générer le nom du fichier de sortie
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    output_filename = f"predictions_batch_{timestamp}.csv"
-
-    # Sauvegarder dans le même dossier que ce script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    output_path = os.path.join(script_dir, output_filename)
-
-    # Sauvegarder dans le même dossier que ce script
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    output_path = os.path.join(script_dir, output_filename)
-
-    df_results.to_csv(output_path, index=False, encoding="utf-8-sig")
 
     # ═══════════════════════════════════════════════════════════════
-    # AFFICHAGE DU RÉSUMÉ
+    # AFFICHAGE DU RÉSULTAT
     # ═══════════════════════════════════════════════════════════════
-
-    print("\n" + "═" * 60)
-    print("                    📊 RÉSUMÉ")
-    print("═" * 60)
-
-    summary = result["summary"]
-    print(f"\n✅ Employés qui vont RESTER: {summary['total_stay']}")
-    print(f"🏃 Employés qui vont PARTIR: {summary['total_leave']}")
-    print(f"\n🔴 Risque ÉLEVÉ: {summary['high_risk_count']}")
-    print(f"🟡 Risque MOYEN: {summary['medium_risk_count']}")
-    print(f"🟢 Risque FAIBLE: {summary['low_risk_count']}")
-
     print("\n" + "═" * 60)
-    print("💾 Résultats sauvegardés dans:")
-    print(f"   {output_path}")
+    print("📊 RÉSULTAT DE LA PRÉDICTION BATCH")
     print("═" * 60)
 
-    # Afficher un échantillon
-    print("\n📋 Aperçu des 5 premiers résultats:")
-    print(df_results.head(5).to_string(index=False))
+    if isinstance(result, dict):
+        # Lecture du fichier résultat
+        result_path = result.get("value") or result.get("path")
+        if result_path and os.path.exists(result_path):
+            df = pd.read_csv(result_path)
+            total = len(df)
+
+            # Statistiques
+            if "prediction" in df.columns:
+                restent = (df["prediction"] == "Reste").sum()
+                partent = (df["prediction"] == "Part").sum()
+            else:
+                restent = partent = 0
+
+            if "risk_level" in df.columns:
+                risque_eleve = (df["risk_level"] == "Élevé").sum()
+                risque_moyen = (df["risk_level"] == "Moyen").sum()
+                risque_faible = (df["risk_level"] == "Faible").sum()
+            else:
+                risque_eleve = risque_moyen = risque_faible = 0
+
+            # Affichage des stats
+            print(f"\n👥 Total employés analysés: {total}")
+            print(f"\n📈 Vont RESTER:  {restent} ({100 * restent / total:.1f}%)")
+            print(f"📉 Vont PARTIR:  {partent} ({100 * partent / total:.1f}%)")
+
+            print(f"\n🟢 Risque faible: {risque_faible}")
+            print(f"🟠 Risque moyen:  {risque_moyen}")
+            print(f"🔴 Risque élevé:  {risque_eleve}")
+
+            # Sauvegarde
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_file = os.path.join(SCRIPT_DIR, f"predictions_batch_{timestamp}.csv")
+            df.to_csv(output_file, index=False)
+
+            print("\n" + "─" * 60)
+            print(f"💾 Fichier sauvegardé: {os.path.basename(output_file)}")
+            print("─" * 60)
+
+            # Aperçu
+            print("\n📋 Aperçu des résultats:")
+            cols = ["employee_id", "prediction", "prob_depart", "risk_level"]
+            cols_exist = [c for c in cols if c in df.columns]
+            if cols_exist:
+                print(df[cols_exist].head(10).to_string(index=False))
+        else:
+            print(f"\n⚠️ Fichier résultat non trouvé: {result_path}")
+    else:
+        print(f"\n📋 Résultat: {result}")
+
+    print("\n✅ Prédiction batch terminée avec succès!")
 
-except requests.exceptions.RequestException as e:
-    print(f"\n❌ ERREUR API: {e}")
-    if hasattr(e, "response") and e.response is not None:
-        print(f"Détails: {e.response.text}")
 except Exception as e:
-    print(f"\n❌ ERREUR: {e}")
-finally:
-    # Fermer les fichiers
-    for f in files.values():
-        if not f.closed:
-            f.close()
+    print(f"\n❌ Erreur: {e}")
+    sys.exit(1)

exemples/demo_batch_hf.py

@@ -1,109 +1,154 @@
 #!/usr/bin/env python3
 """
-📦 Prédiction BATCH via API Hugging Face (Gradio Client)
+📦 Prédiction BATCH - API Hugging Face (Gradio)
 
 Usage: python demo_batch_hf.py
-- Utilise par défaut les CSV d'exemple du dossier
-- Envoie les 3 fichiers à la Space HF via Gradio Client
-- Sauvegarde un CSV de résultats
-
-Prérequis: pip install gradio_client
+Prérequis: pip install gradio_client pandas
 """
 
 import os
 import sys
-import pandas as pd
 from datetime import datetime
 
 try:
+    import pandas as pd
     from gradio_client import Client, handle_file
 except ImportError:
-    print("❌ gradio_client non installé. Installez-le avec:")
-    print("   pip install gradio_client")
+    print("❌ Dépendances manquantes. Installez avec:")
+    print("   pip install gradio_client pandas")
     sys.exit(1)
 
+# ═══════════════════════════════════════════════════════════════
+# CONFIGURATION
+# ═══════════════════════════════════════════════════════════════
 API_URL = os.getenv("HF_API_URL", "https://asi-engineer-oc-p5.hf.space")
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Fichiers par défaut
+DEFAULT_FILES = {
+    "eval": os.path.join(SCRIPT_DIR, "02_predict_batch_eval.csv"),
+    "sirh": os.path.join(SCRIPT_DIR, "02_predict_batch_sirh.csv"),
+    "sondage": os.path.join(SCRIPT_DIR, "02_predict_batch_sondage.csv"),
+}
 
 print("╔══════════════════════════════════════════════════════════╗")
-print("║  📦 Prédiction BATCH - API Hugging Face (Gradio)        ║")
-print("╚══════════════════════════════════════════════════════════╝\n")
-print(f"🌐 API: {API_URL}\n")
-
-# Dossier du script
-script_dir = os.path.dirname(os.path.abspath(__file__))
-sondage_path = os.path.join(script_dir, "02_predict_batch_sondage.csv")
-eval_path = os.path.join(script_dir, "02_predict_batch_eval.csv")
-sirh_path = os.path.join(script_dir, "02_predict_batch_sirh.csv")
-
-# Vérifier existence
-for path in [sondage_path, eval_path, sirh_path]:
+print("║  📦 PRÉDICTION BATCH - API Hugging Face                  ║")
+print("╚══════════════════════════════════════════════════════════╝")
+print(f"\n🌐 API: {API_URL}\n")
+
+# ═══════════════════════════════════════════════════════════════
+# SÉLECTION DES FICHIERS
+# ═══════════════════════════════════════════════════════════════
+print("═" * 60)
+print("📁 SÉLECTION DES FICHIERS CSV")
+print("═" * 60)
+
+use_default = (
+    input("\nUtiliser les fichiers exemples par défaut? [O/n]: ").strip().lower()
+)
+
+if use_default in ("", "o", "oui", "y", "yes"):
+    fichier_eval = DEFAULT_FILES["eval"]
+    fichier_sirh = DEFAULT_FILES["sirh"]
+    fichier_sondage = DEFAULT_FILES["sondage"]
+    print(f"\n📄 Évaluation: {os.path.basename(fichier_eval)}")
+    print(f"📄 SIRH:       {os.path.basename(fichier_sirh)}")
+    print(f"📄 Sondage:    {os.path.basename(fichier_sondage)}")
+else:
+    print("\nEntrez les chemins des fichiers CSV:")
+    fichier_eval = input("📄 Fichier évaluation: ").strip()
+    fichier_sirh = input("📄 Fichier SIRH: ").strip()
+    fichier_sondage = input("📄 Fichier sondage: ").strip()
+
+# Vérification des fichiers
+for name, path in [
+    ("Évaluation", fichier_eval),
+    ("SIRH", fichier_sirh),
+    ("Sondage", fichier_sondage),
+]:
     if not os.path.exists(path):
-        print(f"❌ Fichier introuvable: {path}")
+        print(f"\n❌ Fichier {name} introuvable: {path}")
         sys.exit(1)
 
-print("✅ Fichiers d'exemple détectés:")
-print(f"   - {os.path.basename(sondage_path)}")
-print(f"   - {os.path.basename(eval_path)}")
-print(f"   - {os.path.basename(sirh_path)}\n")
+# ═══════════════════════════════════════════════════════════════
+# PRÉDICTION BATCH
+# ═══════════════════════════════════════════════════════════════
+print("\n" + "═" * 60)
+print("⏳ TRAITEMENT EN COURS...")
+print("═" * 60)
 
-print("⏳ Connexion à l'API Gradio...")
 try:
+    print("\n⏳ Connexion à l'API...")
     client = Client(API_URL)
-    print("✅ Connecté à l'API Gradio\n")
-except Exception as e:
-    print(f"❌ Impossible de se connecter: {e}")
-    sys.exit(1)
+    print("✅ Connecté")
 
-print("⏳ Envoi des fichiers pour prédiction batch...")
-try:
+    print("⏳ Envoi des fichiers...")
     result = client.predict(
-        sondage_path=handle_file(sondage_path),
-        eval_path=handle_file(eval_path),
-        sirh_path=handle_file(sirh_path),
+        fichier_eval=handle_file(fichier_eval),
+        fichier_sirh=handle_file(fichier_sirh),
+        fichier_sondage=handle_file(fichier_sondage),
         api_name="/predict_batch",
     )
-except Exception as e:
-    print(f"❌ Erreur lors de la prédiction: {e}")
-    sys.exit(1)
-
-# Vérifier si erreur dans le résultat
-if isinstance(result, dict) and "error" in result:
-    print(f"\n❌ Erreur API: {result.get('error')}")
-    print(f"   Message: {result.get('message')}")
-    sys.exit(1)
 
-# Construire le CSV de sortie
-predictions_data = []
-for pred in result.get("predictions", []):
-    predictions_data.append(
-        {
-            "employee_id": pred.get("employee_id"),
-            "prediction": "VA PARTIR" if pred.get("prediction") == 1 else "VA RESTER",
-            "prediction_code": pred.get("prediction"),
-            "risk_level": pred.get("risk_level"),
-            "probability_stay": f"{pred.get('probability_stay', 0):.2%}",
-            "probability_leave": f"{pred.get('probability_leave', 0):.2%}",
-        }
-    )
+    # ═══════════════════════════════════════════════════════════════
+    # AFFICHAGE DU RÉSULTAT
+    # ═══════════════════════════════════════════════════════════════
+    print("\n" + "═" * 60)
+    print("📊 RÉSULTAT DE LA PRÉDICTION BATCH")
+    print("═" * 60)
+
+    if isinstance(result, dict):
+        # Lecture du fichier résultat
+        result_path = result.get("value") or result.get("path")
+        if result_path and os.path.exists(result_path):
+            df = pd.read_csv(result_path)
+            total = len(df)
+
+            # Statistiques
+            if "prediction" in df.columns:
+                restent = (df["prediction"] == "Reste").sum()
+                partent = (df["prediction"] == "Part").sum()
+            else:
+                restent = partent = 0
+
+            if "risk_level" in df.columns:
+                risque_eleve = (df["risk_level"] == "Élevé").sum()
+                risque_moyen = (df["risk_level"] == "Moyen").sum()
+                risque_faible = (df["risk_level"] == "Faible").sum()
+            else:
+                risque_eleve = risque_moyen = risque_faible = 0
+
+            # Affichage des stats
+            print(f"\n👥 Total employés analysés: {total}")
+            print(f"\n📈 Vont RESTER:  {restent} ({100 * restent / total:.1f}%)")
+            print(f"📉 Vont PARTIR:  {partent} ({100 * partent / total:.1f}%)")
+
+            print(f"\n🟢 Risque faible: {risque_faible}")
+            print(f"🟠 Risque moyen:  {risque_moyen}")
+            print(f"🔴 Risque élevé:  {risque_eleve}")
+
+            # Sauvegarde
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_file = os.path.join(SCRIPT_DIR, f"predictions_batch_{timestamp}.csv")
+            df.to_csv(output_file, index=False)
+
+            print("\n" + "─" * 60)
+            print(f"💾 Fichier sauvegardé: {os.path.basename(output_file)}")
+            print("─" * 60)
+
+            # Aperçu
+            print("\n📋 Aperçu des résultats:")
+            cols = ["employee_id", "prediction", "prob_depart", "risk_level"]
+            cols_exist = [c for c in cols if c in df.columns]
+            if cols_exist:
+                print(df[cols_exist].head(10).to_string(index=False))
+        else:
+            print(f"\n⚠️ Fichier résultat non trouvé: {result_path}")
+    else:
+        print(f"\n📋 Résultat: {result}")
+
+    print("\n✅ Prédiction batch terminée avec succès!")
 
-df = pd.DataFrame(predictions_data)
-timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-output_path = os.path.join(script_dir, f"predictions_batch_hf_{timestamp}.csv")
-df.to_csv(output_path, index=False, encoding="utf-8-sig")
-
-# Affichage résumé
-summary = result.get("summary", {})
-total = result.get("total_employees", len(predictions_data))
-
-print("\n" + "=" * 50)
-print("📊 RÉSULTATS DE LA PRÉDICTION BATCH")
-print("=" * 50)
-print(f"\n👥 Total employés analysés: {total}")
-print(f"✅ Vont rester:  {summary.get('total_stay', 'N/A')}")
-print(f"❌ Vont partir:  {summary.get('total_leave', 'N/A')}")
-print(f"\n🔴 Risque élevé:  {summary.get('high_risk_count', 'N/A')}")
-print(f"🟠 Risque moyen:  {summary.get('medium_risk_count', 'N/A')}")
-print(f"🟢 Risque faible: {summary.get('low_risk_count', 'N/A')}")
-
-print(f"\n💾 Résultats sauvegardés: {os.path.basename(output_path)}")
-print("\n✅ Prédiction batch terminée avec succès!")
+except Exception as e:
+    print(f"\n❌ Erreur: {e}")
+    sys.exit(1)

exemples/demo_unitaire.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-🔮 Prédiction UNITAIRE - Interface simple avec entrées numériques uniquement
+🔮 Prédiction UNITAIRE - API locale (Gradio)
 
 Usage: python demo_unitaire.py
-Note: Utilise l'API Gradio locale qui retourne du Markdown
+Prérequis: Lancer l'API locale avec `python app.py`
 """
 
 import re
@@ -19,10 +19,10 @@ except ImportError:
 # ═══════════════════════════════════════════════════════════════
 # CONFIGURATION
 # ═══════════════════════════════════════════════════════════════
-API_URL = "http://127.0.0.1:7860"  # API Gradio locale
+API_URL = "http://127.0.0.1:7860"
 
 # ═══════════════════════════════════════════════════════════════
-# OPTIONS À AFFICHER (pour référence utilisateur)
+# OPTIONS (menus numérotés)
 # ═══════════════════════════════════════════════════════════════
 DOMAINES = {
     1: "Infra & Cloud",
@@ -48,12 +48,12 @@ POSTES = {
 }
 
 print("╔══════════════════════════════════════════════════════════╗")
-print("║  🔮 PRÉDICTION UNITAIRE - Risque de départ employé       ║")
-print("║     (API locale - Entrées numériques uniquement)         ║")
-print("╚══════════════════════════════════════════════════════════╝\n")
+print("║  🔮 PRÉDICTION UNITAIRE - API Locale                     ║")
+print("╚══════════════════════════════════════════════════════════╝")
+print(f"\n🌐 API: {API_URL}\n")
 
 # ═══════════════════════════════════════════════════════════════
-# COLLECTE DES DONNÉES - Tout en nombres !
+# COLLECTE DES DONNÉES
 # ═══════════════════════════════════════════════════════════════
 
 print("═" * 60)
@@ -120,13 +120,13 @@ annees_entreprise = int(input("Années dans l'entreprise [0-40]: "))
 annees_poste = int(input("Années dans le poste actuel [0-18]: "))
 
 # ═══════════════════════════════════════════════════════════════
-# PRÉDICTION VIA GRADIO CLIENT
+# PRÉDICTION
 # ═══════════════════════════════════════════════════════════════
-print("\n⏳ Connexion à l'API Gradio locale...")
+print("\n⏳ Connexion à l'API...")
 
 try:
     client = Client(API_URL)
-    print("✅ Connecté\n")
+    print("✅ Connecté")
     print("⏳ Envoi de la prédiction...")
 
     result = client.predict(
@@ -163,45 +163,51 @@ try:
         api_name="/predict",
     )
 
+    # ═══════════════════════════════════════════════════════════════
+    # AFFICHAGE DU RÉSULTAT
+    # ═══════════════════════════════════════════════════════════════
     print("\n" + "═" * 60)
     print("📊 RÉSULTAT DE LA PRÉDICTION")
     print("═" * 60)
 
-    # Le résultat est du Markdown - on l'affiche directement
-    # mais on extrait aussi les valeurs clés
     if isinstance(result, str):
         # Extraire les probabilités du Markdown
         prob_depart = re.search(r"Probabilité de départ[^:]*:\s*([\d.]+)%", result)
         prob_maintien = re.search(r"Probabilité de maintien[^:]*:\s*([\d.]+)%", result)
         confiance = re.search(r"Confiance[^:]*:\s*([\d.]+)%", result)
 
-        # Détecter le risque
+        # Niveau de risque
         if "RISQUE ÉLEVÉ" in result:
-            print("\n🔴 RISQUE ÉLEVÉ DE DÉPART")
+            print("\n🔴 Niveau de risque: ÉLEVÉ")
         elif "RISQUE MOYEN" in result:
-            print("\n🟠 RISQUE MOYEN DE DÉPART")
+            print("\n🟠 Niveau de risque: MOYEN")
         else:
-            print("\n🟢 RISQUE FAIBLE DE DÉPART")
+            print("\n🟢 Niveau de risque: FAIBLE")
 
-        # Afficher les probabilités
+        # Probabilités
         if prob_maintien:
             print(f"\n📈 Probabilité de rester:  {prob_maintien.group(1)}%")
         if prob_depart:
             print(f"📉 Probabilité de partir: {prob_depart.group(1)}%")
         if confiance:
-            print(f"🎯 Confiance du modèle: {confiance.group(1)}%")
+            print(f"🎯 Confiance du modèle:   {confiance.group(1)}%")
 
-        # Afficher la prédiction
+        # Prédiction finale
+        print("\n" + "─" * 60)
         if "Départ probable" in result:
-            print("\n🚨 PRÉDICTION: VA PARTIR")
+            print("🚨 PRÉDICTION FINALE: VA PARTIR")
         else:
-            print("\n✅ PRÉDICTION: VA RESTER")
+            print("✅ PRÉDICTION FINALE: VA RESTER")
+        print("─" * 60)
     else:
         print(f"\n📋 Résultat: {result}")
 
+    print("\n✅ Prédiction unitaire terminée avec succès!")
+
 except ConnectionError:
-    print("\n❌ Impossible de se connecter à l'API Gradio locale.")
+    print("\n❌ Impossible de se connecter à l'API locale.")
     print("   Lancez d'abord: python app.py")
+    sys.exit(1)
 except Exception as e:
     print(f"\n❌ Erreur: {e}")
     sys.exit(1)

exemples/demo_unitaire_hf.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-🔮 Prédiction UNITAIRE via Hugging Face - Entrées numériques uniquement
+🔮 Prédiction UNITAIRE - API Hugging Face (Gradio)
 
 Usage: python demo_unitaire_hf.py
 Prérequis: pip install gradio_client
@@ -17,10 +17,13 @@ except ImportError:
     print("   pip install gradio_client")
     sys.exit(1)
 
+# ═══════════════════════════════════════════════════════════════
+# CONFIGURATION
+# ═══════════════════════════════════════════════════════════════
 API_URL = os.getenv("HF_API_URL", "https://asi-engineer-oc-p5.hf.space")
 
 # ═══════════════════════════════════════════════════════════════
-# OPTIONS À AFFICHER (pour référence utilisateur)
+# OPTIONS (menus numérotés)
 # ═══════════════════════════════════════════════════════════════
 DOMAINES = {
     1: "Infra & Cloud",
@@ -46,13 +49,12 @@ POSTES = {
 }
 
 print("╔══════════════════════════════════════════════════════════╗")
-print("║  🔮 PRÉDICTION UNITAIRE - Hugging Face Spaces            ║")
-print("║     (Entrées numériques uniquement)                      ║")
-print("╚══════════════════════════════════════════════════════════╝\n")
-print(f"🌐 API: {API_URL}\n")
+print("║  🔮 PRÉDICTION UNITAIRE - API Hugging Face               ║")
+print("╚══════════════════════════════════════════════════════════╝")
+print(f"\n🌐 API: {API_URL}\n")
 
 # ═══════════════════════════════════════════════════════════════
-# COLLECTE DES DONNÉES - Tout en nombres !
+# COLLECTE DES DONNÉES
 # ═══════════════════════════════════════════════════════════════
 
 print("═" * 60)
@@ -119,13 +121,13 @@ annees_entreprise = int(input("Années dans l'entreprise [0-40]: "))
 annees_poste = int(input("Années dans le poste actuel [0-18]: "))
 
 # ═══════════════════════════════════════════════════════════════
-# PRÉDICTION VIA GRADIO CLIENT
+# PRÉDICTION
 # ═══════════════════════════════════════════════════════════════
-print("\n⏳ Connexion à l'API Gradio HF...")
+print("\n⏳ Connexion à l'API...")
 
 try:
     client = Client(API_URL)
-    print("✅ Connecté\n")
+    print("✅ Connecté")
     print("⏳ Envoi de la prédiction...")
 
     result = client.predict(
@@ -162,41 +164,47 @@ try:
         api_name="/predict",
     )
 
+    # ═══════════════════════════════════════════════════════════════
+    # AFFICHAGE DU RÉSULTAT
+    # ═══════════════════════════════════════════════════════════════
     print("\n" + "═" * 60)
-    print("📊 RÉSULTAT DE LA PRÉDICTION (HF)")
+    print("📊 RÉSULTAT DE LA PRÉDICTION")
     print("═" * 60)
 
-    # Le résultat est du Markdown - on extrait les valeurs clés
     if isinstance(result, str):
         # Extraire les probabilités du Markdown
         prob_depart = re.search(r"Probabilité de départ[^:]*:\s*([\d.]+)%", result)
         prob_maintien = re.search(r"Probabilité de maintien[^:]*:\s*([\d.]+)%", result)
         confiance = re.search(r"Confiance[^:]*:\s*([\d.]+)%", result)
 
-        # Détecter le risque
+        # Niveau de risque
         if "RISQUE ÉLEVÉ" in result:
-            print("\n🔴 RISQUE ÉLEVÉ DE DÉPART")
+            print("\n🔴 Niveau de risque: ÉLEVÉ")
         elif "RISQUE MOYEN" in result:
-            print("\n🟠 RISQUE MOYEN DE DÉPART")
+            print("\n🟠 Niveau de risque: MOYEN")
         else:
-            print("\n🟢 RISQUE FAIBLE DE DÉPART")
+            print("\n🟢 Niveau de risque: FAIBLE")
 
-        # Afficher les probabilités
+        # Probabilités
         if prob_maintien:
             print(f"\n📈 Probabilité de rester:  {prob_maintien.group(1)}%")
         if prob_depart:
             print(f"📉 Probabilité de partir: {prob_depart.group(1)}%")
         if confiance:
-            print(f"🎯 Confiance du modèle: {confiance.group(1)}%")
+            print(f"🎯 Confiance du modèle:   {confiance.group(1)}%")
 
-        # Afficher la prédiction
+        # Prédiction finale
+        print("\n" + "─" * 60)
         if "Départ probable" in result:
-            print("\n🚨 PRÉDICTION: VA PARTIR")
+            print("🚨 PRÉDICTION FINALE: VA PARTIR")
         else:
-            print("\n✅ PRÉDICTION: VA RESTER")
+            print("✅ PRÉDICTION FINALE: VA RESTER")
+        print("─" * 60)
     else:
         print(f"\n📋 Résultat: {result}")
 
+    print("\n✅ Prédiction unitaire terminée avec succès!")
+
 except Exception as e:
     print(f"\n❌ Erreur: {e}")
     sys.exit(1)