predict with metadata : preparation of data

app.py

@@ -1,17 +1,154 @@
 import gradio as gr
+import os
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import KBinsDiscretizer, StandardScaler, OneHotEncoder
+import freesound
+import gensim.downloader as api
+
+
+# Token FreeSound
+client = freesound.FreesoundClient()
+client.set_token("zE9NjEOgUMzH9K7mjiGBaPJiNwJLjSM53LevarRK")
+
+# Répertoire dataset
+dataset_dir = "dataset_audio"
+os.makedirs(dataset_dir, exist_ok=True)
+
+# Liste des métadonnées importantes
+metadata_cols = ["name", "num_ratings", "tags", "username",
+    "description", "created", "license", "num_downloads", "channels",
+    "filesize", "category_is_user_provided", "duration", "avg_rating",
+    "category", "subcategory", "type", "samplerate"
+]
+
+def fetch_sound_metadata(sound_url):
+    # Extraire l'ID FreeSound de l'URL
+    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)
+
+    # Télécharger le preview
+    try:
+        sound.retrieve_preview(dataset_dir, file_name)
+    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 hasattr(sound, "tags") 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),
+        "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 preprocess_targets(df):
+    # num_downloads -> discretisation 3 classes
+    X = df["num_downloads"].to_numpy().reshape(-1,1)
+    est = KBinsDiscretizer(n_bins=3, encode="ordinal", strategy="quantile")
+    df["num_downloads_class"] = est.fit_transform(X).astype(int)
+
+    # avg_rating -> discretisation en 4 classes
+    mask_non_zero = df["avg_rating"] != 0
+    X_non_zero = df.loc[mask_non_zero, "avg_rating"].to_numpy().reshape(-1,1)
+    est = KBinsDiscretizer(n_bins=3, encode="ordinal", strategy="quantile")
+    df["avg_rating_class"] = 0
+    df.loc[mask_non_zero, "avg_rating_class"] = est.fit_transform(X_non_zero).flatten().astype(int) + 1
+    df["avg_rating"] = df["avg_rating_class"]
+    df.drop(columns=["avg_rating_class"], inplace=True)
+
+    return df
+
+def preprocess_features(df):
+    df = df.copy()
+
+    # Colonnes booléennes
+    df["category_is_user_provided"] = df["category_is_user_provided"].astype(int)
+
+    # Colonnes catégorielles -> one-hot
+    cat_cols = ["license", "category", "type"]
+    df[cat_cols] = df[cat_cols].fillna("Unknown")
+    df = pd.get_dummies(df, columns=cat_cols, drop_first=False)
+
+    # username -> frequency encoding
+    user_freq = df["username"].value_counts(normalize=True)
+    df["username_freq"] = df["username"].map(user_freq)
+    df.drop(columns=["username"], inplace=True)
+
+    # subcategory -> one-hot, rare <2% regroupé
+    df["subcategory"] = df["subcategory"].fillna("Other")
+    counts = df["subcategory"].value_counts(normalize=True)*100
+    rare_subs = counts[counts<2].index
+    df["subcategory"] = df["subcategory"].apply(lambda x: "Other" if x in rare_subs else x)
+    ohe = OneHotEncoder(sparse_output=False)
+    subcat_ohe = ohe.fit_transform(df[["subcategory"]])
+    subcat_df = pd.DataFrame(subcat_ohe, columns=[f"subcategory_{c}" for c in ohe.categories_[0]], index=df.index)
+    df = pd.concat([df, subcat_df], axis=1)
+    df.drop(columns=["subcategory"], inplace=True)
+
+    # Colonnes numériques -> log1p + standard scaler
+    numeric_cols = ["num_ratings", "filesize", "duration", "samplerate"]
+    for col in numeric_cols:
+        df[col] = np.log1p(df[col])
+    scaler = StandardScaler()
+    df[numeric_cols] = scaler.fit_transform(df[numeric_cols])
+
+    # Description -> vecteur GloVe 100 dim
+    glove_model = api.load("glove-wiki-gigaword-100")
+    def description_to_vec(text, model):
+        if not text: return np.zeros(100)
+        words = text.lower().split()
+        vecs = [model[w] for w in words if w in model]
+        return np.mean(vecs, axis=0) if vecs else np.zeros(100)
+    desc_vecs = np.vstack(df['description'].fillna('').apply(lambda x: description_to_vec(x, glove_model)))
+    desc_cols = [f'description_glove_{i}' for i in range(desc_vecs.shape[1])]
+    df[desc_cols] = pd.DataFrame(desc_vecs, columns=desc_cols, index=df.index)
+    df.drop(columns=["description"], inplace=True)
+
+    return df
+
+
+
 
 # -------- Fonctions (logique plus tard) --------
 
 def predict_with_metadata(url):
     if url.strip() == "":
         return "❌ Veuillez entrer une URL FreeSound."
-    
-    # PLUS TARD :
-    # - extraire ID
-    # - appeler API FreeSound
-    # - calculer score
-    
-    return "🔍 Résultat (métadonnées) : SON POPULAIRE (exemple)"
+
+    try:
+        # Récupérer les métadonnées
+        df = fetch_sound_metadata(url)
+        
+        # Prétraiter les targets et features si besoin
+        df = preprocess_targets(df)
+        df = preprocess_features(df)
+        
+        # Afficher un résumé clair des métadonnées extraites
+        info = df.T  # transpose pour afficher colonne -> valeur
+        info_str = "\n".join([f"{idx}: {val[0]}" for idx, val in info.iterrows()])
+        return f"✅ Métadonnées extraites :\n\n{info_str}"
+
+    except Exception as e:
+        return f"❌ Erreur lors de l'extraction : {e}"
 
 def predict_with_audio(url):
     if url.strip() == "":