Upload 4 files

app.py

@@ -0,0 +1,47 @@
+import gradio as gr
+from recommend import recommend_songs, recommend_by_mood
+
+def recommend_from_song(title, year):
+    try:
+        year = int(year)
+        results = recommend_songs([{'name': title, 'year': year}])
+        return format_results(results)
+    except Exception as e:
+        return f"Error: {e}"
+
+def recommend_from_mood(mood):
+    try:
+        results = recommend_by_mood(mood.lower())
+        return format_results(results)
+    except Exception as e:
+        return f"Error: {e}"
+
+def format_results(results):
+    if isinstance(results, str):
+        return results
+    if not results:
+        return "No recommendations found."
+    formatted = ""
+    for song in results:
+        formatted += f"{song['name']} ({song['year']}) — {song['artists']}\n"
+    return formatted
+
+song_interface = gr.Interface(
+    fn=recommend_from_song,
+    inputs=[gr.Textbox(label="Song Name"), gr.Textbox(label="Year")],
+    outputs="text",
+    title="🎵 Music Recommender (By Song)",
+    description="Get song recommendations based on your favorite track."
+)
+
+mood_interface = gr.Interface(
+    fn=recommend_from_mood,
+    inputs=gr.Dropdown(
+        choices=["happy", "chill", "party", "sad", "romantic", "focus", "workout", "relax", "aggressive", "uplifting"],
+        label="Choose a mood"),
+    outputs="text",
+    title="🎧 Mood-based Music Recommender",
+    description="Get music recommendations that match your mood."
+)
+
+gr.TabbedInterface([song_interface, mood_interface], ["By Song", "By Mood"]).launch()

mood_profiles.py

@@ -0,0 +1,72 @@
+mood_profiles = {
+    "happy": {
+        "valence": 0.8,
+        "energy": 0.7,
+        "danceability": 0.7,
+        "tempo": 120,
+        "acousticness": 0.2
+    },
+    "chill": {
+        "valence": 0.4,
+        "energy": 0.3,
+        "danceability": 0.4,
+        "tempo": 90,
+        "acousticness": 0.8
+    },
+    "party": {
+        "valence": 0.7,
+        "energy": 0.9,
+        "danceability": 0.9,
+        "tempo": 125,
+        "acousticness": 0.1
+    },
+    "sad": {
+        "valence": 0.2,
+        "energy": 0.3,
+        "danceability": 0.3,
+        "tempo": 80,
+        "acousticness": 0.6
+    },
+    "romantic": {
+        "valence": 0.6,
+        "energy": 0.4,
+        "danceability": 0.5,
+        "tempo": 90,
+        "acousticness": 0.7
+    },
+    "focus": {
+        "valence": 0.3,
+        "energy": 0.2,
+        "danceability": 0.3,
+        "tempo": 60,
+        "acousticness": 0.9
+    },
+    "workout": {
+        "valence": 0.6,
+        "energy": 0.95,
+        "danceability": 0.85,
+        "tempo": 130,
+        "acousticness": 0.1
+    },
+    "relax": {
+        "valence": 0.5,
+        "energy": 0.3,
+        "danceability": 0.4,
+        "tempo": 70,
+        "acousticness": 0.8
+    },
+    "aggressive": {
+        "valence": 0.2,
+        "energy": 0.95,
+        "danceability": 0.6,
+        "tempo": 140,
+        "acousticness": 0.05
+    },
+    "uplifting": {
+        "valence": 0.9,
+        "energy": 0.8,
+        "danceability": 0.6,
+        "tempo": 110,
+        "acousticness": 0.3
+    }
+}

recommend.py

@@ -0,0 +1,107 @@
+import numpy as np
+import pandas as pd
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import KMeans
+from sklearn.metrics import euclidean_distances
+from scipy.spatial.distance import cdist
+from collections import defaultdict
+import spotipy
+from spotipy.oauth2 import SpotifyClientCredentials
+
+# Load data
+data = pd.read_csv("data/data.csv")
+number_cols = ['valence', 'year', 'acousticness', 'danceability', 'duration_ms', 'energy', 'explicit',
+               'instrumentalness', 'key', 'liveness', 'loudness', 'mode', 'popularity', 'speechiness', 'tempo']
+
+# Spotify credentials (optional: use environment variables for security)
+sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(
+    client_id='e718060be300434d8b02a4451b37ecd7',
+    client_secret='4f2506ae10714d9c9f3ba30d2884b476'
+))
+
+# Clustering pipeline for preprocessing
+song_cluster_pipeline = Pipeline([
+    ('scaler', StandardScaler()),
+    ('kmeans', KMeans(n_clusters=20, random_state=42))
+])
+song_cluster_pipeline.fit(data[number_cols])
+
+def find_song(name, year):
+    song_data = defaultdict()
+    results = sp.search(q=f'track:{name} year:{year}', limit=1)
+    if results['tracks']['items'] == []:
+        return None
+
+    result = results['tracks']['items'][0]
+    track_id = result['id']
+    audio_features = sp.audio_features(track_id)[0]
+
+    song_data['name'] = [name]
+    song_data['year'] = [year]
+    song_data['explicit'] = [int(result['explicit'])]
+    song_data['duration_ms'] = [result['duration_ms']]
+    song_data['popularity'] = [result['popularity']]
+
+    for key, value in audio_features.items():
+        song_data[key] = value
+
+    return pd.DataFrame(song_data)
+
+def get_song_data(song, spotify_data):
+    try:
+        song_data = spotify_data[(spotify_data['name'] == song['name']) &
+                                 (spotify_data['year'] == song['year'])].iloc[0]
+        return song_data
+    except IndexError:
+        return find_song(song['name'], song['year'])
+
+def get_mean_vector(song_list, spotify_data):
+    song_vectors = []
+    for song in song_list:
+        song_data = get_song_data(song, spotify_data)
+        if song_data is None:
+            print(f"Warning: {song['name']} not found.")
+            continue
+        song_vector = song_data[number_cols].values
+        song_vectors.append(song_vector)
+    song_matrix = np.array(song_vectors)
+    return np.mean(song_matrix, axis=0)
+
+def flatten_dict_list(dict_list):
+    flat_dict = defaultdict(list)
+    for entry in dict_list:
+        for key, value in entry.items():
+            flat_dict[key].append(value)
+    return flat_dict
+
+def recommend_songs(song_list, spotify_data=data, n_songs=10):
+    song_dict = flatten_dict_list(song_list)
+    song_center = get_mean_vector(song_list, spotify_data)
+
+    scaler = song_cluster_pipeline.named_steps['scaler']
+    scaled_data = scaler.transform(spotify_data[number_cols])
+    scaled_song_center = scaler.transform(song_center.reshape(1, -1))
+
+    distances = cdist(scaled_song_center, scaled_data, metric='cosine')
+    indices = list(np.argsort(distances[0])[:n_songs])
+
+    recommendations = spotify_data.iloc[indices]
+    recommendations = recommendations[~recommendations['name'].isin(song_dict['name'])]
+
+    return recommendations[['name', 'year', 'artists']].to_dict(orient='records')
+
+def recommend_by_mood(mood, spotify_data=data, n_recs=10):
+    from mood_profiles import mood_profiles
+
+    if mood not in mood_profiles:
+        print(f"Invalid mood. Choose from: {list(mood_profiles.keys())}")
+        return []
+
+    mood_vector = np.array([mood_profiles[mood][col] for col in ['valence', 'energy', 'danceability', 'tempo', 'acousticness']])
+    mood_data = spotify_data[['valence', 'energy', 'danceability', 'tempo', 'acousticness']].copy()
+
+    distances = cdist([mood_vector], mood_data.values, metric='euclidean')
+    indices = np.argsort(distances[0])[:n_recs]
+
+    return spotify_data.iloc[indices][['name', 'year', 'artists']].to_dict(orient='records')

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+spotipy
+scikit-learn
+pandas
+numpy
+scipy