Changes DV - network analysis

functions/visualizations.py

@@ -5,6 +5,7 @@ import seaborn as sns
 import matplotlib.pyplot as plt
 import networkx as nx
 import plotly.graph_objects as go
+from itertools import combinations
 
 def generate_popularity_trends(df):
     st.header("Popularity Trends Over Time")
@@ -250,25 +251,36 @@ def generate_tempo_mood(df):
 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='Artist Name(s)', y='count', title='Most Featured Artists', color_discrete_sequence=['green'])
-            fig13.update_layout(template='plotly_white', width=800, height=400)
+            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.bar(top_songs, y='Track Name', x='Popularity', orientation='h', title='Top 10 Songs by Popularity', color_discrete_sequence=['blue'])
-            fig14.update_layout(template='plotly_white', width=800, height=400)
+            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"])
@@ -284,54 +296,96 @@ def generate_album_release_trends(df):
     with tab2:
         st.markdown("**Songs by Artists and Years:** Visualizes trends.")
         if 'Artist Name(s)' in df.columns and 'Year' in df.columns:
-            artist_year = df.groupby(['Artist Name(s)', 'Year']).size().unstack().fillna(0)
-            fig16 = px.imshow(artist_year, title='Songs Released by Artists Across Years', color_continuous_scale='Viridis')
-            fig16.update_layout(width=800, height=400)
+            # 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:** Shows duration lengths.")
+        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='Distribution of Track Durations', color_discrete_sequence=['orange'])
+            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 durations.")
+        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.box(df, x='Decade', y='Track Duration (ms)', title='Track Duration by Decade', color_discrete_sequence=['green'])
+            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 Duration:** Explores engagement trends.")
+        st.markdown("**Popularity vs Duration:** Examines how track length influences popularity trends.")
         if 'Track Duration (ms)' in df.columns and 'Popularity' in df.columns:
-            fig19 = px.scatter(df, x='Track Duration (ms)', y='Popularity', title='Popularity vs Track Duration', color_discrete_sequence=['blue'])
-            fig19.update_layout(template='plotly_white', width=800, height=400)
+            df['Duration (minutes)'] = df['Track Duration (ms)'] / 60000
+            fig19 = px.box(
+                df, x=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+']),
+                y='Popularity',
+                title='Popularity Distribution Across Track Durations',
+                color_discrete_sequence=['blue']
+            )
+            fig19.update_layout(template='plotly_white', width=800, height=400, xaxis_title='Track Duration (Minutes)')
             st.plotly_chart(fig19)
         else:
             st.error("Cannot plot: 'Track Duration (ms)' or 'Popularity' column missing.")
+    
     with tab2:
-        st.markdown("**Popularity by Time Signature:** Compares popularity.")
+        st.markdown("**Popularity by Time Signature:** Analyzes the average popularity of songs across different time signatures.")
         if 'Time Signature' in df.columns and 'Popularity' in df.columns:
             pop_by_time = df.groupby('Time Signature')['Popularity'].mean().reset_index()
-            fig20 = px.bar(pop_by_time, x='Time Signature', y='Popularity', title='Average Popularity by Time Signature', color_discrete_sequence=['purple'])
+            fig20 = px.bar(
+                pop_by_time, x='Time Signature', y='Popularity',
+                title='Average Popularity by Time Signature',
+                color='Popularity',
+                color_continuous_scale='purples'
+            )
             fig20.update_layout(template='plotly_white', width=800, height=400)
             st.plotly_chart(fig20)
         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"])
@@ -355,65 +409,74 @@ def generate_feature_comparisons(df):
         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"])
+    
     with tab1:
-        st.markdown("**Artist Collaborations:** Visualizes artist connections.")
-        if 'Artist Name(s)' in df.columns:
-            valid_artists = df['Artist Name(s)'].dropna().astype(str)
-            G = nx.Graph()
-            for artists in valid_artists:
-                artists_list = [a.strip() for a in artists.split(',') if a.strip()]
-                if len(artists_list) > 1:
-                    for a1, a2 in combinations(artists_list, 2):
-                        G.add_edge(a1, a2)
-            if G.number_of_nodes() > 0:
-                pos = nx.spring_layout(G)
-                edge_x = []
-                edge_y = []
-                for edge in G.edges():
-                    x0, y0 = pos[edge[0]]
-                    x1, y1 = pos[edge[1]]
-                    edge_x.extend([x0, x1, None])
-                    edge_y.extend([y0, y1, None])
-
-                edge_trace = go.Scatter(
-                    x=edge_x, y=edge_y,
-                    line=dict(width=0.5, color='#888'),
-                    hoverinfo='none',
-                    mode='lines')
-
-                node_x = [pos[node][0] for node in G.nodes()]
-                node_y = [pos[node][1] for node in G.nodes()]
-                node_trace = go.Scatter(
-                    x=node_x, y=node_y,
-                    mode='markers+text',
-                    hoverinfo='text',
-                    marker=dict(size=10, color='red'),
-                    text=list(G.nodes()),
-                    textposition="top center")
-
-                fig = go.Figure(data=[edge_trace, node_trace],
-                                layout=go.Layout(
-                    title='Artist Collaborations',
-                    showlegend=False,
-                    hovermode='closest',
-                    margin=dict(b=0, l=0, r=0, t=40),
-                    width=800, height=600))
-                st.plotly_chart(fig)
-            else:
-                st.warning("No artist collaborations to display.")
+        st.markdown("**Artist Collaborations:** Visualizes artist connections over time.")
+        if 'Artist Name(s)' in df.columns and 'Year' in df.columns:
+            df['Num_Artists'] = df['Artist Name(s)'].apply(lambda x: len(str(x).split(',')))
+            df['Is_Collaboration'] = df['Num_Artists'] > 1
+            collab_trend = df.groupby('Year')['Is_Collaboration'].mean().reset_index()
+            collab_trend['Is_Collaboration'] *= 100  # Convert to percentage
+            
+            fig = px.line(collab_trend, x='Year', y='Is_Collaboration', markers=True,
+                          title="% of Songs in the Top 10 That Are Collaborative",
+                          labels={'Year': 'Year', 'Is_Collaboration': 'Collaborative Songs (%)'})
+            fig.update_traces(marker=dict(size=8, color='blue'))
+            fig.update_layout(width=900, height=500, template='plotly_white')
+            
+            st.plotly_chart(fig)
         else:
-            st.error("Cannot plot: 'Artist Name(s)' column missing.")
+            st.error("Cannot plot: 'Year' or 'Artist Name(s)' column missing.")
+    
     with tab2:
-        st.markdown("**Genre Crossover:** Placeholder for future visualization.")
-        st.write("To implement, install `holoviews` and use the following code:")
-        st.code("""
-        import holoviews as hv
-        hv.extension('bokeh')
-        genre_pairs = df.explode('Genres')[['Genres']].merge(df.explode('Genres')[['Genres']], how='cross')
-        chord_data = genre_pairs.groupby(['Genres_x', 'Genres_y']).size().reset_index(name='value')
-        chord = hv.Chord(chord_data).opts(title="Genre Crossover")
-        st.write(hv.render(chord, backend='bokeh'))
-        """)
+        st.markdown("**Genre Crossover:** Displays the statistical distribution of genres using a violin plot.")
+        if 'Genres' in df.columns:
+            df['Genres'] = df['Genres'].astype(str).str.split(', ')
+            genre_counts = df.explode('Genres')['Genres'].value_counts().reset_index()
+            genre_counts.columns = ['Genre', 'Count']
+            
+            fig = px.violin(genre_counts, y='Genre', x='Count', box=True, points="all",
+                            title='Genre Popularity Distribution',
+                            color_discrete_sequence=['purple'])
+            fig.update_layout(width=900, height=600, template='plotly_white')
+            st.plotly_chart(fig)
+        else:
+            st.error("Cannot plot: 'Genres' column missing.")