updtae app.py

app.py

@@ -10,6 +10,9 @@ import freesound
 import gensim.downloader as api
 from huggingface_hub import hf_hub_download
 
+import xgboost as xgb
+
+
 # -------- FreeSound API --------
 client = freesound.FreesoundClient()
 client.set_token("zE9NjEOgUMzH9K7mjiGBaPJiNwJLjSM53LevarRK", "token")
@@ -111,18 +114,39 @@ effect_avg_rating_le = joblib.load(
 )
 
 
-# Liste des colonnes utilisées pour les modèles (même ordre que pendant le training)
+
+
+# Charger les listes de colonnes exactes utilisées pendant l'entraînement
 music_model_features = joblib.load(
     hf_hub_download(
         repo_id="NIIHAAD/freesound-models",
         repo_type="model",
-        filename="model_features_list.joblib",
+        filename="music_model_features_list.joblib",
+        cache_dir="models_cache"
+    )
+)
+
+effect_model_features = joblib.load(
+    hf_hub_download(
+        repo_id="NIIHAAD/freesound-models",
+        repo_type="model",
+        filename="effect_model_features_list.joblib",
         cache_dir="models_cache"
     )
 )
 
+# Charger les listes
+music_model_features_raw = music_model_features
+effect_model_features_raw = effect_model_features 
 
 
+# NETTOYAGE : Supprimer les doublons en gardant l'ordre
+music_model_features = list(dict.fromkeys(music_model_features_raw))
+effect_model_features = list(dict.fromkeys(effect_model_features_raw))
+
+print(f"Après nettoyage - Music: {len(music_model_features)} features")
+print(f"Après nettoyage - Effect: {len(effect_model_features)} features")
+
 # EffectSound
 scaler_samplerate_effect = joblib.load("effectSound/scaler_effectSamplerate.joblib")
 scaler_age_days_effect = joblib.load("effectSound/scaler_effectSound_age_days_log.joblib")
@@ -135,7 +159,17 @@ effect_onehot_tags = joblib.load("effectSound/effect_onehot_tags.joblib")
 
 # GloVe pour description
 glove_model = api.load("glove-wiki-gigaword-100")
+# --- AJOUTE LE CODE ICI ---
+print("--- DIAGNOSTIC DES FEATURES ---")
+print(f"Nombre de features Music : {len(music_model_features)}")
+print(f"Doublons dans Music : {len(music_model_features) - len(set(music_model_features))}")
+
+print(f"Nombre de features Effect : {len(effect_model_features)}")
+print(f"Doublons dans Effect : {len(effect_model_features) - len(set(effect_model_features))}")
+print("-------------------------------")
 
+
+# ---------------------------
 # -------- Fonctions --------
 
 def fetch_sound_metadata(sound_url):
@@ -283,12 +317,21 @@ def preprocess_sound(df):
         df["tags_list"] = [["Other"]]
 
     # One-hot sur toutes les colonnes enregistrées
+    # 1️ Créer toutes les colonnes attendues avec 0
     for col in onehot_tags:
-        tag_name = col.replace("tag_", "").replace("_", " ")
-        df[col] = int(tag_name in df["tags_list"].iloc[0])
+        if col not in df.columns:
+            df[col] = 0
+
+    # 2️ Activer seulement les colonnes correspondant aux tags existants
+    tags_list = df["tags"].iloc[0].lower().split(",") if df["tags"].iloc[0] else []
+    for col in onehot_tags:
+        tag_name = col.replace("tag_", "").lower()
+        if tag_name in tags_list:
+            df[col] = 1
+
+    # 3️ Supprimer la colonne temporaire
+    df.drop(columns=["tags"], inplace=True)
 
-    # Supprimer les colonnes temporaires
-    df.drop(columns=["tags_list", "tags"], inplace=True)
 
 
     # Name
@@ -308,7 +351,7 @@ def preprocess_sound(df):
     df.drop(columns=[ "license","category","type","created","subcategory","id","num_downloads","file_path","username"],inplace=True, errors="ignore")
 
     # --- SAFE REORDER (CRUCIAL) ---
-
+    """
     final_cols = []
 
     for col in onehot_cols:
@@ -324,87 +367,200 @@ def preprocess_sound(df):
     final_cols += [c for c in df.columns if c not in final_cols]
 
     df = df[final_cols]
+    """
 
 
 
 
     return df
 
+
+
+def xgb_predict_safe(model, X, feature_names, label_encoder=None):
+    # sécurité ultime
+    X = X[feature_names].astype(np.float32)
+
+    dmatrix = xgb.DMatrix(
+        X.values,
+        feature_names=feature_names
+    )
+
+    pred = model.get_booster().predict(dmatrix)[0]
+
+    if label_encoder is not None:
+        return label_encoder.inverse_transform([int(round(pred))])[0]
+
+    return pred
+
+
 # -------- Gradio --------
 def predict_with_metadata(url):
+
     if url.strip() == "":
+
         return "❌ Veuillez entrer une URL FreeSound."
 
     # 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
+
     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)"
+
     elif 3 < dur < 10 or dur > 60:
+
         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)"
 
-    # PRÉDICTIONS
-    # =======================
+
+
+    # 3️ Prétraitement seulement si durée ok
+
+    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
 
     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
+
         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
+
         sound_type = "Music"
 
-    # 3️ Prétraitement seulement si durée ok
-    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])
 
-    # Réordonner les colonnes selon la liste sauvegardée pour le training
-    df_for_model = df_for_model[music_model_features]
+    # 🔹 Forcer exactement les colonnes du modèle
 
+    expected_n_cols = len(model_features)
 
-    # Num downloads
-    pred_num_downloads = model_nd.predict(df_for_model)[0]
 
-    # Avg rating
-    pred_avg_rating_enc = model_ar.predict(df_for_model)[0]
-    pred_avg_rating = le_ar.inverse_transform([pred_avg_rating_enc])[0]
 
-    
+    # 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
+
+    df_for_model = df_for_model.reindex(columns=model_features, fill_value=0.0).astype(float)
+
+
+
+    # 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]
+
+    #pred_avg_rating_enc = model_ar.predict(df_for_model)[0]
+
+    #pred_avg_rating = le_ar.inverse_transform([pred_avg_rating_enc])[0]
 
 
 
     # Affichage ligne par ligne pour les features après preprocessing
+
     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)
-    
+
+   
+
     prediction_lines = [
+
         "\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 raw_str + processed_str + prediction_str
 
 
+
+
 def preprocess_name(df, vec_dim=8):
     df = df.copy()