Spaces:
Runtime error
Runtime error
| import numpy as np | |
| import gradio as gr | |
| import pandas as pd | |
| from sklearn.metrics.pairwise import cosine_similarity | |
| import plotly.express as px | |
| import plotly.graph_objects as go | |
| import umap | |
| embedding_df = pd.read_csv('all-MiniLM-L12-v2_embeddings.csv') | |
| embeddings = np.array(embedding_df.drop('id', axis=1)) | |
| feature_df = pd.read_csv('feature_df.csv', index_col=0) | |
| feature_df= (feature_df - feature_df.mean() ) / feature_df.std() #standardize | |
| info_df = pd.read_csv('song_info_df.csv') | |
| info_df.sort_values(['artist_name','song_title'], inplace=True) | |
| def feature_similarity(song_id): | |
| std_drop = 4 #drop songs with strange values | |
| song_vec = feature_df[feature_df.index.isin([song_id])].to_numpy() | |
| songs_matrix = feature_df[~feature_df.index.isin([song_id])].copy() | |
| songs_matrix = songs_matrix[(songs_matrix<std_drop).any(axis=1)] | |
| song_ids = list(songs_matrix.index) | |
| songs_matrix=songs_matrix.to_numpy() | |
| num_dims=songs_matrix.shape[1] | |
| distances = np.sqrt(np.square(songs_matrix-song_vec) @ np.ones(num_dims)) #compute euclidean distance | |
| max_distance = np.nanmax(distances) | |
| similarities = (max_distance - distances)/max_distance #low distance -> high similarity | |
| return pd.DataFrame({'song_id': song_ids, 'feature_similarity': similarities}) | |
| def embedding_similarity(song_id): | |
| song_index = embedding_df[embedding_df.id==song_id].index.values[0] | |
| song_ids = embedding_df[embedding_df.id != song_id].id.to_list() | |
| emb_matrix = np.delete(np.copy(embeddings), song_index, axis=0) | |
| similarities = cosine_similarity(emb_matrix, np.expand_dims(np.copy(embeddings[song_index,:]), axis=0)) | |
| return pd.DataFrame({'song_id': song_ids, 'cosine_similarity': similarities[:,0]}) | |
| def decode(song_id): | |
| temp_df = info_df[info_df.song_id == song_id] | |
| artist = temp_df.artist_name.values[0] | |
| song = temp_df.song_title.values[0] | |
| youtube_url = f"""<a href=https://www.youtube.com/results?search_query= | |
| {artist.replace(' ','+')}+{song}.replace(' ','+') target=_blank>{song}</a>""" | |
| url = f'''<a href="https://www.youtube.com/results?search_query= | |
| {artist.strip().replace(' ','+')}+{song.strip().replace(' ','+')}" target="_blank" style="color:blue; text-decoration: underline"> | |
| {song} </a> by {artist}''' | |
| return url | |
| def plot(artist, song): | |
| plot_df['color'] = 'blue' | |
| plot_df.loc[(plot_df.artist_name==artist) & (plot_df.song_title==song), 'color'] = 'red' | |
| plot_df['size'] = 1.5 | |
| plot_df.loc[(plot_df.artist_name==artist) & (plot_df.song_title==song), 'size'] = 3 | |
| try: | |
| fig2.data=[] | |
| except: | |
| pass | |
| fig2 = px.scatter(plot_df[~((plot_df.artist_name==artist) & (plot_df.song_title==song))], | |
| 'x', | |
| 'y', | |
| template='simple_white', | |
| hover_data=['artist_name', 'song_title']).update_traces(marker_size=1.5, marker_opacity=0.7) | |
| fig2.add_trace(go.Scatter(x=[plot_df.loc[(plot_df.artist_name==artist) & (plot_df.song_title==song), 'x'].values[0]], | |
| y=[plot_df.loc[(plot_df.artist_name==artist) & (plot_df.song_title==song), 'y'].values[0]], | |
| mode = 'markers', | |
| marker_color='red', | |
| hovertemplate="Your selected song<extra></extra>", | |
| marker_size = 4)) | |
| fig2.update_xaxes(visible=False) | |
| fig2.update_yaxes(visible=False).update_layout(height = 800, | |
| width =1500, | |
| showlegend=False, | |
| title = { | |
| 'text': "UMAP Projection of Lyric Embeddings", | |
| 'y':0.9, | |
| 'x':0.5, | |
| 'xanchor': 'center', | |
| 'yanchor': 'top' | |
| }) | |
| fig2.data = [fig2.data[1], fig2.data[0]] | |
| return fig2 | |
| def recommend(artist, song_title, embedding_importance, topk=5): | |
| feature_importance = 1 - embedding_importance | |
| song_id = info_df[(info_df.artist_name == artist) & (info_df.song_title == song_title)]['song_id'].values[0] | |
| feature_sim = feature_similarity(song_id) | |
| embedding_sim = embedding_similarity(song_id) | |
| result = embedding_sim.merge(feature_sim, how='left',on='song_id').dropna() | |
| result['cosine_similarity'] = (result['cosine_similarity'] - result['cosine_similarity'].min())/ \ | |
| (result['cosine_similarity'].max() - result['cosine_similarity'].min()) | |
| result['feature_similarity'] = (result['feature_similarity'] - result['feature_similarity'].min())/ \ | |
| (result['feature_similarity'].max() - result['feature_similarity'].min()) | |
| result['score'] = embedding_importance*result.cosine_similarity + feature_importance*result.feature_similarity | |
| exclude_phrases = [r'clean', 'interlude', 'acoustic', r'mix', 'intro', r'original', 'version',\ | |
| 'edited', 'extended'] | |
| result = result[~result.song_id.isin(info_df[info_df.song_title.str.lower().str.contains('|'.join(exclude_phrases))].song_id)] | |
| body='<br>'.join([decode(x) for x in result.sort_values('score', ascending=False).head(topk).song_id.to_list()]) | |
| fig = plot(artist, song_title) | |
| return f'<h3 style="text-align: center;">Recommendations</h3><p style="text-align: center;"><br>{body}</p>', fig | |
| out = umap.UMAP(n_neighbors=30, min_dist=0.2).fit_transform(embedding_df.iloc[:,:-1]) | |
| plot_df = pd.DataFrame({'x':out[:,0],'y':out[:,1],'id':embedding_df.id, 'size':0.1}) | |
| plot_df['x'] = ((plot_df['x'] - plot_df['x'].mean())/plot_df['x'].std()) | |
| plot_df['y'] = ((plot_df['y'] - plot_df['y'].mean())/plot_df['y'].std()) | |
| plot_df = plot_df.merge(info_df, left_on='id', right_on='song_id') | |
| plot_df = plot_df[(plot_df.x.abs()<4) & (plot_df.y.abs()<4)] | |
| fig = px.scatter(plot_df, | |
| 'x', | |
| 'y', | |
| template='simple_white', | |
| hover_data=['artist_name', 'song_title'] | |
| ).update_traces(marker_size=1.5, | |
| opacity=0.7, | |
| ) | |
| fig.update_xaxes(visible=False) | |
| fig.update_yaxes(visible=False).update_layout(height = 800, | |
| width =1500, | |
| title = { | |
| 'text': "UMAP Projection of Lyric Embeddings", | |
| 'y':0.9, | |
| 'x':0.5, | |
| 'xanchor': 'center', | |
| 'yanchor': 'top' | |
| }) | |
| app = gr.Blocks() | |
| with app: | |
| gr.Markdown("# Hip Hop gRadio - A Lyric Based Recommender") | |
| gr.Markdown("""### About this space | |
| The goal of this space is to provide recommendations for hip-hop/rap songs strictly by utilizing lyrics. The recommendations | |
| are a combination of ranked similarity scores. We calculate euclidean distances between our engineered feature vectors for each song, | |
| as well as a cosine distance between document embeddings of the lyrics themselves. A weighted average of these two results in our | |
| final similarity score that we use for recommendation. (feature importance = (1 - embedding importance)) | |
| Additionally, we provide a 2-D projection of all document embeddings below. After entering a song of your choice, you will see it as | |
| a red dot, allowing you to explore both near and far. This projection reduces 384-dimensional embeddings down to 2-d, allowing visualization. | |
| This is done using Uniform Manifold Approximation and Projection [(UMAP)](https://umap-learn.readthedocs.io/en/latest/), a very interesting approach to dimensionalty | |
| reduction, I encourage you to look into it if you are interested! ([paper](https://arxiv.org/abs/1802.03426)) | |
| The engineered features used are the following: song duration, number of lines, syllables per line, variance in syllables per line, | |
| total unique tokens, lexical diversity (measure of repitition), sentiment (using nltk VADER), tokens per second, and syllables per second. | |
| **Model used for embedding**: [all-MiniLM-L12-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L12-v2)<br/> | |
| **Lyrics**: from [genius](https://genius.com/) | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| artist = gr.Dropdown(choices = list(info_df.artist_name.unique()), | |
| value = 'Kanye West', | |
| label='Artist') | |
| song = gr.Dropdown(choices = list(info_df.loc[info_df.artist_name=='Kanye West','song_title']), | |
| label = 'Song Title') | |
| slider = gr.Slider(0,1,value=0.5, label='Embedding Importance') | |
| but = gr.Button() | |
| with gr.Column(): | |
| t = gr.Markdown('<h3 style="text-align: center;">Recomendations</h3>') | |
| with gr.Row(): | |
| p = gr.Plot(fig) | |
| def artist_songs(artist): | |
| return gr.components.Dropdown.update(choices=info_df[info_df.artist_name == artist]['song_title'].to_list()) | |
| artist.change(artist_songs, artist, outputs=song) | |
| but.click(recommend, inputs=[artist, song,slider], outputs=[t, p]) | |
| with gr.Row(): | |
| gr.Markdown("") | |
| app.launch() | |