Muse: a Better Music Recommendation Application

# API: get recommended tracks data based on seed and target valuesrecommendations_api_endpoint = SPOTIFY_API_URL  + "/recommendations?seed_artists=" + ",".join(seed_artists) + "&target_energy=" + target_energy + "&target_liveness=" + target_liveness + "&target_tempo=" + target_tempo + "&target_speechiness=" + target_speechiness + "&target_acousticness=" + target_acousticness + "&target_instrumentalness=" + target_instrumentalness + "&target_danceability=" + target_danceability + "&target_loudness=" + target_loudness + "&limit=20"recommendations_response = requests.get(recommendations_api_endpoint, headers=GLOBAL['authorization_header'])
recommendation_data['data'] = json.loads(recommendations_response.text)['tracks']
 
 # set recommended track title and ids
 for track in recommendation_data['data']:
     # Dont add duplicate recommendations or songs already in your playlist
     if track['id'] not in recommendation_data['ids'] and track['id'] not in seed_data['song_ids']:
         recommendation_data['titles'].append(track['name'])
         recommendation_data['artists'].append(track['artists'][0]['name'])
         recommendation_data['ids'].append(track['id'])
         recommendation_data['images'].append(track['album']['images'][0]['url'])
 
 # API: get collected tracks attributes
 attributes_api_endpoint = SPOTIFY_API_URL  + "/audio-features?ids=" + ",".join(recommendation_data['ids'])
 attributes_response = requests.get(attributes_api_endpoint, headers=GLOBAL['authorization_header'])
 recommendation_data['attributes'] = json.loads(attributes_response.text)['audio_features']
 
 # create tracks with just the float variables
 recommendation_track_attributes = []
 for track in recommendation_data['attributes']:
     track_float_values = {}
     for attribute in target_attributes:
         track_float_values[attribute] = track[attribute]
     recommendation_track_attributes.append(track_float_values.values())
 
 # get recommendation_distances from phantom_average_track
 recommendation_distances = [phantom_average_track.values()] + recommendation_track_attributes
 dist = DistanceMetric.get_metric('euclidean')
 distances = dist.pairwise(recommendation_distances)[0]
 recommendation_data['distances'] = distances[1:len(distances)]
 
 # sort recommendation_data object based on recommendation_data distances
 sorted_recommendation_indexes = recommendation_data['distances'].argsort()[:len(recommendation_data['distances'])]
 for key in recommendation_data.keys():
     if recommendation_data[key] != []:
         recommendation_data[key] = [recommendation_data[key][i] for i in sorted_recommendation_indexes]

Once the Muse algorithm has completed, users can then click on any recommended song. The chosen song’s title and artist name will then be used to query YouTube’s API and return and then play the top related video. Users can also click the play button which will play both playlist tracks and recommendations in order by relevance score.Users can then drag recommendations they like into their playlist, which changes the composition of their playlist thus triggering the Muse algorithm to rerun and get new relevance scores and recommendations based on the playlist with the newly added song.

Automatic Playlist Generation

Although this feature is not entirely implemented yet, it is easy to imagine that a form could be put in place that would prompt a user to select a playlist, how many new songs or how many additional minutes of music they are looking for as well as how much variability in the new recommendations they would like and Muse could automatically add the number of recommendations needed to meet the expanded playlist criteria. For example, if the user wanted to add 5 new songs to the playlist that were most similar to the original playlist (by specifying low variability) then with each added recommendation sorted by relevance, the variance of the playlists’ attributes would tighten as illustrated below. On the other hand, if a user wanted to add 5 new songs that were similar but not too similar, Muse would add recommendations with lower relevance to the original playlist, which would still approach a low variance minimum for playlist attributes as illustrated below again, but at a slower rate, which in turn would expand the variability of the new playlist’s songs.

Recursive Playlist Generation

However, a more interesting algorithm than this would be to let Muse run as it is described in the previous flow chart where with the addition of each recommendation, Muse would recompile the playlist’s phantom average track based on the playlist that now contains an additional song and add a then fetch potentially completely different recommendations. This process would then continue recursively until an entire playlist with new recommendation was reached with specified duration or threshold level. This can be best visualized using a similar workflow as the one described previously, but with the addition of a final recursive step. The application of this recursive playlist generation is very interesting for its potential to create varied suggestions through a unique decision path. For example, if the user wanted to to expand a current playlist by 10 songs that were as similar to the original playlist as possible by specifying a low recommendation relevance, then Muse would add the top recommendation with each recursive iteration and approach a playlist attribute variance minimum as fast as possible until the playlist duration or number of intended songs was achieved. Yet, if a low enough recommendation relevance was set by the user (say 70%), then with each recursive iteration, Muse would add the recommendation with a relevance score closest to 70% which would mean that playlist generation may take a slower, more circuitous route towards the playlist attribute variance minimum. The best way to visualize this process is to imagine falling down a whirlpool. The initial width of whirlpool may be wide, similar to a playlist you may have containing songs with varying attributes, but as you fall further into the whirlpool, its width tightens and the playlist’s variance of song attributes approaches a minimum. It is important to note though, that like how a whirlpool twists and turns away from the center as it approaches its minimum, so too does the variability of recommended songs with each recursive step meaning that each added recommendation brings you closer to the bottom of the whirlpool, but may pull you in different directions throughout its descent depending on the variability of the recommendations. Finally, the pace at which you are pulled down the whirlpool creating a tighter playlist variance is defined by the recommendation relevance level initially set in the playlist generation form.

Billboard Playlisting

One final unique feature of Muse is that it allows users to create a playlist based of the Billboard Top 100 for any days since Billboard’s inception. A user can click on the top bottom left of the screen to change the date and Muse will use Selenium to inject the specified date into this site and then web-scrape the top 100 results to create a new playlist. Muse will then weight these songs by the number of weeks the spent on the charts and find recommended songs that sound like the top hits from that day, but could be from any era.

# if making request for billboard playlistif request.args.get('day', None, type=str) != None:from selenium import webdriver
from selenium.webdriver.common.keys import Keys
 driver = webdriver.Chrome(executable_path="./chromedriver")
 driver.get("http://www.umdmusic.com/default.asp?Chart=D")
 elem = driver.find_element_by_name('ChDay')
 elem.clear()
 elem.send_keys(request.args.get('day', 0, type=str))
 elem = driver.find_element_by_name('ChMonth')
 elem.clear()
 elem.send_keys(request.args.get('month', 0, type=str))
 elem = driver.find_element_by_name('ChYear')
 elem.clear()
 elem.send_keys(request.args.get('year', 0, type=str))
 driver.find_element_by_name('charts').submit()
 rows = driver.find_elements_by_tag_name('tr');
 rows_data = []
 for row in rows[15:40]:
     cells = row.find_elements_by_tag_name('td')
     artist = cells[4].get_attribute("innerHTML").split("</b>")[0].split('<b>')[1].rstrip()
     title =  cells[4].get_attribute("innerHTML").split("<br>")[1].rstrip()
     plays = int(cells[3].get_attribute("innerHTML").strip())
     rows_data.append([artist,title,plays])
 playlist = rows_data
 
 # extract playlist track data
 for track in playlist:
     getSong(track, False)

Further Work

• Set up unique user accounts using Firebase so as to only require initial playlist seeding by Spotify and iTunes once and to store additional metrics to improve the algorithm including skipping of songs and colloborative filtering
• Create the form mentioned previously to recursively generate entire playlists given user specifications
• Deploy as Beta application
• Compared recommendation success to other streaming services