modif interpretation results

app.py

@@ -1,3 +1,4 @@
+# app.py
 import os
 import tempfile
 import numpy as np
@@ -11,82 +12,107 @@ import opensmile
 
 import freesound
 import xgboost as xgb
-from sklearn.feature_extraction.text import HashingVectorizer
 
+# (Optionnel) GloVe via gensim (si dispo / autorisé)
+try:
+    import gensim.downloader as api
+    _GENSIM_OK = True
+except Exception:
+    _GENSIM_OK = False
 
-# ============================================================
-# CONFIG
-# ============================================================
+
+# =========================
+# RÈGLES DURÉE
+# =========================
 MIN_EFFECT, MAX_EFFECT = 0.5, 3.0
 MIN_MUSIC, MAX_MUSIC = 10.0, 60.0
 SR_TARGET = 16000
 
-# HF Space Secret: FREESOUND_TOKEN
-FREESOUND_TOKEN = os.getenv("FREESOUND_TOKEN", "").strip()
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-
-def p(*parts):
-    return os.path.join(BASE_DIR, *parts)
-
-def exists(relpath: str) -> bool:
-    return os.path.exists(p(relpath))
-
-def load_local(relpath: str):
-    full = p(relpath)
-    if not os.path.exists(full):
-        raise FileNotFoundError(f"Fichier introuvable: {relpath}")
-    return joblib.load(full)
-
-def safe_float(v):
-    try:
-        return float(v)
-    except Exception:
-        return 0.0
 
-def parse_sound_id(url: str) -> int:
-    return int(url.rstrip("/").split("/")[-1])
+# =========================
+# HELPERS LOAD
+# =========================
+def load_artifact(*candidate_paths: str):
+    """
+    Charge un artifact joblib/pkl depuis la racine ou chemins candidats.
+    Essaie tous les chemins donnés, puis lève une erreur claire.
+    """
+    for p in candidate_paths:
+        if p and os.path.exists(p):
+            return joblib.load(p)
+    tried = "\n".join([f"- {p}" for p in candidate_paths if p])
+    raise FileNotFoundError(
+        "Artifact introuvable. J'ai essayé :\n" + (tried if tried else "(aucun chemin)")
+    )
 
 
-# ============================================================
-# UI helpers
-# ============================================================
+# =========================
+# UI (CSS)
+# =========================
 CSS = """
-.card { border: 1px solid #e5e7eb; background: #ffffff; padding: 16px; border-radius: 16px; }
-.card-error{ border-color: #fca5a5; background: #fff1f2; }
-.card-warn{ border-color: #fcd34d; background: #fffbeb; }
-.card-title{ font-weight: 950; margin-bottom: 8px; }
-.badges{ display:flex; gap:10px; flex-wrap:wrap; margin-bottom:12px; }
-.badge{ padding:6px 10px; border-radius:999px; font-weight:900; font-size: 13px; border: 1px solid #e5e7eb; }
+.card {
+  border: 1px solid #e5e7eb;
+  background: #ffffff;
+  padding: 16px;
+  border-radius: 16px;
+}
+.card-error{
+  border-color: #fca5a5;
+  background: #fff1f2;
+}
+.card-title{
+  font-weight: 950;
+  margin-bottom: 8px;
+}
+.badges{
+  display:flex;
+  gap:10px;
+  flex-wrap:wrap;
+  margin-bottom:12px;
+}
+.badge{
+  padding:6px 10px;
+  border-radius:999px;
+  font-weight:900;
+  font-size: 13px;
+  border: 1px solid #e5e7eb;
+}
 .badge-type{ background:#eef2ff; color:#3730a3;}
 .badge-time{ background:#ecfeff; color:#155e75;}
-.grid{ display:grid; grid-template-columns: 1fr; gap:10px; }
-.box{ border:1px solid #e5e7eb; border-radius:14px; padding:12px; background:#fafafa; }
+
+.grid{
+  display:grid;
+  grid-template-columns: 1fr;
+  gap:10px;
+}
+.box{
+  border:1px solid #e5e7eb;
+  border-radius:14px;
+  padding:12px;
+  background:#fafafa;
+}
 .box-title{ font-weight:900; margin-bottom:4px; }
 .box-value{ font-size:18px; font-weight:800; }
-.hint{ margin-top:10px; color:#6b7280; font-size:12px; }
+
+.hint{
+  margin-top:10px;
+  color:#6b7280;
+  font-size:12px;
+}
+
 #header-title { font-size: 28px; font-weight: 950; margin-bottom: 6px; }
 #header-sub { color:#6b7280; margin-top:0px; line-height:1.45; }
-pre{ white-space:pre-wrap; }
 """
 
-def html_box(title, body, kind=""):
-    cls = "card"
-    if kind == "error":
-        cls += " card-error"
-    elif kind == "warn":
-        cls += " card-warn"
+
+def html_error(title, body_html):
     return f"""
-<div class="{cls}">
-  <div class="card-title">{title}</div>
-  <div>{body}</div>
+<div class="card card-error">
+  <div class="card-title">❌ {title}</div>
+  <div>{body_html}</div>
 </div>
 """.strip()
 
-def html_error(title, body_html):
-    return html_box(f"❌ {title}", body_html, kind="error")
-
-def html_warn(title, body_html):
-    return html_box(f"⚠️ {title}", body_html, kind="warn")
 
 def html_result(badge_text, duration, rating_text, downloads_text, extra_html=""):
     return f"""
@@ -95,6 +121,7 @@ def html_result(badge_text, duration, rating_text, downloads_text, extra_html=""
     <span class="badge badge-type">{badge_text}</span>
     <span class="badge badge-time">⏱️ {duration:.2f} s</span>
   </div>
+
   <div class="grid">
     <div class="box">
       <div class="box-title">📈 Popularité de la note moyenne</div>
@@ -105,37 +132,70 @@ def html_result(badge_text, duration, rating_text, downloads_text, extra_html=""
       <div class="box-value">{downloads_text}</div>
     </div>
   </div>
+
   {extra_html}
-  <div class="hint">Résultats en <b>niveaux</b> (faible / moyen / élevé), pas en valeurs exactes.</div>
+
+  <div class="hint">
+    Résultats affichés en <b>niveaux</b> (faible / moyen / élevé), pas en valeurs exactes.
+  </div>
 </div>
 """.strip()
 
+
+# =========================
+# INTERPRETATION (COMMUNE)
+# =========================
 def interpret_results(avg_class: int, dl_class: int) -> str:
+    """
+    avg_class: 0=Missed info, 1=Low, 2=Medium, 3=High
+    dl_class: 0=Low, 1=Medium, 2=High
+    """
     if avg_class == 0:
-        return "ℹ️ <b>Interprétation</b> :<br>Aucune évaluation possible (rating manquant / indisponible)."
+        return (
+            "ℹ️ <b>Interprétation</b> :<br>"
+            "Aucune évaluation possible (rating manquant)."
+        )
 
     if avg_class == 3 and dl_class == 2:
-        potentiel, detail = "très fort", "contenu de haute qualité et très populaire."
+        potentiel = "très fort"
+        detail = "contenu de haute qualité et très populaire."
     elif avg_class == 3 and dl_class == 1:
-        potentiel, detail = "fort", "contenu bien apprécié, en croissance."
+        potentiel = "fort"
+        detail = "contenu bien apprécié, en croissance."
     elif avg_class == 3 and dl_class == 0:
-        potentiel, detail = "prometteur", "bonne qualité mais faible visibilité."
+        potentiel = "prometteur"
+        detail = "bonne qualité mais faible visibilité (peut gagner en popularité)."
     elif avg_class == 2 and dl_class == 2:
-        potentiel, detail = "modéré à fort", "populaire mais qualité perçue moyenne."
+        potentiel = "modéré à fort"
+        detail = "populaire mais qualité perçue moyenne."
     elif avg_class == 2 and dl_class == 1:
-        potentiel, detail = "modéré", "profil standard, popularité stable."
+        potentiel = "modéré"
+        detail = "profil standard, popularité stable."
     elif avg_class == 2 and dl_class == 0:
-        potentiel, detail = "limité", "engagement faible, diffusion limitée."
+        potentiel = "limité"
+        detail = "engagement faible, diffusion limitée."
     elif avg_class == 1 and dl_class == 2:
-        potentiel, detail = "contradictoire", "très téléchargé mais peu apprécié."
+        potentiel = "contradictoire"
+        detail = "très téléchargé mais peu apprécié (usage pratique possible)."
     elif avg_class == 1 and dl_class == 1:
-        potentiel, detail = "faible", "peu attractif."
+        potentiel = "faible"
+        detail = "peu attractif pour les utilisateurs."
     else:
-        potentiel, detail = "très faible", "faible intérêt global."
+        potentiel = "très faible"
+        detail = "faible intérêt global."
+
+    return (
+        "<b>Interprétation</b> :<br>"
+        f"Potentiel estimé : <b>{potentiel}</b> — {detail}"
+    )
 
-    return f"<b>Interprétation</b> :<br>Potentiel estimé : <b>{potentiel}</b> — {detail}"
 
 def avg_label_to_class(avg_label: str) -> int:
+    """
+    Convertit un label texte (LabelEncoder) en classe 0..3 :
+    0=Missed info, 1=Low, 2=Medium, 3=High
+    Robuste aux variantes.
+    """
     if avg_label is None:
         return 0
     s = str(avg_label).strip().lower()
@@ -150,89 +210,38 @@ def avg_label_to_class(avg_label: str) -> int:
     return 0
 
 
-# ============================================================
-# FreeSound client
-# ============================================================
-def get_fs_client():
-    if not FREESOUND_TOKEN:
-        raise RuntimeError("Token FreeSound manquant. Ajoute le secret FREESOUND_TOKEN dans le Space.")
-    c = freesound.FreesoundClient()
-    c.set_token(FREESOUND_TOKEN, "token")
-    return c
+# =========================
+# FreeSound client (commun)
+# =========================
+API_TOKEN = os.getenv("FREESOUND_TOKEN", "").strip()
+fs_client = freesound.FreesoundClient()
+if API_TOKEN:
+    fs_client.set_token(API_TOKEN, "token")
 
 
 # ============================================================
-# DIAGNOSTIC FILE LISTS
+# ONGLET 1 — Upload audio → openSMILE → modèle local
 # ============================================================
-FILES_A = [
-    "xgb_model_EffectSound.pkl",
-    "xgb_model_Music.pkl",
-]
-
-FILES_B = [
-    "xgb_num_downloads_effectsound_model.pkl",
-    "xgb_num_downloads_effectsound_features.pkl",
-    "xgb_avg_rating_effectsound_model.pkl",
-    "xgb_avg_rating_effectsound_features.pkl",
-    "xgb_avg_rating_effectsound_label_encoder.pkl",
-    "xgb_num_downloads_music_model.pkl",
-    "xgb_num_downloads_music_features.pkl",
-    "xgb_avg_rating_music_model.pkl",
-    "xgb_avg_rating_music_features.pkl",
-    "xgb_avg_rating_music_label_encoder.pkl",
-]
-
-FILES_C_ROOT = [
-    "effectSound_model_num_downloads.joblib",
-    "effectSound_xgb_avg_rating.joblib",
-    "effectSound_xgb_avg_rating_label_encoder.joblib",
-    "effect_model_features_list.joblib",
-    "music_model_num_downloads.joblib",
-    "music_xgb_avg_rating.joblib",
-    "music_xgb_avg_rating_label_encoder.joblib",
-    # feature list music: tu as les deux, on accepte l’un ou l’autre
-    # "music_model_features_list.joblib" OU "model_features_list.joblib"
-]
-
-FILES_C_EFFECT_DIR = [
-    "effectSound/scaler_effectSamplerate.joblib",
-    "effectSound/scaler_effectSound_age_days_log.joblib",
-    "effectSound/username_freq_dict_effectSound.joblib",
-    "effectSound/est_num_downloads_effectSound.joblib",
-    "effectSound/avg_rating_transformer_effectSound.joblib",
-    "effectSound/effectSound_subcategory_cols.joblib",
-    "effectSound/effectSound_onehot_cols.joblib",
-    "effectSound/effect_onehot_tags.joblib",
-]
-
-FILES_C_MUSIC_DIR = [
-    "music/scaler_music_samplerate.joblib",
-    "music/scaler_music_age_days_log.joblib",
-    "music/username_freq_dict_music.joblib",
-    "music/est_num_downloads_music.joblib",
-    "music/avg_rating_transformer_music.joblib",
-    "music/music_subcategory_cols.joblib",
-    "music/music_onehot_cols.joblib",
-    "music/music_onehot_tags.joblib",
-]
-
-
-# ============================================================
-# PARTIE A — OpenSMILE upload
-# ============================================================
-A_MODELS = {}
-
-def load_A_models():
-    A_MODELS["effect"] = load_local("xgb_model_EffectSound.pkl")
-    A_MODELS["music"] = load_local("xgb_model_Music.pkl")
+MODEL_EFFECT = load_artifact("xgb_model_EffectSound.pkl")
+MODEL_MUSIC = load_artifact("xgb_model_Music.pkl")
+
+RATING_DISPLAY_AUDIO = {
+    0: "❌ Informations manquantes",
+    1: "⭐ Faible",
+    2: "⭐⭐ Moyen",
+    3: "⭐⭐⭐ Élevé",
+}
+DOWNLOADS_DISPLAY_AUDIO = {
+    0: "⭐ Faible",
+    1: "⭐⭐ Moyen",
+    2: "⭐⭐⭐ Élevé",
+}
 
 SMILE = opensmile.Smile(
     feature_set=opensmile.FeatureSet.eGeMAPSv02,
     feature_level=opensmile.FeatureLevel.Functionals,
 )
 
-RATING_DISPLAY_AUDIO = {0: "❌ Informations manquantes", 1: "⭐ Faible", 2: "⭐⭐ Moyen", 3: "⭐⭐⭐ Élevé"}
-DOWNLOADS_DISPLAY_AUDIO = {0: "⭐ Faible", 1: "⭐⭐ Moyen", 2: "⭐⭐⭐ Élevé"}
 
 def get_duration_seconds(filepath):
     ext = os.path.splitext(filepath)[1].lower()
@@ -242,6 +251,7 @@ def get_duration_seconds(filepath):
     with sf.SoundFile(filepath) as f:
         return len(f) / f.samplerate
 
+
 def to_wav_16k_mono(filepath):
     ext = os.path.splitext(filepath)[1].lower()
     if ext == ".wav":
@@ -254,103 +264,136 @@ def to_wav_16k_mono(filepath):
 
     audio = AudioSegment.from_file(filepath)
     audio = audio.set_channels(1).set_frame_rate(SR_TARGET)
+
     tmp = tempfile.NamedTemporaryFile(suffix=".wav", delete=False)
     tmp.close()
     audio.export(tmp.name, format="wav")
     return tmp.name
 
+
 def extract_opensmile_features(filepath):
     wav_path = to_wav_16k_mono(filepath)
     feats = SMILE.process_file(wav_path)
     feats = feats.select_dtypes(include=[np.number]).reset_index(drop=True)
     return feats
 
+
 def predict_upload_with_dmatrix(model, X_df: pd.DataFrame):
+    """
+    Résout 'data did not contain feature names' en passant via Booster + DMatrix(feature_names=...).
+    Retour: array shape (1, n_outputs)
+    """
+    if hasattr(model, "estimators_"):
+        preds = []
+        for est in model.estimators_:
+            booster = est.get_booster() if hasattr(est, "get_booster") else est
+            dm = xgb.DMatrix(X_df.values, feature_names=list(X_df.columns))
+            p = booster.predict(dm)
+            preds.append(np.asarray(p).reshape(-1))
+        return np.column_stack(preds)
+
     booster = model.get_booster() if hasattr(model, "get_booster") else model
     dm = xgb.DMatrix(X_df.values, feature_names=list(X_df.columns))
-    p_ = booster.predict(dm)
-    return np.asarray(p_).reshape(1, -1)
+    p = booster.predict(dm)
+    return np.asarray(p).reshape(1, -1)
 
-def predict_opensmile_upload(audio_file):
+
+def predict_from_uploaded_audio(audio_file):
     if audio_file is None:
         return html_error("Aucun fichier", "Veuillez importer un fichier audio (wav, mp3, flac…).")
 
+    # Durée
     try:
         duration = get_duration_seconds(audio_file)
     except Exception as e:
-        return html_error("Audio illisible", f"Détail : <code>{e}</code>")
+        return html_error("Audio illisible", f"Impossible de lire l'audio.<br>Détail : <code>{e}</code>")
 
+    # Vérif durées
     if duration < MIN_EFFECT:
-        return html_error("Audio trop court", f"Durée : <b>{duration:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
-    if (MAX_EFFECT < duration < MIN_MUSIC) or duration > MAX_MUSIC:
-        return html_error("Audio hors plage", f"Durée : <b>{duration:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
-
-    try:
-        if not A_MODELS:
-            load_A_models()
-    except Exception as e:
-        return html_error("Modèles OpenSMILE manquants", f"Détail : <code>{e}</code>")
+        return html_error(
+            "Audio trop court",
+            f"Durée détectée : <b>{duration:.2f} s</b><br><br>"
+            f"Plages acceptées :<br>"
+            f"• Effet sonore : <b>{MIN_EFFECT}–{MAX_EFFECT} s</b><br>"
+            f"• Musique : <b>{MIN_MUSIC}–{MAX_MUSIC} s</b>"
+        )
 
+    if (MAX_EFFECT < duration < MIN_MUSIC) or duration > MAX_MUSIC:
+        return html_error(
+            "Audio hors plage",
+            f"Durée détectée : <b>{duration:.2f} s</b><br><br>"
+            f"Plages acceptées :<br>"
+            f"• Effet sonore : <b>{MIN_EFFECT}–{MAX_EFFECT} s</b><br>"
+            f"• Musique : <b>{MIN_MUSIC}–{MAX_MUSIC} s</b>"
+        )
+
+    # Type + modèle
     if duration <= MAX_EFFECT:
-        badge = "🔊 OpenSMILE (upload) — EffectSound"
-        model = A_MODELS["effect"]
+        badge = "🔊 Effet sonore (upload)"
+        model = MODEL_EFFECT
     else:
-        badge = "🎵 OpenSMILE (upload) — Music"
-        model = A_MODELS["music"]
+        badge = "🎵 Musique (upload)"
+        model = MODEL_MUSIC
 
+    # openSMILE
     try:
         X = extract_opensmile_features(audio_file)
     except Exception as e:
         return html_error("Extraction openSMILE échouée", f"Détail : <code>{e}</code>")
 
+    # Align features
     try:
-        expected = model.feature_names_in_ if hasattr(model, "feature_names_in_") else list(X.columns)
+        expected = model.estimators_[0].feature_names_in_ if hasattr(model, "estimators_") else model.feature_names_in_
         X = X.reindex(columns=list(expected), fill_value=0)
     except Exception as e:
-        return html_error("Alignement features échoué", f"Détail : <code>{e}</code>")
+        return html_error("Alignement des features échoué", f"Détail : <code>{e}</code>")
 
+    # Predict
     try:
         y = predict_upload_with_dmatrix(model, X)
     except Exception as e:
         return html_error("Prédiction échouée", f"Détail : <code>{e}</code>")
 
+    y = np.array(y)
     avg_class = int(y[0, 0])
     dl_class = int(y[0, 1])
 
     rating_text = RATING_DISPLAY_AUDIO.get(avg_class, "Inconnu")
     downloads_text = DOWNLOADS_DISPLAY_AUDIO.get(dl_class, "Inconnu")
 
+    conclusion = interpret_results(avg_class, dl_class)
     extra = f"""
 <div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-{interpret_results(avg_class, dl_class)}
+{conclusion}
 </div>
 """
     return html_result(badge, duration, rating_text, downloads_text, extra_html=extra)
 
 
 # ============================================================
-# PARTIE B — FreeSound API acoustic features
+# ONGLET 2 — URL FreeSound → features API → modèles locaux
 # ============================================================
-B_MODELS = {}
+xgb_music_num = load_artifact("xgb_num_downloads_music_model.pkl")
+xgb_music_feat_num = load_artifact("xgb_num_downloads_music_features.pkl")
+xgb_music_avg = load_artifact("xgb_avg_rating_music_model.pkl")
+xgb_music_feat_avg = load_artifact("xgb_avg_rating_music_features.pkl")
+le_music_avg = load_artifact("xgb_avg_rating_music_label_encoder.pkl")
 
-def load_B_models():
-    # downloads
-    B_MODELS["eff_num_model"] = load_local("xgb_num_downloads_effectsound_model.pkl")
-    B_MODELS["eff_num_feats"] = load_local("xgb_num_downloads_effectsound_features.pkl")
+xgb_effect_num = load_artifact("xgb_num_downloads_effectsound_model.pkl")
+xgb_effect_feat_num = load_artifact("xgb_num_downloads_effectsound_features.pkl")
+xgb_effect_avg = load_artifact("xgb_avg_rating_effectsound_model.pkl")
+xgb_effect_feat_avg = load_artifact("xgb_avg_rating_effectsound_features.pkl")
+le_effect_avg = load_artifact("xgb_avg_rating_effectsound_label_encoder.pkl")
 
-    B_MODELS["mus_num_model"] = load_local("xgb_num_downloads_music_model.pkl")
-    B_MODELS["mus_num_feats"] = load_local("xgb_num_downloads_music_features.pkl")
+NUM_DOWNLOADS_MAP_FR = {0: "Faible", 1: "Moyen", 2: "Élevé"}
 
-    # avg rating
-    B_MODELS["eff_avg_model"] = load_local("xgb_avg_rating_effectsound_model.pkl")
-    B_MODELS["eff_avg_feats"] = load_local("xgb_avg_rating_effectsound_features.pkl")
-    B_MODELS["eff_avg_le"] = load_local("xgb_avg_rating_effectsound_label_encoder.pkl")
 
-    B_MODELS["mus_avg_model"] = load_local("xgb_avg_rating_music_model.pkl")
-    B_MODELS["mus_avg_feats"] = load_local("xgb_avg_rating_music_features.pkl")
-    B_MODELS["mus_avg_le"] = load_local("xgb_avg_rating_music_label_encoder.pkl")
+def safe_float(v):
+    try:
+        return float(v)
+    except Exception:
+        return 0.0
 
-NUM_DOWNLOADS_MAP_B = {0: "Faible", 1: "Moyen", 2: "Élevé"}
 
 def predict_with_model_fs(model, features_dict, feat_list, label_encoder=None):
     row = []
@@ -363,40 +406,33 @@ def predict_with_model_fs(model, features_dict, feat_list, label_encoder=None):
     X = pd.DataFrame([row], columns=feat_list)
     dmatrix = xgb.DMatrix(X.values, feature_names=feat_list)
 
-    booster = model.get_booster() if hasattr(model, "get_booster") else model
-    pred_int = int(booster.predict(dmatrix)[0])
+    pred_int = int(model.get_booster().predict(dmatrix)[0])
 
     if label_encoder is not None:
         return label_encoder.inverse_transform([pred_int])[0]
     return pred_int
 
-def predict_freesound_acoustic_features(url: str):
+
+def predict_from_freesound_url(url: str):
+    if not API_TOKEN:
+        return html_error(
+            "Token FreeSound manquant",
+            "Ajoute la variable d’environnement <code>FREESOUND_TOKEN</code> pour activer cet onglet."
+        )
+
     if not url or not url.strip():
-        return html_error("URL vide", "Colle une URL du type <code>https://freesound.org/s/123456/</code>")
+        return html_error("URL vide", "Collez une URL FreeSound du type <code>https://freesound.org/s/123456/</code>")
 
+    # ID
     try:
-        sound_id = parse_sound_id(url)
+        sound_id = int(url.rstrip("/").split("/")[-1])
     except Exception:
         return html_error("URL invalide", "Impossible d'extraire l'ID depuis l'URL.")
 
-    try:
-        fs_client = get_fs_client()
-    except Exception as e:
-        return html_error("Token FreeSound", str(e))
-
-    try:
-        if not B_MODELS:
-            load_B_models()
-    except Exception as e:
-        return html_error("Modèles Features API manquants", f"Détail : <code>{e}</code>")
-
-    # champs API = union de toutes les features nécessaires (pour éviter de faire 2 appels)
-    all_feats = set()
-    all_feats.update(B_MODELS["eff_num_feats"])
-    all_feats.update(B_MODELS["mus_num_feats"])
-    all_feats.update(B_MODELS["eff_avg_feats"])
-    all_feats.update(B_MODELS["mus_avg_feats"])
-    fields = "duration," + ",".join(sorted(all_feats))
+    all_features = list(set(
+        list(xgb_music_feat_num) + list(xgb_music_feat_avg) + list(xgb_effect_feat_num) + list(xgb_effect_feat_avg)
+    ))
+    fields = "duration," + ",".join(all_features)
 
     try:
         results = fs_client.search(query="", filter=f"id:{sound_id}", fields=fields)
@@ -409,134 +445,165 @@ def predict_freesound_acoustic_features(url: str):
     sound = results.results[0]
     duration = safe_float(sound.get("duration", 0))
 
-    if duration < MIN_EFFECT or ((MAX_EFFECT < duration < MIN_MUSIC) or duration > MAX_MUSIC):
-        return html_error("Durée non supportée", f"Durée : <b>{duration:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
+    # Effect Sound
+    if MIN_EFFECT <= duration <= MAX_EFFECT:
+        badge = "🔊 Effet sonore (URL → features API)"
+        dl_class = int(predict_with_model_fs(xgb_effect_num, sound, xgb_effect_feat_num))
+        avg_text = str(predict_with_model_fs(xgb_effect_avg, sound, xgb_effect_feat_avg, le_effect_avg))
+        dl_text = NUM_DOWNLOADS_MAP_FR.get(dl_class, str(dl_class))
 
-    # EffectSound
-    if duration <= MAX_EFFECT:
-        badge = "🔊 FreeSound (API features acoustiques) — EffectSound"
-        dl_class = int(predict_with_model_fs(B_MODELS["eff_num_model"], sound, B_MODELS["eff_num_feats"]))
-        dl_text = NUM_DOWNLOADS_MAP_B.get(dl_class, str(dl_class))
-        avg_text = str(predict_with_model_fs(B_MODELS["eff_avg_model"], sound, B_MODELS["eff_avg_feats"], B_MODELS["eff_avg_le"]))
         avg_class = avg_label_to_class(avg_text)
+        conclusion = interpret_results(avg_class, dl_class)
 
         extra = f"""
 <div class="hint">ID FreeSound : <b>{sound_id}</b></div>
 <div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-{interpret_results(avg_class, dl_class)}
+{conclusion}
 </div>
 """
         return html_result(badge, duration, avg_text, dl_text, extra_html=extra)
 
     # Music
-    badge = "🎵 FreeSound (API features acoustiques) — Music"
-    dl_class = int(predict_with_model_fs(B_MODELS["mus_num_model"], sound, B_MODELS["mus_num_feats"]))
-    dl_text = NUM_DOWNLOADS_MAP_B.get(dl_class, str(dl_class))
-    avg_text = str(predict_with_model_fs(B_MODELS["mus_avg_model"], sound, B_MODELS["mus_avg_feats"], B_MODELS["mus_avg_le"]))
-    avg_class = avg_label_to_class(avg_text)
+    if MIN_MUSIC <= duration <= MAX_MUSIC:
+        badge = "🎵 Musique (URL → features API)"
+        dl_class = int(predict_with_model_fs(xgb_music_num, sound, xgb_music_feat_num))
+        avg_text = str(predict_with_model_fs(xgb_music_avg, sound, xgb_music_feat_avg, le_music_avg))
+        dl_text = NUM_DOWNLOADS_MAP_FR.get(dl_class, str(dl_class))
 
-    extra = f"""
+        avg_class = avg_label_to_class(avg_text)
+        conclusion = interpret_results(avg_class, dl_class)
+
+        extra = f"""
 <div class="hint">ID FreeSound : <b>{sound_id}</b></div>
 <div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-{interpret_results(avg_class, dl_class)}
+{conclusion}
 </div>
 """
-    return html_result(badge, duration, avg_text, dl_text, extra_html=extra)
+        return html_result(badge, duration, avg_text, dl_text, extra_html=extra)
+
+    return html_error(
+        "Durée non supportée",
+        f"Durée détectée : <b>{duration:.2f} s</b><br><br>"
+        f"Plages acceptées :<br>"
+        f"• Effet sonore : <b>{MIN_EFFECT}–{MAX_EFFECT} s</b><br>"
+        f"• Musique : <b>{MIN_MUSIC}–{MAX_MUSIC} s</b>"
+    )
 
 
 # ============================================================
-# PARTIE C — Metadata preprocessing + joblib
+# ONGLET 3 — URL FreeSound → METADATA → preprocessing complet → modèles
+#   (reprend la logique du script metadata, mais sans HF hub obligatoire)
 # ============================================================
-C_READY = False
-C = {}
-C_LOAD_ERRORS = []
 
-def try_load_C():
-    global C_READY, C, C_LOAD_ERRORS
-    C_READY = False
-    C = {}
-    C_LOAD_ERRORS = []
-
-    def load_and_store(key, relpath):
-        try:
-            C[key] = load_local(relpath)
-            return True
-        except Exception as e:
-            C_LOAD_ERRORS.append(f"{relpath} -> {type(e).__name__}: {e}")
-            return False
-
-    ok = True
-
-    # preprocess music
-    ok &= load_and_store("scaler_samplerate_music",   "music/scaler_music_samplerate.joblib")
-    ok &= load_and_store("scaler_age_days_music",     "music/scaler_music_age_days_log.joblib")
-    ok &= load_and_store("username_freq_music",       "music/username_freq_dict_music.joblib")
-    ok &= load_and_store("est_num_downloads_music",   "music/est_num_downloads_music.joblib")
-    ok &= load_and_store("avg_rating_tr_music",       "music/avg_rating_transformer_music.joblib")
-    ok &= load_and_store("music_subcat_cols",         "music/music_subcategory_cols.joblib")
-    ok &= load_and_store("music_onehot_cols",         "music/music_onehot_cols.joblib")
-    ok &= load_and_store("music_onehot_tags",         "music/music_onehot_tags.joblib")
-
-    # preprocess effect
-    ok &= load_and_store("scaler_samplerate_effect",  "effectSound/scaler_effectSamplerate.joblib")
-    ok &= load_and_store("scaler_age_days_effect",    "effectSound/scaler_effectSound_age_days_log.joblib")
-    ok &= load_and_store("username_freq_effect",      "effectSound/username_freq_dict_effectSound.joblib")
-    ok &= load_and_store("est_num_downloads_effect",  "effectSound/est_num_downloads_effectSound.joblib")
-    ok &= load_and_store("avg_rating_tr_effect",      "effectSound/avg_rating_transformer_effectSound.joblib")
-    ok &= load_and_store("effect_subcat_cols",        "effectSound/effectSound_subcategory_cols.joblib")
-    ok &= load_and_store("effect_onehot_cols",        "effectSound/effectSound_onehot_cols.joblib")
-    ok &= load_and_store("effect_onehot_tags",        "effectSound/effect_onehot_tags.joblib")
-
-    # models root
-    ok &= load_and_store("music_nd_model",            "music_model_num_downloads.joblib")
-    ok &= load_and_store("music_ar_model",            "music_xgb_avg_rating.joblib")
-    ok &= load_and_store("music_ar_le",               "music_xgb_avg_rating_label_encoder.joblib")
-
-    ok &= load_and_store("effect_nd_model",           "effectSound_model_num_downloads.joblib")
-    ok &= load_and_store("effect_ar_model",           "effectSound_xgb_avg_rating.joblib")
-    ok &= load_and_store("effect_ar_le",              "effectSound_xgb_avg_rating_label_encoder.joblib")
-
-    # feature lists
-    if exists("music_model_features_list.joblib"):
-        ok &= load_and_store("music_features", "music_model_features_list.joblib")
-    elif exists("model_features_list.joblib"):
-        ok &= load_and_store("music_features", "model_features_list.joblib")
-    else:
-        ok = False
-        C_LOAD_ERRORS.append("music features list manquante: music_model_features_list.joblib OU model_features_list.joblib")
-
-    ok &= load_and_store("effect_features",           "effect_model_features_list.joblib")
-
-    if ok:
-        C["music_features"] = list(dict.fromkeys(C["music_features"]))
-        C["effect_features"] = list(dict.fromkeys(C["effect_features"]))
-        C_READY = True
-    else:
-        C_READY = False
+class AvgRatingTransformer:
+    def __init__(self, est, class_mapping=None):
+        self.est = est
+        if class_mapping is None:
+            self.class_mapping = {0: "MissedInfo", 1: "Low", 2: "Medium", 3: "High"}
+        else:
+            self.class_mapping = class_mapping
+
+    def transform(self, X):
+        X = np.asarray(X)
+        mask_non_zero = X != 0
+        Xt = np.zeros_like(X, dtype=int)
+        if mask_non_zero.any():
+            Xt[mask_non_zero] = self.est.transform(X[mask_non_zero].reshape(-1, 1)).flatten() + 1
+        return np.array([self.class_mapping.get(v, "MissedInfo") for v in Xt])
+
+
+# ---- Artifacts preprocessing (music/effect) ----
+# Supporte soit "à la racine", soit encore dans music/ et effectSound/
+scaler_samplerate_music = load_artifact("scaler_music_samplerate.joblib", "music/scaler_music_samplerate.joblib")
+scaler_age_days_music = load_artifact("scaler_music_age_days_log.joblib", "music/scaler_music_age_days_log.joblib")
+username_freq_music = load_artifact("username_freq_dict_music.joblib", "music/username_freq_dict_music.joblib")
+est_num_downloads_music = load_artifact("est_num_downloads_music.joblib", "music/est_num_downloads_music.joblib")
+avg_rating_transformer_music = load_artifact("avg_rating_transformer_music.joblib", "music/avg_rating_transformer_music.joblib")
+music_subcategory_cols = load_artifact("music_subcategory_cols.joblib", "music/music_subcategory_cols.joblib")
+music_onehot_cols = load_artifact("music_onehot_cols.joblib", "music/music_onehot_cols.joblib")
+music_onehot_tags = load_artifact("music_onehot_tags.joblib", "music/music_onehot_tags.joblib")
+
+scaler_samplerate_effect = load_artifact("scaler_effectSamplerate.joblib", "effectSound/scaler_effectSamplerate.joblib")
+scaler_age_days_effect = load_artifact("scaler_effectSound_age_days_log.joblib", "effectSound/scaler_effectSound_age_days_log.joblib")
+username_freq_effect = load_artifact("username_freq_dict_effectSound.joblib", "effectSound/username_freq_dict_effectSound.joblib")
+est_num_downloads_effect = load_artifact("est_num_downloads_effectSound.joblib", "effectSound/est_num_downloads_effectSound.joblib")
+avg_rating_transformer_effect = load_artifact("avg_rating_transformer_effectSound.joblib", "effectSound/avg_rating_transformer_effectSound.joblib")
+effect_subcategory_cols = load_artifact("effectSound_subcategory_cols.joblib", "effectSound/effectSound_subcategory_cols.joblib")
+effect_onehot_cols = load_artifact("effectSound_onehot_cols.joblib", "effectSound/effectSound_onehot_cols.joblib")
+effect_onehot_tags = load_artifact("effect_onehot_tags.joblib", "effectSound/effect_onehot_tags.joblib")
+
+# ---- Modèles metadata (num_downloads + avg_rating + features list) ----
+# (à mettre idéalement à la racine)
+music_model_num_downloads = load_artifact("music_model_num_downloads.joblib")
+music_model_avg_rating = load_artifact("music_xgb_avg_rating.joblib")
+music_avg_rating_le_meta = load_artifact("music_xgb_avg_rating_label_encoder.joblib")
+music_model_features = load_artifact("music_model_features_list.joblib")
+
+effect_model_num_downloads = load_artifact("effectSound_model_num_downloads.joblib")
+effect_model_avg_rating = load_artifact("effectSound_xgb_avg_rating.joblib")
+effect_avg_rating_le_meta = load_artifact("effectSound_xgb_avg_rating_label_encoder.joblib")
+effect_model_features = load_artifact("effect_model_features_list.joblib")
+
+# Nettoyage doublons (comme ta collègue)
+music_model_features = list(dict.fromkeys(list(music_model_features)))
+effect_model_features = list(dict.fromkeys(list(effect_model_features)))
+
+# GloVe (optionnel)
+if _GENSIM_OK:
+    try:
+        glove_model = api.load("glove-wiki-gigaword-100")
+    except Exception:
+        glove_model = None
+else:
+    glove_model = None
 
-# run once at import
-try_load_C()
 
 def preprocess_name(df, vec_dim=8):
+    # Version simple: hashing via sklearn n'est pas importé ici pour rester léger.
+    # Pour rester fidèle au code collègue, on refait le hashing "à la main" avec pandas+numpy.
+    # (Si tu veux EXACTEMENT HashingVectorizer, dis-moi et je te le remets.)
     df = df.copy()
-    df["name_len"] = df["name_clean"].str.len()
-    vectorizer = HashingVectorizer(n_features=vec_dim, alternate_sign=False, norm=None)
-    name_vec_sparse = vectorizer.transform(df["name_clean"])
-    name_vec_df = pd.DataFrame(
-        name_vec_sparse.toarray(),
-        columns=[f"name_vec_{i}" for i in range(vec_dim)],
-        index=df.index
-    )
-    return pd.concat([df, name_vec_df], axis=1)
-
-def fetch_sound_metadata(fs_client, sound_url):
-    sound_id = parse_sound_id(sound_url)
+    name = df["name_clean"].fillna("").astype(str)
+    df["name_len"] = name.str.len()
+    # hashing rudimentaire en vec_dim dimensions
+    vec = np.zeros((len(df), vec_dim), dtype=float)
+    for i, s in enumerate(name.tolist()):
+        h = abs(hash(s))
+        for k in range(vec_dim):
+            vec[i, k] = ((h >> (k * 3)) & 0x7)  # petit pattern stable
+    for k in range(vec_dim):
+        df[f"name_vec_{k}"] = vec[:, k]
+    return df
+
+
+def description_to_vec(text, model, dim=100):
+    if model is None:
+        return np.zeros(dim)
+    if not text:
+        return np.zeros(dim)
+    words = str(text).lower().split()
+    vecs = [model[w] for w in words if w in model]
+    if len(vecs) == 0:
+        return np.zeros(dim)
+    return np.mean(vecs, axis=0)
+
+
+def fetch_sound_metadata(sound_url: str) -> pd.DataFrame:
+    """
+    Récupère les metadata FreeSound (sans télécharger l'audio).
+    """
+    if not API_TOKEN:
+        raise RuntimeError("Token FreeSound manquant (FREESOUND_TOKEN).")
+
+    sound_id = int(sound_url.rstrip("/").split("/")[-1])
     sound = fs_client.get_sound(sound_id)
+
     data = {
         "id": sound_id,
-        "name": sound.name,
+        "file_path": None,
+        "name": getattr(sound, "name", ""),
         "num_ratings": getattr(sound, "num_ratings", 0),
-        "tags": ",".join(sound.tags) if getattr(sound, "tags", None) else "",
+        "tags": ",".join(getattr(sound, "tags", []) or []),
         "username": getattr(sound, "username", ""),
         "description": getattr(sound, "description", "") or "",
         "created": getattr(sound, "created", ""),
@@ -555,50 +622,62 @@ def fetch_sound_metadata(fs_client, sound_url):
     }
     return pd.DataFrame([data])
 
-def preprocess_sound_metadata(df):
+
+def preprocess_sound(df: pd.DataFrame):
+    """
+    Preprocessing complet basé sur la durée pour choisir Music vs EffectSound.
+    """
     df = df.copy()
     dur = float(df["duration"].iloc[0])
 
     if MIN_EFFECT <= dur <= MAX_EFFECT:
-        dataset_type = "effectSound"
-        scaler_samplerate = C["scaler_samplerate_effect"]
-        scaler_age = C["scaler_age_days_effect"]
-        username_freq = C["username_freq_effect"]
-        est_num_downloads = C["est_num_downloads_effect"]
-        avg_rating_tr = C["avg_rating_tr_effect"]
-        subcat_cols = C["effect_subcat_cols"]
-        onehot_cols = C["effect_onehot_cols"]
-        onehot_tags = C["effect_onehot_tags"]
+        scaler_samplerate = scaler_samplerate_effect
+        scaler_age = scaler_age_days_effect
+        username_freq = username_freq_effect
+        est_num_downloads = est_num_downloads_effect
+        avg_rating_transformer = avg_rating_transformer_effect
+        subcat_cols = effect_subcategory_cols
+        onehot_cols = effect_onehot_cols
+        onehot_tags = effect_onehot_tags
     elif MIN_MUSIC <= dur <= MAX_MUSIC:
-        dataset_type = "music"
-        scaler_samplerate = C["scaler_samplerate_music"]
-        scaler_age = C["scaler_age_days_music"]
-        username_freq = C["username_freq_music"]
-        est_num_downloads = C["est_num_downloads_music"]
-        avg_rating_tr = C["avg_rating_tr_music"]
-        subcat_cols = C["music_subcat_cols"]
-        onehot_cols = C["music_onehot_cols"]
-        onehot_tags = C["music_onehot_tags"]
+        scaler_samplerate = scaler_samplerate_music
+        scaler_age = scaler_age_days_music
+        username_freq = username_freq_music
+        est_num_downloads = est_num_downloads_music
+        avg_rating_transformer = avg_rating_transformer_music
+        subcat_cols = music_subcategory_cols
+        onehot_cols = music_onehot_cols
+        onehot_tags = music_onehot_tags
     else:
-        return None, None, f"Durée hors plage ({dur:.2f}s)."
+        return f"❌ Son trop court ou trop long ({dur} sec)"
 
+    # Category bool
     df["category_is_user_provided"] = df["category_is_user_provided"].astype(int)
+
+    # Username frequency
     df["username_freq"] = df["username"].map(username_freq).fillna(0)
 
+    # Numeric features log1p
     for col in ["num_ratings", "num_comments", "filesize", "duration"]:
         df[col] = np.log1p(df[col])
 
+    # samplerate scaled
     df["samplerate"] = scaler_samplerate.transform(df[["samplerate"]])
 
+    # Age_days
     df["created"] = pd.to_datetime(df["created"], errors="coerce").dt.tz_localize(None)
     df["age_days"] = (pd.Timestamp.now() - df["created"]).dt.days
     df["age_days_log"] = np.log1p(df["age_days"])
     df["age_days_log_scaled"] = scaler_age.transform(df[["age_days_log"]])
-    df = df.drop(columns=["created", "age_days", "age_days_log"], errors="ignore")
+    df = df.drop(columns=["created", "age_days", "age_days_log"])
 
+    # num_downloads_class (binned)
     df["num_downloads_class"] = est_num_downloads.transform(df[["num_downloads"]])
-    df["avg_rating"] = avg_rating_tr.transform(df["avg_rating"].to_numpy())
 
+    # avg_rating discretized via transformer
+    df["avg_rating"] = avg_rating_transformer.transform(df["avg_rating"].to_numpy())
+
+    # Subcategory onehot
     for col in subcat_cols:
         df[col] = 0
     subcat_val = df["subcategory"].iloc[0]
@@ -606,8 +685,9 @@ def preprocess_sound_metadata(df):
         cat_name = col.replace("subcategory_", "")
         if subcat_val == cat_name:
             df[col] = 1
-    df.drop(columns=["subcategory"], inplace=True, errors="ignore")
+    df.drop(columns=["subcategory"], inplace=True)
 
+    # One-hot cols (license/category/type)
     for col in onehot_cols:
         if col not in df.columns:
             df[col] = 0
@@ -620,6 +700,16 @@ def preprocess_sound_metadata(df):
         if col_name in df.columns:
             df[col_name] = 1
 
+    # Tags
+    for col in ["name", "tags", "description"]:
+        if col not in df.columns:
+            df[col] = ""
+
+    df["tags_list"] = df["tags"].fillna("").astype(str).str.lower().str.split(",")
+
+    if not df["tags_list"].iloc[0] or df["tags_list"].iloc[0] == [""]:
+        df["tags_list"] = [["Other"]]
+
     for col in onehot_tags:
         if col not in df.columns:
             df[col] = 0
@@ -629,236 +719,180 @@ def preprocess_sound_metadata(df):
         tag_name = col.replace("tag_", "").lower()
         if tag_name in tags_list:
             df[col] = 1
-    df.drop(columns=["tags"], inplace=True, errors="ignore")
 
+    df.drop(columns=["tags"], inplace=True)
+
+    # Name hashing
     df["name_clean"] = df["name"].astype(str).str.lower().str.rsplit(".", n=1).str[0]
     df = preprocess_name(df, vec_dim=8)
-    df.drop(columns=["name", "name_clean"], inplace=True, errors="ignore")
-
-    # IMPORTANT: Pas de GloVe ici (ton modèle est piloté par model_features_list.joblib)
-    df.drop(columns=["description"], inplace=True, errors="ignore")
+    df.drop(columns=["name", "name_clean"], inplace=True)
+
+    # Description → glove mean (si glove non dispo: zeros)
+    desc_vec = description_to_vec(df["description"].iloc[0], glove_model)
+    for i in range(100):
+        df[f"description_glove_{i}"] = float(desc_vec[i])
+    df.drop(columns=["description"], inplace=True)
+
+    # Drop non-features
+    df.drop(
+        columns=[
+            "license", "category", "type", "subcategory", "id",
+            "num_downloads", "file_path", "username", "tags_list"
+        ],
+        inplace=True,
+        errors="ignore"
+    )
 
-    df.drop(columns=["license", "category", "type", "id", "num_downloads", "username"], inplace=True, errors="ignore")
+    return df
 
-    return df, dataset_type, None
 
-def predict_with_model_df(model, df_input):
+def predict_with_model_meta(model, df_input: pd.DataFrame, le=None):
     booster_feats = model.get_booster().feature_names
     X_aligned = df_input.reindex(columns=booster_feats, fill_value=0.0).astype(float)
-    dmatrix = xgb.DMatrix(X_aligned.values, feature_names=booster_feats)
-    pred = model.get_booster().predict(dmatrix)
-    pred_val = pred[0]
-    if hasattr(pred_val, "__len__") and np.size(pred_val) > 1:
-        return int(np.argmax(pred_val))
-    return int(round(float(pred_val)))
-
-def predict_freesound_metadata(url: str, show_debug: bool):
-    if not C_READY:
-        body = "Le pipeline metadata n’a pas pu charger tous les joblib."
-        if C_LOAD_ERRORS:
-            body += "<br><br><details><summary><b>Voir erreurs</b></summary><pre>" + "\n".join(C_LOAD_ERRORS[:80]) + "</pre></details>"
-        return html_warn("Pipeline C désactivé", body)
+    dmatrix = xgb.DMatrix(X_aligned.values, feature_names=list(booster_feats))
+    preds = model.get_booster().predict(dmatrix)
+    pred_val = preds[0]
+    pred_int = int(round(float(pred_val)))
 
-    if not url or not url.strip():
-        return html_error("URL vide", "Colle une URL du type <code>https://freesound.org/s/123456/</code>")
+    if le is not None:
+        try:
+            return le.inverse_transform([pred_int])[0]
+        except Exception:
+            return f"Classe inconnue ({pred_int})"
+    return pred_int
 
-    try:
-        sound_id = parse_sound_id(url)
-    except Exception:
-        return html_error("URL invalide", "Impossible d'extraire l'ID depuis l'URL.")
 
-    try:
-        fs_client = get_fs_client()
-    except Exception as e:
-        return html_error("Token FreeSound", str(e))
+def predict_from_metadata_url(url: str):
+    if not API_TOKEN:
+        return "❌ Token FreeSound manquant. Ajoute FREESOUND_TOKEN (env / secret)."
+
+    if not url or not url.strip():
+        return "❌ Veuillez entrer une URL FreeSound."
 
+    # 1) metadata brute
     try:
-        df_raw = fetch_sound_metadata(fs_client, url)
+        df_raw = fetch_sound_metadata(url)
     except Exception as e:
-        return html_error("Erreur API FreeSound", f"Détail : <code>{e}</code>")
-
-    dur = float(df_raw["duration"].iloc[0])
-    if dur < MIN_EFFECT or ((MAX_EFFECT < dur < MIN_MUSIC) or dur > MAX_MUSIC):
-        return html_error("Durée non supportée", f"Durée : <b>{dur:.2f}s</b><br>Accepté: 0.5–3s ou 10–60s")
-
-    df_proc, dtype, err = preprocess_sound_metadata(df_raw)
-    if df_proc is None:
-        return html_error("Prétraitement metadata", err or "Erreur inconnue.")
-
-    if dtype == "effectSound":
-        badge = "🔊 FreeSound (metadata) — EffectSound"
-        nd_model = C["effect_nd_model"]
-        ar_model = C["effect_ar_model"]
-        ar_le = C["effect_ar_le"]
-        feats = C["effect_features"]
-    else:
-        badge = "🎵 FreeSound (metadata) — Music"
-        nd_model = C["music_nd_model"]
-        ar_model = C["music_ar_model"]
-        ar_le = C["music_ar_le"]
-        feats = C["music_features"]
+        return f"❌ Erreur API FreeSound: {e}"
 
-    df_for_model = df_proc.reindex(columns=feats, fill_value=0.0).astype(float)
+    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)
 
-    dl_class = predict_with_model_df(nd_model, df_for_model)
-    dl_map = {0: "Low", 1: "Medium", 2: "High"}
-    dl_text = dl_map.get(dl_class, str(dl_class))
-
-    ar_class = predict_with_model_df(ar_model, df_for_model)
-    try:
-        avg_text = ar_le.inverse_transform([ar_class])[0]
-    except Exception:
-        avg_text = f"Classe {ar_class}"
-
-    avg_class_for_interp = avg_label_to_class(avg_text)
-    dl_class_for_interp = {"Low": 0, "Medium": 1, "High": 2}.get(dl_text, 1)
-
-    debug_html = ""
-    if show_debug:
-        raw_txt = "\n".join([f"{c}: {df_raw.loc[0,c]}" for c in df_raw.columns])
-        proc_cols = df_proc.columns.tolist()
-        proc_preview = proc_cols[:140]
-        proc_txt = "\n".join([f"{c}: {df_proc.loc[0,c]}" for c in proc_preview])
-        debug_html = f"""
-<div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-  <details><summary><b>Debug</b> — métadonnées brutes</summary><pre>{raw_txt}</pre></details>
-  <details><summary><b>Debug</b> — features après preprocessing (aperçu)</summary><pre>{proc_txt}</pre></details>
-</div>
-"""
-
-    extra = f"""
-<div class="hint">ID FreeSound : <b>{sound_id}</b></div>
-<div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
-{interpret_results(avg_class_for_interp, dl_class_for_interp)}
-</div>
-{debug_html}
-"""
-    return html_result(badge, dur, str(avg_text), str(dl_text), extra_html=extra)
+    # 2) durée
+    dur = float(df_raw["duration"].iloc[0])
+    if dur < MIN_EFFECT:
+        return raw_str + f"\n\n❌ Son trop court ({dur} sec). Plage acceptée: {MIN_EFFECT}-{MAX_EFFECT} ou {MIN_MUSIC}-{MAX_MUSIC} sec"
+    if (MAX_EFFECT < dur < MIN_MUSIC) or dur > MAX_MUSIC:
+        return raw_str + f"\n\n❌ Son hors plage ({dur} sec). Plage acceptée: {MIN_EFFECT}-{MAX_EFFECT} ou {MIN_MUSIC}-{MAX_MUSIC} sec"
 
+    # 3) preprocessing complet
+    df_processed = preprocess_sound(df_raw)
+    if isinstance(df_processed, str):
+        return raw_str + "\n\n" + df_processed
 
-# ============================================================
-# DIAGNOSTIC HTML
-# ============================================================
-def make_diagnostic_html():
-    # A
-    missing_a = [f for f in FILES_A if not exists(f)]
-    a_ok = (len(missing_a) == 0)
-
-    # B
-    missing_b = [f for f in FILES_B if not exists(f)]
-    b_ok = (len(missing_b) == 0)
-
-    # C presence (files) + runtime load status (C_READY)
-    missing_c = []
-    for f in FILES_C_ROOT + FILES_C_EFFECT_DIR + FILES_C_MUSIC_DIR:
-        if not exists(f):
-            missing_c.append(f)
-    # music features list special rule
-    if not (exists("music_model_features_list.joblib") or exists("model_features_list.joblib")):
-        missing_c.append("music_model_features_list.joblib OU model_features_list.joblib")
-    c_files_ok = (len(missing_c) == 0)
-
-    parts = []
-    parts.append("<b>📦 Diagnostic du Space</b><br><br>")
-
-    parts.append("<b>OpenSMILE (A)</b><br>")
-    if a_ok:
-        parts.append("✅ OK<br>")
-        parts.append("Effect: xgb_model_EffectSound.pkl<br>Music: xgb_model_Music.pkl<br><br>")
-    else:
-        parts.append("❌ incomplet<br>")
-        parts.append(f"Manquants: {', '.join(missing_a)}<br><br>")
+    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])
 
-    parts.append("<b>Features API (B)</b><br>")
-    if b_ok:
-        parts.append("✅ OK<br><br>")
-    else:
-        parts.append("❌ incomplet<br>")
-        parts.append(f"Manquants: {', '.join(missing_b)}<br><br>")
-
-    parts.append("<b>Metadata (C)</b><br>")
-    if not c_files_ok:
-        parts.append("⚠️ désactivé si dossiers/joblib absents<br>")
-        parts.append("Activer seulement si preprocessing joblib présents.<br>")
-        parts.append(f"Manquants: {', '.join(missing_c)}<br><br>")
+    # 4) choisir modèles metadata
+    if MIN_EFFECT <= dur <= MAX_EFFECT:
+        model_nd = effect_model_num_downloads
+        model_ar = effect_model_avg_rating
+        model_features = effect_model_features
+        sound_type = "EffectSound"
+        current_le = effect_avg_rating_le_meta
     else:
-        # files are OK, but loading can still fail due to version mismatch
-        if C_READY:
-            parts.append("✅ OK (actif)<br><br>")
-        else:
-            parts.append("⚠️ fichiers présents mais chargement joblib a échoué (versions ?) <br>")
-            if C_LOAD_ERRORS:
-                parts.append("<details><summary><b>Voir erreurs de chargement</b></summary>")
-                parts.append("<pre>" + "\n".join(C_LOAD_ERRORS[:80]) + "</pre></details>")
-            parts.append("<br>")
-
-    # list detected files
-    detected = []
-    for root, _, files in os.walk(BASE_DIR):
-        for fn in files:
-            rel = os.path.relpath(os.path.join(root, fn), BASE_DIR)
-            detected.append(rel)
-    detected = sorted(detected)
-
-    parts.append("<details><summary><b>Fichiers détectés</b></summary>")
-    parts.append("<pre>" + "\n".join(detected) + "</pre></details>")
-
-    return html_box("Diagnostic", "".join(parts))
-
-
-def refresh_diagnostic():
-    # reload C on refresh
-    try_load_C()
-    return make_diagnostic_html()
-
-
-# ============================================================
-# GRADIO APP
-# ============================================================
-diag_init = make_diagnostic_html()
-
-with gr.Blocks(title="Popularité FreeSound — 3 pipelines", css=CSS, theme=gr.themes.Soft()) as demo:
-    gr.HTML(f"""
-<div id="header-title">Popularité FreeSound — 3 pipelines</div>
+        model_nd = music_model_num_downloads
+        model_ar = music_model_avg_rating
+        model_features = music_model_features
+        sound_type = "Music"
+        current_le = music_avg_rating_le_meta
+
+    # 5) forcer colonnes exactes
+    df_for_model = df_for_model.reindex(columns=model_features, fill_value=0.0).astype(float)
+
+    # 6) prédictions
+    pred_num_downloads_val = predict_with_model_meta(model_nd, df_for_model, le=None)
+    NUM_DOWNLOADS_MAP = {0: "Low", 1: "Medium", 2: "High"}
+    pred_num_downloads = NUM_DOWNLOADS_MAP.get(int(pred_num_downloads_val), str(pred_num_downloads_val))
+
+    pred_avg_rating = predict_with_model_meta(model_ar, df_for_model, le=current_le)
+
+    # 7) afficher 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)
+
+    # 8) résultat
+    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
+
+
+# =========================
+# APP UI (3 onglets)
+# =========================
+theme = gr.themes.Soft()
+
+with gr.Blocks(title="Démo — Popularité Audio", css=CSS) as demo:
+    gr.HTML(
+        f"""
+<div id="header-title">Démo — Prédiction de popularité audio</div>
 <p id="header-sub">
-<b>A)</b> Upload audio → <b>OpenSMILE</b><br>
-<b>B)</b> URL FreeSound → <b>Features acoustiques via API fields</b><br>
-<b>C)</b> URL FreeSound → <b>Metadata + preprocessing (joblib)</b><br><br>
-<b>Durées acceptées :</b> 🔊 {MIN_EFFECT}–{MAX_EFFECT}s · 🎵 {MIN_MUSIC}–{MAX_MUSIC}s
+Trois modes : <b>Upload audio</b> (openSMILE), <b>URL FreeSound</b> (features API), <b>URL FreeSound</b> (metadata + preprocessing complet).<br><br>
+<b>Durées acceptées :</b> 🔊 Effet sonore {MIN_EFFECT}–{MAX_EFFECT}s · 🎵 Musique {MIN_MUSIC}–{MAX_MUSIC}s
 </p>
-""")
+"""
+    )
 
-    diag_out = gr.HTML(value=diag_init)
-    btn_diag = gr.Button("🔄 Rafraîchir diagnostic")
-    btn_diag.click(refresh_diagnostic, outputs=diag_out)
+    if not API_TOKEN:
+        gr.Markdown(
+            "⚠️ **FREESOUND_TOKEN non défini** : les onglets URL (2 et 3) ne fonctionneront pas tant que tu ne l’ajoutes pas."
+        )
 
     with gr.Tabs():
-        with gr.Tab("A) Upload → OpenSMILE"):
+        # -------- TAB 1 --------
+        with gr.Tab("1) Upload audio (openSMILE)"):
             with gr.Row():
-                with gr.Column():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Importer un fichier")
                     audio_in = gr.Audio(type="filepath", label="Fichier audio")
-                    btn = gr.Button("🚀 Prédire (OpenSMILE)", variant="primary")
-                with gr.Column():
-                    out = gr.HTML()
-            btn.click(predict_opensmile_upload, inputs=audio_in, outputs=out)
-
-        with gr.Tab("B) URL → Features acoustiques (API)"):
+                    btn_audio = gr.Button("🚀 Prédire (upload)", variant="primary")
+                with gr.Column(scale=1):
+                    gr.Markdown("### Résultat")
+                    out_audio = gr.HTML()
+            btn_audio.click(predict_from_uploaded_audio, inputs=audio_in, outputs=out_audio)
+
+        # -------- TAB 2 --------
+        with gr.Tab("2) URL FreeSound (features API)"):
             with gr.Row():
-                with gr.Column():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Coller une URL FreeSound")
                     url_in = gr.Textbox(label="URL FreeSound", placeholder="https://freesound.org/s/123456/")
-                    btn = gr.Button("🚀 Prédire (Features API)", variant="primary")
-                with gr.Column():
-                    out = gr.HTML()
-            btn.click(predict_freesound_acoustic_features, inputs=url_in, outputs=out)
-
-        with gr.Tab("C) URL → Metadata (prétraitement)"):
+                    btn_url = gr.Button("🚀 Prédire (URL → features API)", variant="primary")
+                with gr.Column(scale=1):
+                    gr.Markdown("### Résultat")
+                    out_url = gr.HTML()
+            btn_url.click(predict_from_freesound_url, inputs=url_in, outputs=out_url)
+
+        # -------- TAB 3 --------
+        with gr.Tab("3) URL FreeSound (metadata + preprocessing complet)"):
             with gr.Row():
-                with gr.Column():
-                    url_in = gr.Textbox(label="URL FreeSound", placeholder="https://freesound.org/s/123456/")
-                    show_debug = gr.Checkbox(label="Afficher debug (brut + aperçu features)", value=False)
-                    btn = gr.Button("🚀 Prédire (Metadata)", variant="primary")
-                with gr.Column():
-                    out = gr.HTML()
-            btn.click(predict_freesound_metadata, inputs=[url_in, show_debug], outputs=out)
-
-demo.launch()
+                with gr.Column(scale=1):
+                    gr.Markdown("### Coller une URL FreeSound")
+                    url_meta = gr.Textbox(label="URL FreeSound", placeholder="https://freesound.org/s/123456/")
+                    btn_meta = gr.Button("📊 Prétraiter + prédire (metadata)", variant="primary")
+                with gr.Column(scale=1):
+                    gr.Markdown("### Sortie détaillée (brut + features + prédictions)")
+                    out_meta = gr.Textbox(label="Résultat", lines=22)
+            btn_meta.click(predict_from_metadata_url, inputs=url_meta, outputs=out_meta)
+
+demo.launch(theme=theme)

avg_rating_transformer_effectSound.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37b2862f96050ad72ab3964d30f4f2d3908dd6b5e746f150c1baea5d2cdb2bbf
+size 944

avg_rating_transformer_music.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29e054a504fd9193b232384f5a2799cad18e54903f03cbfc999a77547feff2d2
+size 944

effectSound_onehot_cols.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3de47c718ff02e366470f28167a8e5736829fa84b0d34531ac046ceaec5371fa
+size 761

effectSound_subcategory_cols.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6796b185bc36b2a0961c0a0b22f813f473eec2962cfa5c20a013f0f328ae8021
+size 418

effect_onehot_tags.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9504d82fd7b4691fdc61b00f2e8ae15e28665fce17c60cf44655ccd60cf09f36
+size 69808

est_num_downloads_effectSound.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd69b4b945f61331c7778a7ff3366a856191beff40ed439ed78705c1f94440ef
+size 831

est_num_downloads_music.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:435f88fd8e8f46a970b39b2f255920c298c20e41cf558276dae8b09a40bd56be
+size 831

music_onehot_cols.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:554cb8135c47967de9f480942f6d09c79b2ac8440adecebd1dd8c013444d195a
+size 771

music_onehot_tags.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8d510dc14604d2d69333e144cc3212ecb3b446d5192f15940347d65610e6eb1
+size 36877

music_subcategory_cols.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a51f89fa69f26d5785cd8518fc594ceffbc959493572ac9b06162bfd4f509247
+size 377

music_xgb_avg_rating (1).joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:528b63dab12f2d20b07086f7d7b1a8747fbc09798d5c6a199185cec57bda823d
+size 7961465

music_xgb_model_smote_balanced_avg_rating.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9266eb3b73bbe34dcbbf84a5cefd758b8dae561f1ee7abd11ea9e79dcb9a756
+size 4144472

music_xgb_model_smote_balanced_num_downloads.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fca062c7c044eeb44c0acaaad0f1ee91ff79b733d877d7893795580c74b68f87
+size 5322685

requirements.txt

@@ -1,15 +1,14 @@
-gradio==4.44.1
-pandas==2.2.2
-numpy==1.26.4
-scikit-learn==1.3.2
-joblib==1.3.2
-xgboost==2.0.3
-soundfile==0.12.1
-pydub==0.25.1
-opensmile==2.5.0
-requests==2.32.3
-pytz==2024.1
-urllib3==2.2.2
-matplotlib==3.8.4
-imbalanced-learn==0.11.0
-git+https://github.com/MTG/freesound-python.git
+gradio==6.5.0
+pandas
+numpy
+scikit-learn
+joblib
+xgboost
+soundfile
+pydub
+opensmile
+requests
+pytz
+imblearn
+matplotlib
+git+https://github.com/MTG/freesound-python

scaler_effectSamplerate.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5ac8d3018ca0d1477592952a1aa6b9d582ad589c46314854efd56b607d175b3a
+size 879

scaler_effectSound_age_days_log.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:332ee96e7bca4c412bc0d5ac20c0876d5bf8304142d4fd57d4d5524e03228e61
+size 895

scaler_music_age_days_log.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1941f5f48e21243a939080d9d7a1cedc677e2b0b813a451a50f64d00ce149588
+size 895

scaler_music_samplerate.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0339152b44141d57f6be072c67c50c074d7b6e12280a57f0434520188af83483
+size 879

username_freq_dict_effectSound.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:457517d900b3c05061f398d37b00f8087ae9edb1a4776c7cbc2fc77fa60a4036
+size 209269

username_freq_dict_music.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6ca2078e0e0c5c0d5f871362bba1e787c6860fb547dd1f9f3c4f0f3c366b447
+size 214933