modif interpretation results

app.py

@@ -764,78 +764,102 @@ def predict_with_model_meta(model, df_input: pd.DataFrame, le=None):
 
 def predict_from_metadata_url(url: str):
     if not API_TOKEN:
-        return "❌ Token FreeSound manquant. Ajoute FREESOUND_TOKEN (env / secret)."
+        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 "❌ Veuillez entrer une URL FreeSound."
+        return html_error(
+            "URL vide",
+            "Collez une URL FreeSound du type <code>https://freesound.org/s/123456/</code>"
+        )
 
     # 1) metadata brute
     try:
         df_raw = fetch_sound_metadata(url)
     except Exception as e:
-        return f"❌ Erreur API FreeSound: {e}"
-
-    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)
+        return html_error("Erreur API FreeSound", f"Détail : <code>{e}</code>")
 
     # 2) durée
-    dur = float(df_raw["duration"].iloc[0])
+    try:
+        dur = float(df_raw["duration"].iloc[0])
+    except Exception:
+        dur = 0.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"
+        return html_error(
+            "Audio trop court",
+            f"Durée détectée : <b>{dur:.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 < 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"
+        return html_error(
+            "Audio hors plage",
+            f"Durée détectée : <b>{dur:.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>"
+        )
 
-    # 3) preprocessing complet
+    # 3) preprocessing complet (mais on NE L’AFFICHE PAS)
     df_processed = preprocess_sound(df_raw)
     if isinstance(df_processed, str):
-        return raw_str + "\n\n" + df_processed
+        return html_error("Preprocessing impossible", df_processed)
 
+    # 4) features pour modèles
     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])
+    df_for_model = df_processed.drop(
+        columns=[c for c in cols_to_remove if c in df_processed.columns],
+        errors="ignore"
+    )
 
-    # 4) choisir modèles metadata
+    # 5) choisir modèles metadata
     if MIN_EFFECT <= dur <= MAX_EFFECT:
+        badge = "🔊 Effet sonore (URL → metadata)"
         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:
+        badge = "🎵 Musique (URL → metadata)"
         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
+    # 6) forcer colonnes exactes
     df_for_model = df_for_model.reindex(columns=model_features, fill_value=0.0).astype(float)
 
-    # 6) prédictions
+    # 7) prédire
     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_num_downloads_val = int(pred_num_downloads_val) if str(pred_num_downloads_val).isdigit() else pred_num_downloads_val
 
-    pred_avg_rating = predict_with_model_meta(model_ar, df_for_model, le=current_le)
+    # Mapping num downloads
+    NUM_DOWNLOADS_MAP = {0: "Faible", 1: "Moyen", 2: "Élevé"}
+    pred_downloads_text = NUM_DOWNLOADS_MAP.get(pred_num_downloads_val, str(pred_num_downloads_val))
 
-    # 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)
+    # avg rating (label)
+    pred_avg_rating_label = predict_with_model_meta(model_ar, df_for_model, le=current_le)
 
-    # 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)
+    # 8) transformer en classes (pour interprétation + cohérence visuelle)
+    avg_class = avg_label_to_class(pred_avg_rating_label)
+    dl_class = int(pred_num_downloads_val) if isinstance(pred_num_downloads_val, (int, np.integer)) else 0
 
-    return raw_str + processed_str + prediction_str
+    rating_display = str(pred_avg_rating_label)
+    downloads_display = pred_downloads_text
 
+    conclusion = interpret_results(avg_class, dl_class)
+    extra = f"""
+<div style="margin-top:12px; padding-top:10px; border-top:1px dashed #d1d5db">
+{conclusion}
+</div>
+"""
+
+    return html_result(badge, dur, rating_display, downloads_display, extra_html=extra)
 
 # =========================
 # APP UI (3 onglets)
@@ -884,15 +908,15 @@ Trois modes : <b>Upload audio</b> (openSMILE), <b>URL FreeSound</b> (features AP
             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.Tab("3) URL FreeSound (metadata)"):
             with gr.Row():
                 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")
+                    btn_meta = gr.Button("🚀 Prédire (URL → metadata)", variant="primary")
                 with gr.Column(scale=1):
-                    gr.Markdown("### Sortie détaillée (prédictions)")
-                    out_meta = gr.Textbox(label="Résultat", lines=22)
+                    gr.Markdown("### Résultat")
+                    out_meta = gr.HTML()
             btn_meta.click(predict_from_metadata_url, inputs=url_meta, outputs=out_meta)
 
 demo.launch(theme=theme)