initial commit

.env

@@ -0,0 +1,2 @@
+SPOTIFY_CLIENT_ID=111597a76d6a42f3add7008145f16284
+SPOTIFY_CLIENT_SECRET=dbb5781e8e8a4d39a012a2ad27fb2e27

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+kmeans_clustered_spotify_dataset.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,89 @@
+import os
+import spotipy
+import gradio as gr
+import pandas as pd
+
+from dotenv import load_dotenv
+from recommendations import recommend_songs
+from spotipy.oauth2 import SpotifyClientCredentials
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Access the Spotify API credentials
+client_id = os.getenv('SPOTIFY_CLIENT_ID')
+client_secret = os.getenv('SPOTIFY_CLIENT_SECRET')
+
+# Authenticate with the Spotify API
+sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(client_id=client_id, client_secret=client_secret))
+
+data = pd.read_csv("kmeans_clustered_spotify_dataset.csv")
+
+def fetch_song_cover(song_name):
+    # Search for the song
+    results = sp.search(q=song_name, limit=1, type='track')
+    if results['tracks']['items']:
+        song = results['tracks']['items'][0]
+        cover_url = song['album']['images'][0]['url']
+        user_song_name = song['name']
+
+        user_song = song['name']
+
+        return cover_url, song['name'], song['artists'][0]['name']
+    else:
+        return None, "Song not found", "Artist not found"
+
+def get_recommendations(song_name):
+  suggestions = recommend_songs(song_list=[{'name': song_name}], spotify_data=data)
+  song_covers = []
+
+  for suggestion in suggestions:
+    print(suggestion)
+    cover = fetch_song_cover(suggestion["name"])
+    song_covers.append(cover[0])
+
+  return song_covers
+
+# Gradio Interface
+def gradio_interface(song_name):
+    cover_url, song_name, artist_name = fetch_song_cover(song_name)
+
+    if cover_url:
+        return cover_url, f"Song: {song_name}", f"Artist: {artist_name}", gr.update(visible=True), gr.update(visible=True)
+    else:
+        return None, "Song not found", "Artist not found"
+
+# Creating Gradio Interface
+with gr.Blocks() as demo:
+    gr.Markdown("# Music Recommendation System using Spotify Dataset")
+
+    with gr.Row():
+        with gr.Column():
+            song_input = gr.Textbox(label="Enter Song Name")
+            search_button = gr.Button("Find Song")
+
+        with gr.Column():
+            cover_output = gr.Image(label="Cover Image")
+            song_name_output = gr.Textbox(label="Song Name")
+            artist_name_output = gr.Textbox(label="Artist Name")
+
+    recommendations_labels = gr.Row(visible=False)
+    
+    recommendations_songs = gr.Column(visible=False)
+
+    with recommendations_labels:
+      gr.Markdown("# You may also like")
+
+    with recommendations_songs: 
+      song_covers = gr.Gallery(label="Image Gallery")
+
+    search_button.click(fn=gradio_interface, 
+                        inputs=song_input, 
+                        outputs=[cover_output, song_name_output, artist_name_output, recommendations_labels, recommendations_songs]).then(
+                                  fn=get_recommendations,
+                                  inputs=song_input,
+                                  outputs=song_covers
+                              )
+
+# Launching the Gradio app
+demo.launch(debug=True)

kmeans_clustered_spotify_dataset.csv

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

recommendations.py

@@ -0,0 +1,112 @@
+
+import os
+import spotipy
+import difflib
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+
+from dotenv import load_dotenv
+from spotipy.oauth2 import SpotifyClientCredentials
+from collections import defaultdict
+from sklearn.metrics import euclidean_distances
+from scipy.spatial.distance import cdist
+
+number_cols = ['valence', 'year', 'acousticness', 'danceability', 'duration_ms', 'energy', 'explicit',
+ 'instrumentalness', 'key', 'liveness', 'loudness', 'mode', 'popularity', 'speechiness', 'tempo']
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Access the Spotify API credentials
+client_id = os.getenv('SPOTIFY_CLIENT_ID')
+client_secret = os.getenv('SPOTIFY_CLIENT_SECRET')
+
+sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(client_id=client_id,
+                              client_secret=client_secret))
+
+def find_song(name):
+  song_data = defaultdict()
+  results = sp.search(q=name, limit=1, type='track')
+  if results["tracks"]["items"] == []:
+    return None
+
+  results = results["tracks"]["items"][0]
+  track_id = results["id"]
+  audio_features = sp.audio_features(track_id)[0]
+
+  song_data["name"] = [name]
+  song_data["year"] = [int(results['album']['release_date'].split("-")[0])]
+  song_data["artist"] = [results['artists'][0]['name']]
+  song_data["explicit"] = [int(results['explicit'])]
+  song_data['duration_ms'] = [results['duration_ms']]
+  song_data['popularity'] = [results['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'])].iloc[0]
+        print(f"Finding the song in the fitted data.")
+        return song_data
+
+    except IndexError:
+        print(f"Could not find song in the fitted data. Trying to fetch online now...")
+        return find_song(song['name'])
+
+
+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('Warning: {} does not exist in Spotify or in database'.format(song['name']))
+            continue
+        song_vector = song_data[number_cols].values
+        song_vectors.append(song_vector)
+
+    song_matrix = np.array(list(song_vectors))
+    return np.mean(song_matrix, axis=0)
+
+
+def flatten_dict_list(dict_list):
+
+    flattened_dict = defaultdict()
+    for key in dict_list[0].keys():
+        flattened_dict[key] = []
+
+    for dictionary in dict_list:
+        for key, value in dictionary.items():
+            flattened_dict[key].append(value)
+
+    return flattened_dict
+
+
+def recommend_songs( song_list, spotify_data, n_songs=10):
+
+    metadata_cols = ['name', 'year', 'artists']
+    song_dict = flatten_dict_list(song_list)
+
+    # song_center = get_mean_vector(song_list, spotify_data)
+
+    song_center = get_song_data(song_list[0], spotify_data)[number_cols].values
+
+    scaler = StandardScaler()
+    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, 'cosine')
+    index = list(np.argsort(distances)[:, :n_songs][0])
+
+    rec_songs = spotify_data.iloc[index]
+    rec_songs['name'] = rec_songs['name'].apply(lambda x: x.lower())
+    song_dict['name'] = [x.lower() for x in song_dict['name']]
+
+    rec_songs = rec_songs[~rec_songs['name'].isin(song_dict['name'])]
+    return rec_songs[metadata_cols].to_dict(orient='records')

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+pandas
+numpy
+scikit-learn
+scipy
+spotipy
+python-dotenv