Update app.py

app.py

@@ -172,36 +172,56 @@ class SpeechAnalyzer:
                 devices_found[device] = count
         return devices_found
 
-    def create_semantic_network(self, text, top_n=20):
-        """Create semantic network graph"""
-        # Use spaCy for advanced parsing
+    def create_semantic_network(self, text, top_n=20, window_size=10):
+        """Create semantic network graph with weighted edges"""
         doc = nlp(text)
         
         # Create graph
         G = nx.Graph()
         
         # Extract top nouns and their relationships
-        nouns = [token.text for token in doc if token.pos_ == 'NOUN']
+        nouns = [token.text.lower() for token in doc if token.pos_ == 'NOUN']
         noun_freq = nltk.FreqDist(nouns)
-        top_nouns = [noun for noun, _ in noun_freq.most_common(top_n)]
+        top_nouns = [noun for noun, freq in noun_freq.most_common(top_n)]
         
-        # Add nodes and edges
+        # Create co-occurrence matrix
+        cooc_matrix = np.zeros((len(top_nouns), len(top_nouns)))
+        noun_to_idx = {noun: idx for idx, noun in enumerate(top_nouns)}
+        
+        # Calculate co-occurrences within window_size
+        words = [token.text.lower() for token in doc]
+        for i in range(len(words)):
+            window_words = words[max(0, i-window_size):min(len(words), i+window_size)]
+            for noun1 in top_nouns:
+                if noun1 in window_words:
+                    for noun2 in top_nouns:
+                        if noun1 != noun2 and noun2 in window_words:
+                            idx1, idx2 = noun_to_idx[noun1], noun_to_idx[noun2]
+                            cooc_matrix[idx1][idx2] += 1
+                            cooc_matrix[idx2][idx1] += 1
+        
+        # Add nodes and weighted edges
         for noun in top_nouns:
-            G.add_node(noun)
+            G.add_node(noun, size=noun_freq[noun])
         
-        # Connect related nouns and add positions
-        pos = nx.spring_layout(G)
+        # Add edges with weights based on co-occurrence
+        max_weight = np.max(cooc_matrix)
         for i in range(len(top_nouns)):
             for j in range(i+1, len(top_nouns)):
-                if top_nouns[i] in text and top_nouns[j] in text:
-                    G.add_edge(top_nouns[i], top_nouns[j])
+                weight = cooc_matrix[i][j]
+                if weight > 0:
+                    G.add_edge(top_nouns[i], top_nouns[j], 
+                              weight=weight,
+                              width=3 * (weight/max_weight))
+        
+        # Calculate layout with weighted edges
+        pos = nx.spring_layout(G, k=1, iterations=50)
         
-        # Store positions in graph
+        # Store positions and attributes in graph
         for node in G.nodes():
             G.nodes[node]['pos'] = pos[node]
         
         return G
-
 def main():
     st.title("🗣️ Advanced Political Speech Analysis Toolkit")
     
@@ -314,24 +334,35 @@ def main():
             
             # Create the network visualization
             network_fig = go.Figure()
+
+            # Add edges with varying widths
+            for edge in semantic_graph.edges():
+                x0, y0 = semantic_graph.nodes[edge[0]]['pos']
+                x1, y1 = semantic_graph.nodes[edge[1]]['pos']
+                width = semantic_graph.edges[edge]['width']
+                
+                network_fig.add_trace(go.Scatter(
+                    x=[x0, x1, None],
+                    y=[y0, y1, None],
+                    mode='lines',
+                    line=dict(width=width, color='#888'),
+                    hoverinfo='none'
+                ))
             
-            # Add edges
-            network_fig.add_trace(go.Scatter(
-                x=edge_x, y=edge_y,
-                mode='lines',
-                line=dict(width=0.5, color='#888'),
-                hoverinfo='none'
-            ))
-            
-            # Add nodes
-            network_fig.add_trace(go.Scatter(
-                x=node_x, y=node_y,
-                mode='markers+text',
-                marker=dict(size=10),
-                text=node_text,
-                textposition="top center",
-                hoverinfo='text'
-            ))
+            # Add nodes with varying sizes
+            for node in semantic_graph.nodes():
+                x, y = semantic_graph.nodes[node]['pos']
+                size = semantic_graph.nodes[node]['size']
+                
+                network_fig.add_trace(go.Scatter(
+                    x=[x],
+                    y=[y],
+                    mode='markers+text',
+                    marker=dict(size=10 + size/2),
+                    text=[node],
+                    textposition="top center",
+                    hoverinfo='text'
+                ))
             
             network_fig.update_layout(
                 showlegend=False,
@@ -340,9 +371,6 @@ def main():
                 xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
                 yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
             )
-            
-            st.plotly_chart(network_fig)
-
         
         with tab5:
             st.subheader("Advanced NLP Analysis")