Add demo interface + models

.gitignore

@@ -0,0 +1 @@
+.DS_Store

app.py

@@ -1,307 +1,180 @@
-import gradio as gr
 import os
-import pandas as pd
+import tempfile
 import numpy as np
-from sklearn.preprocessing import KBinsDiscretizer, StandardScaler, OneHotEncoder
-from sklearn.feature_extraction.text import HashingVectorizer
-from collections import Counter
+import pandas as pd
+import gradio as gr
+
 import joblib
-import freesound
-import gensim.downloader as api
-
-# -------- FreeSound API --------
-client = freesound.FreesoundClient()
-client.set_token("zE9NjEOgUMzH9K7mjiGBaPJiNwJLjSM53LevarRK", "token")
-
-dataset_dir = "dataset_audio"
-os.makedirs(dataset_dir, exist_ok=True)
-
-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 = X.copy()
-        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
-        X_transformed = np.array([self.class_mapping.get(v, "MissedInfo") for v in Xt])
-        return X_transformed
-
-
-# -------- Charger les objets sauvegardés --------
-# Music
-scaler_samplerate_music = joblib.load("music/scaler_music_samplerate.joblib")
-scaler_age_days_music = joblib.load("music/scaler_music_age_days_log.joblib")
-username_freq_music = joblib.load("music/username_freq_dict_music.joblib")
-est_num_downloads_music = joblib.load("music/est_num_downloads_music.joblib")
-avg_rating_transformer_music = joblib.load("music/avg_rating_transformer_music.joblib")
-music_subcategory_cols = joblib.load("music/music_subcategory_cols.joblib")
-music_onehot_cols = joblib.load("music/music_onehot_cols.joblib")
-music_onehot_tags = joblib.load("music/music_onehot_tags.joblib")
-
-
-
-# EffectSound
-scaler_samplerate_effect = joblib.load("effectSound/scaler_effectSamplerate.joblib")
-scaler_age_days_effect = joblib.load("effectSound/scaler_effectSound_age_days_log.joblib")
-username_freq_effect = joblib.load("effectSound/username_freq_dict_effectSound.joblib")
-est_num_downloads_effect = joblib.load("effectSound/est_num_downloads_effectSound.joblib")
-avg_rating_transformer_effect = joblib.load("effectSound/avg_rating_transformer_effectSound.joblib")
-effect_subcategory_cols = joblib.load("effectSound/effectSound_subcategory_cols.joblib")
-effect_onehot_cols = joblib.load("effectSound/effectSound_onehot_cols.joblib")
-effect_onehot_tags = joblib.load("effectSound/effect_onehot_tags.joblib")
-
-# GloVe pour description
-glove_model = api.load("glove-wiki-gigaword-100")
-
-# -------- Fonctions --------
-
-
-
-def fetch_sound_metadata(sound_url):
-    """Télécharge les métadonnées du son FreeSound"""
-    sound_id = int(sound_url.rstrip("/").split("/")[-1])
-    sound = client.get_sound(sound_id)
-    file_name = f"{sound.name.replace(' ', '_')}.mp3"
-    file_path = os.path.join(dataset_dir, file_name)
+import soundfile as sf
+from pydub import AudioSegment
+
+import opensmile
+
+
+# =========================
+# Config
+# =========================
+SR_TARGET = 16000
+MIN_EFFECT, MAX_EFFECT = 0.5, 3.0
+MIN_MUSIC, MAX_MUSIC = 10.0, 60.0
+
+MODEL_EFFECT_PATH = "xgb_model_EffectSound.pkl"
+MODEL_MUSIC_PATH  = "xgb_model_Music.pkl"
+
+# openSMILE (comme ton script)
+SMILE = opensmile.Smile(
+    feature_set=opensmile.FeatureSet.eGeMAPSv02,
+    feature_level=opensmile.FeatureLevel.Functionals,
+)
+
+# Charger modèles (sans print, pour éviter les soucis de repr)
+MODEL_EFFECT = joblib.load(MODEL_EFFECT_PATH)
+MODEL_MUSIC = joblib.load(MODEL_MUSIC_PATH)
+
+
+# =========================
+# Helpers audio
+# =========================
+def get_duration_seconds(filepath: str) -> float:
+    ext = os.path.splitext(filepath)[1].lower()
+    if ext == ".mp3":
+        audio = AudioSegment.from_file(filepath)
+        return len(audio) / 1000.0
+    # wav / flac / ogg...
+    with sf.SoundFile(filepath) as f:
+        return len(f) / float(f.samplerate)
+
+def to_wav_16k_mono(filepath: str) -> str:
+    """
+    Convertit l'audio en WAV 16k mono pour openSMILE.
+    Retourne le chemin d’un fichier wav temporaire.
+    """
+    ext = os.path.splitext(filepath)[1].lower()
+
+    # Si WAV déjà ok, on peut le garder (mais on vérifie sr/channels)
+    if ext == ".wav":
+        try:
+            with sf.SoundFile(filepath) as f:
+                if f.samplerate == SR_TARGET and f.channels == 1:
+                    return filepath
+        except Exception:
+            pass
+
+    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: str) -> pd.DataFrame:
+    wav_path = to_wav_16k_mono(filepath)
+    feats = SMILE.process_file(wav_path)
+
+    # Nettoyage : garder uniquement colonnes numériques
+    feats = feats.select_dtypes(include=[np.number]).copy()
+    feats.reset_index(drop=True, inplace=True)
+    return feats
+
+
+# =========================
+# Prediction
+# =========================
+def predict_popularity(audio_file):
+    """
+    audio_file: chemin fourni par Gradio (type="filepath")
+    """
+    if audio_file is None:
+        return "❌ Merci d’uploader un fichier audio."
+
+    path = audio_file
     try:
-        sound.retrieve_preview(dataset_dir, file_name)
+        dur = get_duration_seconds(path)
     except Exception as e:
-        print(f"Erreur téléchargement {file_name}: {e}")
-        file_path = None
-    data = {
-        "file_path": file_path,
-        "name": sound.name,
-        "num_ratings": sound.num_ratings,
-        "tags": ",".join(sound.tags) if getattr(sound, "tags", None) else "",
-        "username": sound.username,
-        "description": sound.description if sound.description else "",
-        "created": getattr(sound, "created", ""),
-        "license": getattr(sound, "license", ""),
-        "num_downloads": getattr(sound, "num_downloads", 0),
-        "channels": getattr(sound, "channels", 0),
-        "filesize": getattr(sound, "filesize", 0),
-        "num_comments": getattr(sound, "num_comments", 0),
-        "category_is_user_provided": getattr(sound, "category_is_user_provided", 0),
-        "duration": getattr(sound, "duration", 0),
-        "avg_rating": getattr(sound, "avg_rating", 0),
-        "category": getattr(sound, "category", "Unknown"),
-        "subcategory": getattr(sound, "subcategory", "Other"),
-        "type": getattr(sound, "type", ""),
-        "samplerate": getattr(sound, "samplerate", 0)
-    }
-    return pd.DataFrame([data])
-
-def description_to_vec(text, model, dim=100):
-    if not text:
-        return np.zeros(dim)
-    words = 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 preprocess_sound(df):
-    """Applique le preprocessing complet selon duration pour choisir music ou effectSound"""
-    df = df.copy()
-    dur = df["duration"].iloc[0]
-    
-    if 0.5 <= dur <= 3:
-        dataset_type = "effectSound"
-        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 10 <= dur <= 60:
-        dataset_type = "music"
-        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
+        return f"❌ Impossible de lire l’audio : {e}"
+
+    # Vérif plage
+    if dur < MIN_EFFECT:
+        return (
+            f"❌ Audio trop court ({dur:.2f}s).\n\n"
+            f"Plages acceptées :\n"
+            f"- SoundEffect : {MIN_EFFECT} à {MAX_EFFECT} secondes\n"
+            f"- Music : {MIN_MUSIC} à {MAX_MUSIC} secondes"
+        )
+
+    if (MAX_EFFECT < dur < MIN_MUSIC) or (dur > MAX_MUSIC):
+        return (
+            f"❌ Audio trop long / hors plage ({dur:.2f}s).\n\n"
+            f"Plages acceptées :\n"
+            f"- SoundEffect : {MIN_EFFECT} à {MAX_EFFECT} secondes\n"
+            f"- Music : {MIN_MUSIC} à {MAX_MUSIC} secondes"
+        )
+
+    # Choix type
+    if MIN_EFFECT <= dur <= MAX_EFFECT:
+        dataset_type = "SoundEffect"
+        model = MODEL_EFFECT
     else:
-        return f"❌ Son trop court ou trop long ({dur} sec)"
-
-    # ----------------- Features -----------------
-    # 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
-    for col in ["num_ratings", "num_comments", "filesize", "duration"]:
-        df[col] = np.log1p(df[col])
-    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"])
-  
-    # num_downloads
-    df["num_downloads_class"] = est_num_downloads.transform(df[["num_downloads"]])
-    
-    # avg_rating
-    df["avg_rating"] = avg_rating_transformer.transform(df["avg_rating"].to_numpy())
-    
-    # Subcategory
-    for col in subcat_cols:
-        df[col] = 0  # toutes les colonnes initialisées à 0
-    # activer 1 pour la bonne subcategory
-    subcat_val = df["subcategory"].iloc[0]
-    for col in subcat_cols:
-        cat_name = col.replace("subcategory_", "")
-        if subcat_val == cat_name:
-            df[col] = 1
-    df.drop(columns=["subcategory"], inplace=True)
-        
-    
-
-    # créer toutes les colonnes attendues à 0
-    for col in onehot_cols:
-        if col not in df.columns:
-            df[col] = 0
-
-    # activer les bonnes colonnes one-hot
-    license_val = df.loc[0, "license"]
-    category_val = df.loc[0, "category"]
-    type_val = df.loc[0, "type"]
-
-    for col_name in [
-        f"license_{license_val}",
-        f"category_{category_val}",
-        f"type_{type_val}",
-    ]:
-        if col_name in df.columns:
-            df[col_name] = 1
-
-
-
-
-        
-    # Tags
-    # Si la colonne "tags" n'existe pas, on la crée avec une valeur vide
-    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(",")
-
-    # Si aucun tag n'existe ou que la liste est vide, mettre "Other"
-    if not df["tags_list"].iloc[0] or df["tags_list"].iloc[0] == [""]:
-        df["tags_list"] = [["Other"]]
-
-    # One-hot sur toutes les colonnes enregistrées
-    for col in onehot_tags:
-        tag_name = col.replace("tag_", "").replace("_", " ")
-        df[col] = int(tag_name in df["tags_list"].iloc[0])
-
-    # Supprimer les colonnes temporaires
-    df.drop(columns=["tags_list", "tags"], inplace=True)
-
-
-    # Name
-    df["name_clean"] = df["name"].astype(str).str.lower().str.rsplit(".", n=1).str[0]
-    vectorizer = HashingVectorizer(n_features=8, alternate_sign=False, norm=None)
-    name_vec = vectorizer.transform(df["name_clean"])
-    for i in range(8):
-        df[f"name_vec_{i}"] = name_vec.toarray()[0][i]
-    df.drop(columns=["name","name_clean"], inplace=True)
-
-    
-    # Description
-    desc_vec = description_to_vec(df["description"].iloc[0], glove_model)
-    for i in range(100):
-        df[f"description_glove_{i}"] = desc_vec[i]
-    df.drop(columns=["description"], inplace=True)
-
-    
-    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:
-        if col in df.columns:
-            final_cols.append(col)
-
-    # subcategories
-    for col in subcat_cols:
-        if col in df.columns:
-            final_cols.append(col)
-
-    # le reste
-    final_cols += [c for c in df.columns if c not in final_cols]
-
-    df = df[final_cols]
-
-
-
-
-    return df
-
-# -------- 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)
+        dataset_type = "Music"
+        model = MODEL_MUSIC
 
-    # 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)"
-
-    # 3️ Prétraitement seulement si durée ok
-    df_processed = preprocess_sound(df_raw)
-
-    # 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)
-
-    return raw_str + processed_str
-
-
-
-
-
-with gr.Blocks(title="FreeSound Popularity Detector") as demo:
-    gr.Markdown("# 🎧 FreeSound Popularity Detector")
-    gr.Markdown("Collez l'URL d'un son FreeSound et le preprocessing complet sera appliqué automatiquement.")
-
-    url_input = gr.Textbox(label="URL du son FreeSound")
-    btn_meta = gr.Button("📊 Prétraiter et afficher features")
-    output = gr.Textbox(label="Résultat")
+    # Extraction openSMILE
+    try:
+        X = extract_opensmile_features(path)
+    except Exception as e:
+        return f"❌ Erreur extraction openSMILE : {e}"
 
-    btn_meta.click(fn=predict_with_metadata, inputs=url_input, outputs=output)
+    # Prédiction
+    try:
+        y = model.predict(X)
+    except Exception as e:
+        return (
+            "❌ Erreur pendant la prédiction.\n\n"
+            f"Détail: {e}\n\n"
+            "👉 Si ça arrive sur Space, c’est souvent un souci de versions (sklearn/xgboost). "
+            "Voir requirements.txt proposé plus bas."
+        )
+
+    # y peut être (1,2) ou autre. On gère robuste.
+    y = np.array(y)
+
+    # Essai : 2 sorties
+    if y.ndim == 2 and y.shape[1] >= 2:
+        pred_avg_rating = y[0, 0]
+        pred_num_downloads = y[0, 1]
+    elif y.ndim == 1 and y.shape[0] >= 2:
+        pred_avg_rating = y[0]
+        pred_num_downloads = y[1]
+    else:
+        return f"✅ Type: {dataset_type} | Durée: {dur:.2f}s\n\nPrédiction brute: {y}"
+
+    return (
+        f"✅ Type détecté : **{dataset_type}**\n"
+        f"⏱️ Durée : **{dur:.2f} s**\n\n"
+        f"📈 **avg_rating (prédit)** : {pred_avg_rating}\n"
+        f"⬇️ **num_downloads (prédit)** : {pred_num_downloads}"
+    )
+
+
+# =========================
+# UI Gradio
+# =========================
+with gr.Blocks(title="Popularity Predictor (openSMILE)") as demo:
+    gr.Markdown("# 🎧 Popularity Predictor")
+    gr.Markdown(
+        "Upload un audio. Si la durée est dans l’une des plages, "
+        "on extrait les features openSMILE (eGeMAPS) puis on prédit **avg_rating** et **num_downloads**.\n\n"
+        f"- SoundEffect: **{MIN_EFFECT}–{MAX_EFFECT}s**\n"
+        f"- Music: **{MIN_MUSIC}–{MAX_MUSIC}s**"
+    )
+
+    audio_in = gr.Audio(label="Uploader un audio", type="filepath")
+    btn = gr.Button("🚀 Prédire")
+
+    out = gr.Markdown()
+
+    btn.click(fn=predict_popularity, inputs=audio_in, outputs=out)
 
 demo.launch()

requirements.txt

@@ -1,8 +1,9 @@
-gradio==6.5.0
-scikit-learn
+gradio
 numpy
 pandas
-gensim
-pytz
-git+https://github.com/MTG/freesound-python
-
+joblib
+soundfile
+pydub
+opensmile
+scikit-learn==1.8.0
+xgboost

xgb_model_EffectSound.pkl

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

xgb_model_Music.pkl

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