m

app.py

@@ -377,189 +377,92 @@ def preprocess_sound(df):
 
 
 def xgb_predict_safe(model, X, label_encoder=None):
-    # Sécurité ultime : forcer exactement les features du booster
     booster_features = model.get_booster().feature_names
     X_safe = X.reindex(columns=booster_features, fill_value=0.0).astype(np.float32)
     
-    dmatrix = xgb.DMatrix(
-        X_safe.values,
-        feature_names=booster_features
-    )
+    dmatrix = xgb.DMatrix(X_safe.values, feature_names=list(booster_features))
 
     pred = model.get_booster().predict(dmatrix)[0]
 
     if label_encoder is not None:
-        return label_encoder.inverse_transform([int(round(pred))])[0]
+        # label_encoder est une liste de classes
+        pred_int = int(round(pred))
+        if pred_int < 0: pred_int = 0
+        if pred_int >= len(label_encoder): pred_int = len(label_encoder) - 1
+        return label_encoder[pred_int]
 
     return pred
 
 
 # -------- Gradio --------
-def predict_with_metadata(url):
 
+def predict_with_metadata(url):
     if url.strip() == "":
-
         return "❌ Veuillez entrer une URL FreeSound."
 
-    # 1️ Récupérer les métadonnées brutes
+    # 1️⃣ Récupérer les métadonnées brutes
     df_raw = fetch_sound_metadata(url)
-    # Affichage ligne par ligne pour les métadonnées brutes
     raw_lines = ["=== Métadonnées brutes ==="]
-
     for col in df_raw.columns:
         raw_lines.append(f"{col}: {df_raw[col].iloc[0]}")
     raw_str = "\n".join(raw_lines)
 
-
-    # 2️ Vérifier la durée
-
+    # 2️⃣ Vérifier la durée
     dur = df_raw["duration"].iloc[0]
-
     if dur < 0.5:
-
-        return raw_str + f"\n\n Son trop court ({dur} sec), veuillez entrer un son qui est court (0.5 à 3 s) ou  un son long (10 à 60 s)"
-
+        return raw_str + f"\n\n❌ Son trop court ({dur} sec). Plage acceptée: 0.5-3 ou 10-60 sec"
     elif 3 < dur < 10 or dur > 60:
+        return raw_str + f"\n\n❌ Son hors plage ({dur} sec). Plage acceptée: 0.5-3 ou 10-60 sec"
 
-        return raw_str + f"\n\n Son trop long ou hors plage acceptable ({dur} sec) , veuillez entrer un son qui est court (0.5 à 3 s) ou  un son long (10 à 60 s)"
-
-
-
-    # 3️ Prétraitement seulement si durée ok
-
+    # 3️⃣ Prétraitement
     df_processed = preprocess_sound(df_raw)
-
-
-
-    # Supprimer les colonnes inutiles
-
     cols_to_remove = ["avg_rating", "num_downloads_class"]
-
     df_for_model = df_processed.drop(columns=[c for c in cols_to_remove if c in df_processed.columns])
 
-
-
-    # Choix modèle
-
+    # 4️⃣ Choix modèle selon durée
     if 0.5 <= dur <= 3:
-
-        model_features = effect_model_features
-
         model_nd = effect_model_num_downloads
-
         model_ar = effect_model_avg_rating
-
-        le_ar = effect_avg_rating_le
-
+        model_features = effect_model_features
         sound_type = "EffectSound"
-
     else:
-
-        model_features = music_model_features
-
         model_nd = music_model_num_downloads
-
         model_ar = music_model_avg_rating
-
-        le_ar = music_avg_rating_le
-
+        model_features = music_model_features
         sound_type = "Music"
 
-
-
-    # 🔹 Forcer exactement les colonnes du modèle
-
-    expected_n_cols = len(model_features)
-
-
-
-    # Supprimer tout ce qui n'est pas dans le modèle
-
-    df_for_model = df_for_model[[c for c in model_features if c in df_for_model.columns]]
-
-
-
-    # Ajouter les colonnes manquantes avec 0
-
-    for col in model_features:
-
-        if col not in df_for_model.columns:
-
-            df_for_model[col] = 0.0
-
-
-
-    # Réordonner exactement
-
+    # 5️⃣ Forcer exactement les colonnes du modèle
     df_for_model = df_for_model.reindex(columns=model_features, fill_value=0.0).astype(float)
 
+    # 6️⃣ DMatrix XGBoost
+    dmatrix = xgb.DMatrix(df_for_model.values, feature_names=list(df_for_model.columns))
 
 
-    # Dernière sécurité : si encore mismatch, tronquer ou ajouter des colonnes fictives
-    """
-    if df_for_model.shape[1] != expected_n_cols:
-        diff = expected_n_cols - df_for_model.shape[1]
-        if diff > 0:
-            for i in range(diff):
-                df_for_model[f"extra_col_{i}"] = 0.0
-        elif diff < 0:
-            df_for_model = df_for_model.iloc[:, :expected_n_cols]
-    """
-    # Prédictions
-    pred_num_downloads = xgb_predict_safe(
-    model_nd,
-    df_for_model,
-    model_features
-    )
-
-    pred_avg_rating = xgb_predict_safe(
-        model_ar,
-        df_for_model,
-        model_features,
-        label_encoder=le_ar
-    )
-
-    #pred_num_downloads = model_nd.predict(df_for_model)[0]
+    # 7️⃣ Faire les prédictions
+    NUM_DOWNLOADS_MAP = {0: "Low", 1: "Medium", 2: "High"}
 
-    #pred_avg_rating_enc = model_ar.predict(df_for_model)[0]
+    pred_num_downloads_int = int(model_nd.get_booster().predict(dmatrix)[0])
+    pred_avg_rating_int = int(model_ar.get_booster().predict(dmatrix)[0])
 
-    #pred_avg_rating = le_ar.inverse_transform([pred_avg_rating_enc])[0]
-
-
-
-    # Affichage ligne par ligne pour les features apr��s preprocessing
+    pred_num_downloads = NUM_DOWNLOADS_MAP.get(pred_num_downloads_int, str(pred_num_downloads_int))
+    pred_avg_rating = NUM_DOWNLOADS_MAP.get(pred_avg_rating_int, str(pred_avg_rating_int))
 
+    # 8️⃣ Affichage des features prétraitées
     processed_lines = ["\n=== Features après preprocessing ==="]
-
     for col in df_processed.columns:
-
         processed_lines.append(f"{col}: {df_processed[col].iloc[0]}")
-
     processed_str = "\n".join(processed_lines)
 
-   
-
+    # 9️ Résultat final
     prediction_lines = [
-
-        "\n===  Prédictions ===",
-
+        "\n=== Prédictions ===",
         f"Type détecté : {sound_type}",
-
         f"📥 Num downloads prédit : {pred_num_downloads}",
-
         f"⭐ Avg rating prédit : {pred_avg_rating}"
-
     ]
-
-
-
     prediction_str = "\n".join(prediction_lines)
 
-
-
-    return 'rien à afficher'
-
-
+    return raw_str + processed_str + prediction_str
 
 
 def preprocess_name(df, vec_dim=8):