Update app.py

app.py

@@ -1,57 +1,89 @@
-import gradio as gr
-import pandas as pd
+import pickle
 import numpy as np
-import joblib
-from sklearn.metrics.pairwise import cosine_similarity
+import pandas as pd
+import gradio as gr
+from sklearn.neighbors import NearestNeighbors
 
-BUNDLE_PATH = "spotify_recommender.joblib"  # make sure this is in the Space
-bundle = joblib.load(BUNDLE_PATH)
+BUNDLE_PATH = "spotify_recommender.pkl"
 
-nn_model = bundle["nn_model"]
-features = bundle["features"]          # feature matrix (N x D)
-data = bundle["data"]                  # metadata DataFrame
-track_labels = bundle["track_labels"]  # list of "track – artist" labels
+with open(BUNDLE_PATH, "rb") as f:
+    bundle = pickle.load(f)
+
+nn_model: NearestNeighbors = bundle["nn_model"]
+features: np.ndarray = bundle["features"]
+track_labels = bundle["track_labels"]
 
 label_to_index = {label: i for i, label in enumerate(track_labels)}
 
-def recommend_tracks_ui(query_label, k):
+def _split_label(label: str):
+    """
+    label format: 'track_name – artist_name'
+    Uses an en dash (U+2013). Falls back gracefully if not present.
+    """
+    if " – " in label:
+        track_name, artist_name = label.split(" – ", 1)
+    else:
+        track_name, artist_name = label, ""
+    return track_name, artist_name
+
+
+def recommend_tracks_ui(query_label: str, k: int):
+    """
+    Gradio-facing function that:
+      - finds k nearest neighbors for the selected track
+      - returns a DataFrame with track_name, artist_name, similarity
+    """
     if query_label not in label_to_index:
         return pd.DataFrame(
             {"error": ["Track not found. Please select from the dropdown."]}
         )
 
     idx = label_to_index[query_label]
-    # Get k+1 neighbors and drop the first one (it is the track itself)
+
+    n_neighbors = min(len(features), int(k) + 1)
     distances, indices = nn_model.kneighbors(
-        features[idx:idx+1],
-        n_neighbors=min(len(features), int(k) + 1)
+        features[idx:idx + 1],
+        n_neighbors=n_neighbors
     )
 
-    indices = indices[0]
     distances = distances[0]
+    indices = indices[0]
 
-    # remove self (distance 0)
     mask = indices != idx
     indices = indices[mask][:int(k)]
     distances = distances[mask][:int(k)]
 
-    # cosine similarity = 1 - cosine distance
     similarities = 1.0 - distances
 
-    results = data.loc[indices, [
-        "track_name",
-        "artist_name",
-        "album_name",
-        "track_popularity",
-    ]].copy()
-    results["similarity"] = similarities
-
-    return results.reset_index(drop=True)
-
-def evaluate_mean_similarity_ui(k, n_samples):
+    rows = []
+    for i, sim in zip(indices, similarities):
+        track_name, artist_name = _split_label(track_labels[i])
+        rows.append({
+            "track_name": track_name,
+            "artist_name": artist_name,
+            "similarity": float(sim),
+        })
+
+    if not rows:
+        return pd.DataFrame({"info": ["No neighbors found. Try a different k."]})
+
+    return pd.DataFrame(rows)
+
+
+def evaluate_mean_similarity_ui(k: int, n_samples: int):
+    """
+    Evaluation function:
+      - randomly sample n_samples tracks
+      - for each, get top-k neighbors from the model
+      - compute mean cosine similarity of those neighbors
+      - return mean ± std as a string
+    """
     k = int(k)
     n_samples = int(n_samples)
     n = features.shape[0]
+    if n == 0:
+        return "No tracks in feature matrix."
+
     n_samples = min(n_samples, n)
 
     rng = np.random.default_rng(42)
@@ -59,30 +91,40 @@ def evaluate_mean_similarity_ui(k, n_samples):
 
     all_means = []
     for idx in sample_indices:
+        n_neighbors = min(n, k + 1)
         distances, indices = nn_model.kneighbors(
-            features[idx:idx+1],
-            n_neighbors=min(len(features), k + 1)
+            features[idx:idx + 1],
+            n_neighbors=n_neighbors
         )
+
         distances = distances[0]
         indices = indices[0]
 
-        # drop self
         mask = indices != idx
         distances = distances[mask][:k]
 
+        if len(distances) == 0:
+            continue
+
         similarities = 1.0 - distances
         all_means.append(similarities.mean())
 
+    if not all_means:
+        return "Could not compute evaluation (no valid neighbors)."
+
     all_means = np.array(all_means)
     mean_sim = float(all_means.mean())
     std_sim = float(all_means.std())
 
-    return f"Mean top-{k} cosine similarity over {n_samples} random tracks: {mean_sim:.4f} ± {std_sim:.4f}"
+    return (
+        f"Mean top-{k} cosine similarity over {len(all_means)} random tracks: "
+        f"{mean_sim:.4f} ± {std_sim:.4f}"
+    )
 
 with gr.Blocks(title="Spotify Content-Based Recommender") as demo:
     gr.Markdown("# 🎧 Spotify Content-Based Recommender")
     gr.Markdown(
-        "Select a song and get similar tracks based on a trained Nearest Neighbors model."
+        "Select a song and get similar tracks using a trained Nearest Neighbors model."
     )
 
     with gr.Tab("Recommender"):
@@ -111,7 +153,8 @@ with gr.Blocks(title="Spotify Content-Based Recommender") as demo:
 
     with gr.Tab("Evaluation"):
         gr.Markdown(
-            "We measure quality using **mean cosine similarity** between query tracks and their top-k recommendations."
+            "We measure quality using **mean cosine similarity** between query tracks "
+            "and their top-k recommendations."
         )
         k_eval = gr.Slider(1, 20, value=10, step=1, label="k (top-k neighbors)")
         n_eval = gr.Slider(50, 500, value=200, step=50, label="Number of random tracks to sample")