Spaces:
Build error
Build error
| import streamlit as st | |
| import pandas as pd | |
| import plotly.express as px | |
| import seaborn as sns | |
| import matplotlib.pyplot as plt | |
| import networkx as nx | |
| import plotly.graph_objects as go | |
| from itertools import chain, combinations | |
| import numpy as np | |
| from collections import Counter | |
| def generate_popularity_trends(df): | |
| st.header("Popularity Trends Over Time") | |
| tab1, tab2, tab3 = st.tabs( | |
| ["Average Popularity", "Individual Songs", "Top 10 Songs"]) | |
| with tab1: | |
| st.markdown( | |
| "**Average Popularity by Decade:** This chart shows how the average popularity of songs has changed over different decades.") | |
| if 'Decade' in df.columns: | |
| top_decades = df.groupby('Decade')['Popularity'].mean( | |
| ).reset_index().nlargest(10, 'Popularity') | |
| fig1 = go.Figure() | |
| fig1.add_trace(go.Scatter( | |
| x=top_decades['Decade'], | |
| y=top_decades['Popularity'], | |
| mode='lines+markers', | |
| fill='tonexty', | |
| line=dict(color='royalblue', width=3), | |
| marker=dict(size=8, color='darkblue', | |
| line=dict(width=2, color='white')), | |
| name='Popularity', | |
| hovertext=top_decades['Decade'] | |
| )) | |
| fig1.update_layout( | |
| title='Top 10 Decades by Average Popularity', | |
| xaxis_title='Decade', | |
| yaxis_title='Average Popularity Score', | |
| template='plotly_white', | |
| width=900, | |
| height=450 | |
| ) | |
| st.plotly_chart(fig1) | |
| else: | |
| st.error("Cannot plot: 'Decade' column missing.") | |
| with tab2: | |
| st.markdown( | |
| "**Top 10 Individual Songs:** This scatter plot highlights the popularity of the top 10 most popular songs over time.") | |
| if 'Year' in df.columns: | |
| top_songs = df.nlargest(10, 'Popularity') | |
| fig2 = px.scatter( | |
| top_songs, x='Year', y='Popularity', | |
| color='Popularity', | |
| size='Popularity', | |
| color_continuous_scale='viridis', | |
| title='Top 10 Individual Songs by Popularity', | |
| hover_data=['Track Name', 'Artist Name(s)', 'Year'] | |
| ) | |
| fig2.update_layout( | |
| xaxis_title='Release Year', | |
| yaxis_title='Popularity Score', | |
| template='plotly_white', | |
| width=900, | |
| height=500 | |
| ) | |
| st.plotly_chart(fig2) | |
| else: | |
| st.error("Cannot plot: 'Year' column missing.") | |
| with tab3: | |
| st.markdown( | |
| "**Top 10 Most Popular Songs:** This bar chart displays the top 10 songs based on their popularity scores.") | |
| if 'Track Name' in df.columns and 'Popularity' in df.columns: | |
| top_songs = df.nlargest(10, 'Popularity')[ | |
| ['Track Name', 'Artist Name(s)', 'Popularity']] | |
| fig3 = px.bar( | |
| top_songs, y='Track Name', x='Popularity', | |
| orientation='h', color='Popularity', | |
| color_continuous_scale='deep', | |
| title='Top 10 Most Popular Songs', | |
| labels={'Track Name': 'Song Title', | |
| 'Popularity': 'Popularity Score'}, | |
| hover_data=['Track Name', 'Artist Name(s)'] | |
| ) | |
| fig3.update_layout( | |
| xaxis_title='Popularity Score', | |
| yaxis_title='Song Title', | |
| template='plotly_white', | |
| width=900, | |
| height=500 | |
| ) | |
| st.plotly_chart(fig3) | |
| else: | |
| st.error("Cannot plot: 'Track Name' or 'Popularity' column missing.") | |
| def generate_audio_features(df): | |
| st.header("Audio Features Analysis") | |
| feature = st.selectbox( | |
| "Select Feature", ['Danceability', 'Energy', 'Tempo', 'Loudness'] | |
| ) | |
| tab1, tab2 = st.tabs(["Distribution", "By Decade"]) | |
| with tab1: | |
| st.markdown( | |
| f"**Top 20 {feature} Values:** This bar chart displays the distribution of the top 20 songs based on {feature}.") | |
| top_features = df.nlargest(20, feature) | |
| fig = px.bar( | |
| top_features, x='Track Name', y=feature, | |
| color='Decade' if 'Decade' in df.columns else None, | |
| title=f'Top 20 Songs by {feature}', | |
| color_discrete_sequence=px.colors.qualitative.Set2, | |
| hover_data=['Track Name', 'Artist Name(s)'] | |
| ) | |
| fig.update_layout(xaxis_tickangle=-45, template='plotly_white') | |
| st.plotly_chart(fig) | |
| with tab2: | |
| st.markdown( | |
| f"**{feature} by Decade:** This line chart compares the top {feature} trends over different decades.") | |
| if 'Decade' in df.columns: | |
| avg_feature_by_decade = df.groupby( | |
| 'Decade')[feature].mean().reset_index() | |
| fig2 = px.line( | |
| avg_feature_by_decade, x='Decade', y=feature, | |
| title=f'Average {feature} by Decade', | |
| markers=True, | |
| color_discrete_sequence=['red'], | |
| hover_data=['Decade'] | |
| ) | |
| fig2.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig2) | |
| else: | |
| st.error("Cannot plot: 'Decade' column missing.") | |
| def generate_genre_analysis(df): | |
| st.header("Genre & Artist Analysis") | |
| tab1, tab2, tab3 = st.tabs( | |
| ["Top Genres", "Genre Distribution", "Artist Popularity"]) | |
| with tab1: | |
| st.markdown( | |
| "**Top Genres in Top 10 Songs:** Displays the most common genres among the top 10 most popular songs.") | |
| top_songs = df.nlargest(10, 'Popularity') | |
| top_genres = top_songs.explode( | |
| 'Genres')['Genres'].value_counts().reset_index() | |
| fig1 = px.bar( | |
| top_genres, x='count', y='Genres', | |
| orientation='h', color='count', | |
| color_continuous_scale='viridis', | |
| title='Top Genres in Top 10 Songs', | |
| labels={'count': 'Number of Songs', 'Genres': 'Genre Name'}, | |
| hover_data=['Genres', 'count'] | |
| ) | |
| fig1.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig1) | |
| with tab2: | |
| st.markdown( | |
| "**Genre Distribution in Top 10 Songs:** Shows how different genres contribute to the top 10 songs.") | |
| genre_song_data = top_songs.explode('Genres') | |
| fig2 = px.bar( | |
| genre_song_data, x='Track Name', y='Popularity', color='Genres', | |
| title='Genre Distribution in Top 10 Songs', | |
| labels={'Track Name': 'Song Title', | |
| 'Popularity': 'Popularity Score', 'Genres': 'Genre'}, | |
| barmode='stack', | |
| hover_data=['Track Name', 'Genres'] | |
| ) | |
| fig2.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig2) | |
| with tab3: | |
| st.markdown( | |
| "**Artist Popularity in Top 10 Songs:** Visualizes the most popular artists in the top 10 songs with their song count and names.") | |
| artist_popularity = top_songs.groupby('Artist Name(s)').agg( | |
| {'Popularity': 'sum', 'Track Name': lambda x: list(x)}).reset_index().sort_values(by='Popularity', ascending=False) | |
| artist_popularity['Song Count'] = artist_popularity['Track Name'].apply( | |
| len) | |
| fig3 = px.bar( | |
| artist_popularity, x='Popularity', y='Artist Name(s)', | |
| orientation='h', color='Popularity', | |
| color_continuous_scale='blues', | |
| title='Artist Popularity in Top 10 Songs', | |
| labels={'Artist Name(s)': 'Artist Name', | |
| 'Popularity': 'Total Popularity Score', 'Song Count': 'Number of Songs'}, | |
| hover_data={'Artist Name(s)': True, 'Popularity': True, | |
| 'Song Count': True, 'Track Name': True} | |
| ) | |
| fig3.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig3) | |
| def generate_explicit_trends(df): | |
| st.header("Explicit Content Trends") | |
| st.markdown("**Explicit vs Non-Explicit Songs Over Time:** This line chart shows how the number of explicit and non-explicit songs has changed over different decades.") | |
| if 'Decade' in df.columns and 'Explicit' in df.columns: | |
| explicit_trends = df.groupby( | |
| ['Decade', 'Explicit']).size().reset_index(name='Count') | |
| fig = px.line( | |
| explicit_trends, x='Decade', y='Count', color='Explicit', | |
| markers=True, line_shape='linear', | |
| title='Explicit vs Non-Explicit Songs Over Time', | |
| labels={'Decade': 'Decade', 'Count': 'Number of Songs', | |
| 'Explicit': 'Song Type'}, | |
| color_discrete_map={True: 'purple', False: 'green'} | |
| ) | |
| fig.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig) | |
| else: | |
| st.error("Cannot plot: 'Decade' or 'Explicit' column missing.") | |
| def generate_album_insights(df): | |
| st.header("Album & Label Insights") | |
| tab1, tab2 = st.tabs(["Top Labels", "Album Popularity"]) | |
| with tab1: | |
| st.markdown( | |
| "**Top Record Labels:** Displays the most dominant record labels based on the number of songs they have released.") | |
| if 'Label' in df.columns: | |
| top_labels = df['Label'].value_counts().nlargest(10).reset_index() | |
| fig9 = px.sunburst( | |
| top_labels, path=['Label'], values='count', | |
| title='Top Record Labels by Song Count', | |
| color='count', color_continuous_scale='blues', | |
| labels={'Label': 'Record Label', 'count': 'Number of Songs'} | |
| ) | |
| fig9.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig9) | |
| else: | |
| st.error("Cannot plot: 'Label' column missing.") | |
| with tab2: | |
| st.markdown( | |
| "**Album Popularity:** Compares the popularity of albums based on the number of songs and their average popularity score.") | |
| if 'Album Name' in df.columns and 'Popularity' in df.columns: | |
| album_pop = df.groupby('Album Name')['Popularity'].agg( | |
| ['mean', 'count']).reset_index() | |
| album_pop = album_pop.sort_values(by=['mean', 'count'], ascending=[ | |
| False, False]).nlargest(10, 'mean') | |
| fig10 = px.strip( | |
| album_pop, x='mean', y='Album Name', | |
| color='count', | |
| title='Top 10 Albums by Popularity', | |
| labels={'Album Name': 'Album', | |
| 'mean': 'Average Popularity Score', 'count': 'Number of Songs'}, | |
| hover_data={'Album Name': True, 'count': True, 'mean': True}, | |
| color_discrete_sequence=px.colors.qualitative.Pastel | |
| ) | |
| fig10.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig10) | |
| else: | |
| st.error("Cannot plot: 'Album Name' or 'Popularity' column missing.") | |
| def generate_tempo_mood(df): | |
| st.header("Tempo & Mood Analysis") | |
| tab1, tab2 = st.tabs(["Tempo Trends", "Mood Scatter"]) | |
| with tab1: | |
| st.markdown("**Tempo Trends:** Tracks tempo changes.") | |
| if 'Year' in df.columns and 'Tempo' in df.columns: | |
| tempo_by_year = df.groupby('Year')['Tempo'].mean().reset_index() | |
| fig11 = px.line(tempo_by_year, x='Year', y='Tempo', | |
| title='Average Tempo Over Time', color_discrete_sequence=['orange']) | |
| fig11.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig11) | |
| else: | |
| st.error("Cannot plot: 'Year' or 'Tempo' column missing.") | |
| with tab2: | |
| st.markdown( | |
| "**Mood Analysis (Valence & Energy):** Categorizes songs based on mood and energy.") | |
| if 'Valence' in df.columns and 'Energy' in df.columns: | |
| top_songs = df.nlargest(10, 'Popularity') | |
| mood_by_valence = top_songs.groupby( | |
| 'Valence')['Energy'].mean().reset_index() | |
| fig12 = px.bar( | |
| mood_by_valence, x='Valence', y='Energy', | |
| title='Average Energy Levels by Valence (Mood Analysis)', | |
| color='Energy', color_continuous_scale='plasma' | |
| ) | |
| fig12.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig12) | |
| else: | |
| st.error("Cannot plot: 'Valence' or 'Energy' column missing.") | |
| def generate_top_artists_songs(df): | |
| st.header("Top Artists and Songs") | |
| tab1, tab2 = st.tabs(["Top Artists", "Top Songs"]) | |
| with tab1: | |
| st.markdown("**Most Featured Artists:** Shows top artists.") | |
| if 'Artist Name(s)' in df.columns: | |
| top_artists = df['Artist Name(s)'].value_counts().nlargest( | |
| 10).reset_index() | |
| fig13 = px.bar( | |
| top_artists, x='count', y='Artist Name(s)', | |
| orientation='h', | |
| title='Most Featured Artists', | |
| color='count', color_continuous_scale='greens' | |
| ) | |
| fig13.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig13) | |
| else: | |
| st.error("Cannot plot: 'Artist Name(s)' column missing.") | |
| with tab2: | |
| st.markdown("**Top 10 Songs:** Lists top songs.") | |
| if 'Track Name' in df.columns and 'Popularity' in df.columns: | |
| top_songs = df.nlargest(10, 'Popularity')[ | |
| ['Track Name', 'Popularity']] | |
| fig14 = px.pie( | |
| top_songs, values='Popularity', names='Track Name', | |
| title='Top 10 Songs by Popularity', color_discrete_sequence=px.colors.qualitative.Set3 | |
| ) | |
| fig14.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig14) | |
| else: | |
| st.error("Cannot plot: 'Track Name' or 'Popularity' column missing.") | |
| def generate_album_release_trends(df): | |
| st.header("Album Release Trends") | |
| tab1, tab2 = st.tabs(["Albums per Year", "Artist-Year Heatmap"]) | |
| with tab1: | |
| st.markdown("**Albums per Year:** Tracks release patterns.") | |
| if 'Year' in df.columns: | |
| albums_per_year = df['Year'].value_counts( | |
| ).sort_index().reset_index() | |
| fig15 = px.line(albums_per_year, x='Year', y='count', | |
| title='Number of Albums Released per Year', color_discrete_sequence=['purple']) | |
| fig15.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig15) | |
| else: | |
| st.error("Cannot plot: 'Year' column missing.") | |
| with tab2: | |
| st.markdown("**Songs by Artists and Years:** Visualizes trends.") | |
| if 'Artist Name(s)' in df.columns and 'Year' in df.columns: | |
| # Filter to only show the top 10 most featured artists | |
| top_artists = df['Artist Name(s)'].value_counts().nlargest( | |
| 10).index | |
| filtered_df = df[df['Artist Name(s)'].isin(top_artists)] | |
| # Grouping data | |
| artist_year = filtered_df.groupby( | |
| ['Year', 'Artist Name(s)']).size().reset_index(name='Count') | |
| # Create a grouped bar chart | |
| fig16 = px.bar( | |
| artist_year, x='Year', y='Count', color='Artist Name(s)', | |
| title='Songs Released by Top Artists Over the Years', | |
| labels={'Count': 'Number of Songs', 'Year': 'Year'}, | |
| barmode='group', # Grouped bars for each artist per year | |
| color_discrete_sequence=px.colors.qualitative.Set2 | |
| ) | |
| fig16.update_layout(width=900, height=500) | |
| st.plotly_chart(fig16) | |
| else: | |
| st.error("Cannot plot: 'Artist Name(s)' or 'Year' column missing.") | |
| def generate_duration_analysis(df): | |
| st.header("Track Duration Analysis") | |
| tab1, tab2 = st.tabs(["Distribution", "By Decade"]) | |
| # Filter out tracks longer than 900,000ms (15 minutes) | |
| df = df[df['Track Duration (ms)'] <= 900000] | |
| with tab1: | |
| st.markdown( | |
| "**Track Duration Distribution:** Illustrates how track durations vary, helping identify common song lengths.") | |
| if 'Track Duration (ms)' in df.columns: | |
| fig17 = px.histogram( | |
| df, x='Track Duration (ms)', | |
| title='Track Duration Distribution (Filtered)', | |
| nbins=50, | |
| color_discrete_sequence=['orange'] | |
| ) | |
| fig17.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig17) | |
| else: | |
| st.error("Cannot plot: 'Track Duration (ms)' column missing.") | |
| with tab2: | |
| st.markdown( | |
| "**Duration by Decade:** Compares the evolution of average track durations across decades, showing historical trends.") | |
| if 'Decade' in df.columns and 'Track Duration (ms)' in df.columns: | |
| fig18 = px.pie( | |
| df.groupby('Decade')[ | |
| 'Track Duration (ms)'].mean().reset_index(), | |
| names='Decade', values='Track Duration (ms)', | |
| title='Average Track Duration by Decade', | |
| color_discrete_sequence=px.colors.qualitative.Set2 | |
| ) | |
| fig18.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig18) | |
| else: | |
| st.error( | |
| "Cannot plot: 'Decade' or 'Track Duration (ms)' column missing.") | |
| def generate_streaming_insights(df): | |
| st.header("Streaming and Engagement Insights") | |
| tab1, tab2 = st.tabs(["Popularity vs Duration", "Time Signature"]) | |
| with tab1: | |
| st.markdown( | |
| "**Popularity vs Track Duration:** This line chart shows the trend of song popularity based on their duration.") | |
| if 'Track Duration (ms)' in df.columns and 'Popularity' in df.columns: | |
| df['Duration (minutes)'] = df['Track Duration (ms)'] / 60000 | |
| duration_bins = pd.cut(df['Duration (minutes)'], bins=[ | |
| 0, 2, 4, 6, 8, 10, 15], labels=['0-2', '2-4', '4-6', '6-8', '8-10', '10+']) | |
| avg_popularity = df.groupby(duration_bins)[ | |
| 'Popularity'].mean().reset_index() | |
| fig1 = px.line( | |
| avg_popularity, | |
| x='Duration (minutes)', | |
| y='Popularity', | |
| title='Popularity vs. Track Duration', | |
| markers=True, # Adds points to the line | |
| line_shape='spline', # Smoothens the line | |
| color_discrete_sequence=['blue'] | |
| ) | |
| fig1.update_layout( | |
| template='plotly_white', xaxis_title='Track Duration (Minutes)', yaxis_title='Average Popularity') | |
| st.plotly_chart(fig1) | |
| else: | |
| st.error( | |
| "Cannot plot: 'Track Duration (ms)' or 'Popularity' column missing.") | |
| with tab2: | |
| st.markdown( | |
| "**Popularity by Time Signature:** This bar chart compares the average popularity of songs based on their time signatures.") | |
| if 'Time Signature' in df.columns and 'Popularity' in df.columns: | |
| pop_by_time = df.groupby('Time Signature')[ | |
| 'Popularity'].mean().reset_index() | |
| fig2 = px.bar( | |
| pop_by_time, | |
| x='Time Signature', | |
| y='Popularity', | |
| title='Average Popularity by Time Signature', | |
| color='Popularity', | |
| color_continuous_scale='purples' | |
| ) | |
| fig2.update_layout( | |
| template='plotly_white', xaxis_title='Time Signature', yaxis_title='Average Popularity') | |
| st.plotly_chart(fig2) | |
| else: | |
| st.error( | |
| "Cannot plot: 'Time Signature' or 'Popularity' column missing.") | |
| def generate_feature_comparisons(df): | |
| st.header("Feature Comparisons Across Decades") | |
| tab1, tab2 = st.tabs(["Feature Comparison", "Loudness Trends"]) | |
| with tab1: | |
| st.markdown("**Feature Comparison:** Compares features across decades.") | |
| if 'Decade' in df.columns: | |
| features_by_decade = df.groupby( | |
| 'Decade')[['Danceability', 'Energy', 'Valence']].mean().reset_index() | |
| fig21 = px.bar(features_by_decade.melt(id_vars='Decade'), x='Decade', y='value', color='variable', | |
| barmode='group', title='Feature Comparison by Decade', color_discrete_sequence=px.colors.qualitative.Pastel) | |
| fig21.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig21) | |
| else: | |
| st.error("Cannot plot: 'Decade' column missing.") | |
| with tab2: | |
| st.markdown("**Loudness Over Time:** Tracks loudness trends.") | |
| if 'Year' in df.columns and 'Loudness' in df.columns: | |
| loudness_by_year = df.groupby( | |
| 'Year')['Loudness'].mean().reset_index() | |
| fig22 = px.line(loudness_by_year, x='Year', y='Loudness', | |
| title='Average Loudness Over Time', color_discrete_sequence=['green']) | |
| fig22.update_layout(template='plotly_white', width=800, height=400) | |
| st.plotly_chart(fig22) | |
| else: | |
| st.error("Cannot plot: 'Year' or 'Loudness' column missing.") | |
| def generate_top_artists_songs(df): | |
| st.header("Top Artists and Songs") | |
| tab1, tab2 = st.tabs(["Top Artists", "Top Songs"]) | |
| with tab1: | |
| st.markdown( | |
| "**Most Featured Artists:** Displays the top 10 artists with the highest song counts, highlighting their dominance in the dataset.") | |
| if 'Artist Name(s)' in df.columns: | |
| top_artists = df['Artist Name(s)'].value_counts().nlargest( | |
| 10).reset_index() | |
| top_artists.columns = ['Artist Name(s)', 'Count'] | |
| fig13 = px.sunburst( | |
| top_artists, path=['Artist Name(s)'], values='Count', | |
| title='Most Featured Artists', | |
| color='Count', | |
| color_continuous_scale='greens' | |
| ) | |
| fig13.update_layout(template='plotly_white', width=900, height=500) | |
| st.plotly_chart(fig13) | |
| else: | |
| st.error("Cannot plot: 'Artist Name(s)' column missing.") | |
| with tab2: | |
| st.markdown( | |
| "**Songs by Artists and Years:** Analyzes song release trends across different years, focusing on the top artists.") | |
| if 'Artist Name(s)' in df.columns and 'Year' in df.columns: | |
| artist_year = df.groupby( | |
| ['Artist Name(s)', 'Year']).size().reset_index(name='Count') | |
| fig16 = px.sunburst( | |
| artist_year, path=['Year', 'Artist Name(s)'], values='Count', | |
| title='Songs Released by Artists Over the Years', | |
| color='Count', | |
| color_continuous_scale=px.colors.qualitative.Set2 | |
| ) | |
| fig16.update_layout(width=900, height=500) | |
| st.plotly_chart(fig16) | |
| else: | |
| st.error("Cannot plot: 'Artist Name(s)' or 'Year' column missing.") | |
| def generate_network_analysis(df): | |
| st.header("Network Analysis") | |
| tab1, tab2 = st.tabs(["Artist Collaborations", "Genre Crossover"]) | |
| # Ensure column names are stripped of spaces | |
| df.columns = df.columns.str.strip() | |
| with tab1: | |
| st.markdown( | |
| "**Top Collaborating Artists:** This chart highlights artists who frequently collaborate with each other.") | |
| if 'Artist Name(s)' in df.columns: | |
| df['Artist Name(s)'] = df['Artist Name(s)'].astype( | |
| str).str.split(', ') | |
| collaborations = [] | |
| for artists in df['Artist Name(s)']: | |
| collaborations.extend(combinations(sorted(artists), 2)) | |
| collab_counts = Counter(collaborations) | |
| top_collabs = sorted(collab_counts.items(), | |
| key=lambda x: x[1], reverse=True)[:20] | |
| G = nx.Graph() | |
| for (artist1, artist2), weight in top_collabs: | |
| G.add_edge(artist1, artist2, weight=weight) | |
| pos = nx.spring_layout(G, seed=42) | |
| plt.figure(figsize=(12, 8)) | |
| edges = nx.draw_networkx_edges(G, pos, alpha=0.5, width=[ | |
| G[u][v]['weight'] for u, v in G.edges()]) | |
| nodes = nx.draw_networkx_nodes( | |
| G, pos, node_size=700, node_color='orange') | |
| labels = nx.draw_networkx_labels( | |
| G, pos, font_size=10, font_weight='bold') | |
| plt.title("Top 20 Artist Collaborations") | |
| st.pyplot(plt) | |
| else: | |
| st.error( | |
| "Cannot plot: 'Artist Name(s)' column missing. Available columns: " + ", ".join(df.columns)) | |
| with tab2: | |
| st.markdown( | |
| "**Genre Crossover:** This chart shows how different music genres are connected and often blend together.") | |
| if 'Genres' in df.columns: | |
| df['Genres'] = df['Genres'].astype(str).str.split(', ') | |
| genre_pairs = [] | |
| for genres in df['Genres']: | |
| genre_pairs.extend(combinations(sorted(set(genres)), 2)) | |
| genre_counts = Counter(genre_pairs) | |
| top_genre_pairs = sorted( | |
| genre_counts.items(), key=lambda x: x[1], reverse=True)[:20] | |
| labels = list(set(chain.from_iterable( | |
| [pair[0] for pair in top_genre_pairs]))) | |
| matrix = [[0] * len(labels) for _ in range(len(labels))] | |
| label_index = {label: i for i, label in enumerate(labels)} | |
| for (genre1, genre2), count in top_genre_pairs: | |
| i, j = label_index[genre1], label_index[genre2] | |
| matrix[i][j] = count | |
| matrix[j][i] = count | |
| fig = go.Figure(data=[go.Heatmap( | |
| z=matrix, x=labels, y=labels, colorscale='OrRd', text=matrix, hoverinfo='text')]) | |
| fig.update_layout(title="Genre Crossover Chord Diagram", | |
| xaxis_title="Genres", yaxis_title="Genres") | |
| st.plotly_chart(fig) | |
| else: | |
| st.error( | |
| "Cannot plot: 'Genres' column missing. Available columns: " + ", ".join(df.columns)) | |