Create app.py

app.py

@@ -0,0 +1,127 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import joblib
+from sklearn.metrics.pairwise import cosine_similarity
+
+BUNDLE_PATH = "spotify_recommender.joblib"  # make sure this is in the Space
+bundle = joblib.load(BUNDLE_PATH)
+
+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
+
+label_to_index = {label: i for i, label in enumerate(track_labels)}
+
+def recommend_tracks_ui(query_label, k):
+    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)
+    distances, indices = nn_model.kneighbors(
+        features[idx:idx+1],
+        n_neighbors=min(len(features), int(k) + 1)
+    )
+
+    indices = indices[0]
+    distances = distances[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):
+    k = int(k)
+    n_samples = int(n_samples)
+    n = features.shape[0]
+    n_samples = min(n_samples, n)
+
+    rng = np.random.default_rng(42)
+    sample_indices = rng.choice(n, size=n_samples, replace=False)
+
+    all_means = []
+    for idx in sample_indices:
+        distances, indices = nn_model.kneighbors(
+            features[idx:idx+1],
+            n_neighbors=min(len(features), k + 1)
+        )
+        distances = distances[0]
+        indices = indices[0]
+
+        # drop self
+        mask = indices != idx
+        distances = distances[mask][:k]
+
+        similarities = 1.0 - distances
+        all_means.append(similarities.mean())
+
+    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}"
+
+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."
+    )
+
+    with gr.Tab("Recommender"):
+        song_input = gr.Dropdown(
+            choices=track_labels,
+            label="Choose a track",
+        )
+        k_input = gr.Slider(
+            minimum=1,
+            maximum=20,
+            value=10,
+            step=1,
+            label="Number of recommendations (k)",
+        )
+        recommend_button = gr.Button("Recommend")
+        rec_output = gr.Dataframe(
+            label="Recommended Tracks",
+            interactive=False
+        )
+
+        recommend_button.click(
+            fn=recommend_tracks_ui,
+            inputs=[song_input, k_input],
+            outputs=rec_output,
+        )
+
+    with gr.Tab("Evaluation"):
+        gr.Markdown(
+            "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")
+        eval_button = gr.Button("Run evaluation")
+        eval_output = gr.Textbox(label="Result")
+
+        eval_button.click(
+            fn=evaluate_mean_similarity_ui,
+            inputs=[k_eval, n_eval],
+            outputs=eval_output,
+        )
+
+demo.launch()