Update app.py

app.py

@@ -274,64 +274,94 @@ def main():
             # Detailed insights
             for foundation, score in moral_scores.items():
                 st.write(f"**{MORAL_FOUNDATIONS[foundation]}**: {score:.2%}")
-        
+                
         with tab2:
             st.subheader("Emotional Trajectory")
             emotional_trajectory = analyzer.analyze_emotional_trajectory(text)
             
-            # Scale values to a -1 to 1 range
-            scaled_trajectory = np.array(emotional_trajectory)
-            scaled_trajectory = np.clip(scaled_trajectory, -1, 1)
+            # Normalize and scale the sentiment values
+            scaled_trajectory = np.array(emotional_trajectory) * 2 - 1  # Scale to [-1, 1]
             
-            # Create segment labels for x-axis
+            # Create segment labels
             num_segments = len(scaled_trajectory)
-            segment_labels = [f"Segment {i+1}" for i in range(num_segments)]
+            segment_labels = [f"{i+1}" for i in range(num_segments)]
             
             trajectory_fig = go.Figure(data=go.Scatter(
                 x=segment_labels,
                 y=scaled_trajectory,
                 mode='lines+markers',
-                name='Emotional Intensity',
                 line=dict(
                     color='#1f77b4',
                     width=3
                 ),
                 marker=dict(
                     size=8,
-                    color='#1f77b4'
+                    color='#1f77b4',
+                    symbol='circle'
                 )
             ))
             
             trajectory_fig.update_layout(
-                title='Speech Emotional Flow',
-                xaxis_title='Speech Progression',
-                yaxis_title='Sentiment',
+                title='Emotional Flow Throughout the Speech',
+                xaxis_title='Speech Segments',
+                yaxis_title='Emotional Tone',
                 yaxis=dict(
                     ticktext=['Very Negative', 'Neutral', 'Very Positive'],
                     tickvals=[-1, 0, 1],
-                    range=[-1, 1]
+                    range=[-1.1, 1.1],
+                    gridcolor='lightgray'
                 ),
                 hovermode='x unified',
-                showlegend=False
+                showlegend=False,
+                plot_bgcolor='white'
             )
             
             st.plotly_chart(trajectory_fig)
-
         
         with tab3:
-            st.subheader("Linguistic Complexity")
+            st.subheader("Linguistic Analysis")
             readability = analyzer.calculate_readability(text)
             
+            # Readability metrics with context
             col1, col2 = st.columns(2)
             with col1:
-                st.metric("Flesch Reading Ease", f"{readability['Flesch Reading Ease']:.2f}")
+                score = readability['Flesch Reading Ease']
+                interpretation = "Complex" if score < 50 else "Standard" if score < 70 else "Easy"
+                st.metric(
+                    label="Reading Ease",
+                    value=f"{score:.1f}/100",
+                    delta=interpretation,
+                    delta_color="normal"
+                )
+            
             with col2:
-                st.metric("Flesch-Kincaid Grade Level", f"{readability['Flesch-Kincaid Grade Level']:.2f}")
+                grade = readability['Flesch-Kincaid Grade Level']
+                st.metric(
+                    label="Education Level",
+                    value=f"Grade {grade:.1f}",
+                    delta="Years of Education",
+                    delta_color="normal"
+                )
             
-            # Key Phrases
-            st.subheader("Key Phrases")
+            # Enhanced key phrases display
+            st.subheader("Key Topics and Themes")
             key_phrases = analyzer.extract_key_phrases(text)
-            st.write(", ".join(key_phrases))
+            
+            # Create columns for better phrase organization
+            cols = st.columns(3)
+            for idx, phrase in enumerate(key_phrases):
+                col_idx = idx % 3
+                cols[col_idx].markdown(
+                    f"""<div style='
+                        background-color: rgba(31, 119, 180, {0.9 - idx*0.05});
+                        color: white;
+                        padding: 8px 15px;
+                        margin: 5px 0;
+                        border-radius: 15px;
+                        text-align: center;
+                        '>{phrase}</div>""",
+                    unsafe_allow_html=True
+                )
         
         with tab4:
             st.subheader("Semantic Network")
@@ -403,71 +433,43 @@ def main():
             st.plotly_chart(network_fig, use_container_width=True)
     
         with tab5:
-            st.subheader("Advanced NLP Analysis")
-            
-            # Named Entities with clear explanations
-            st.write("### Key People, Organizations, and Places")
+            st.subheader("Named Entity Recognition")
             named_entities = analyzer.detect_named_entities(text)
             
-            # Create intuitive mapping of entity types
-            entity_type_mapping = {
-                'PER': 'Person',
-                'ORG': 'Organization',
-                'LOC': 'Location',
-                'GPE': 'Country/City',
-                'MISC': 'Miscellaneous'
-            }
-            
-            # Transform the entities dataframe
+            # Process entities
             entities_df = pd.DataFrame(named_entities)
-            entities_df['entity_type'] = entities_df['entity_group'].map(entity_type_mapping)
-            entities_df['confidence'] = entities_df['score'].apply(lambda x: f"{x*100:.1f}%")
-            
-            # Display enhanced table
-            display_df = entities_df[['word', 'entity_type', 'confidence']].rename(columns={
-                'word': 'Name/Term',
-                'entity_type': 'Type',
-                'confidence': 'Confidence Level'
-            })
-            
-            st.dataframe(
-                display_df,
-                column_config={
-                    "Name/Term": st.column_config.TextColumn(
-                        help="The identified name or term from the text"
-                    ),
-                    "Type": st.column_config.TextColumn(
-                        help="Category of the identified term"
-                    ),
-                    "Confidence Level": st.column_config.TextColumn(
-                        help="How certain the AI is about this identification"
-                    )
-                },
-                hide_index=True
-            )
             
-            # Enhanced Rhetorical Devices section
-            st.write("### Persuasive Language Techniques")
-            rhetorical_devices = analyzer.detect_rhetorical_devices(text)
+            # Map entity types to friendly names
+            type_mapping = {
+                'B-PER': 'Person',
+                'I-PER': 'Person',
+                'B-ORG': 'Organization',
+                'I-ORG': 'Organization',
+                'B-LOC': 'Location',
+                'I-LOC': 'Location',
+                'B-MISC': 'Other',
+                'I-MISC': 'Other'
+            }
             
-            # Create columns for better layout
-            col1, col2 = st.columns(2)
+            # Clean and transform the data
+            display_df = pd.DataFrame({
+                'Term': entities_df['word'],
+                'Category': entities_df['entity'].map(type_mapping),
+                'Confidence': entities_df['score'].apply(lambda x: f"{x*100:.1f}%")
+            })
             
-            # Define friendly names and descriptions
-            device_explanations = {
-                'analogy': 'Comparisons (using "like" or "as")',
-                'repetition': 'Repeated phrases for emphasis',
-                'metaphor': 'Symbolic comparisons',
-                'hyperbole': 'Dramatic exaggerations',
-                'rhetorical_question': 'Questions asked for effect'
-            }
+            # Group similar entities
+            grouped_df = display_df.groupby('Category').agg({
+                'Term': lambda x: ', '.join(set(x)),
+                'Confidence': 'count'
+            }).reset_index()
             
-            for device, count in rhetorical_devices.items():
-                with col1:
-                    st.metric(
-                        label=device_explanations[device],
-                        value=f"{count} times"
-                    )
+            # Display results in an organized way
+            for category in grouped_df['Category'].unique():
+                category_data = grouped_df[grouped_df['Category'] == category]
+                st.write(f"### {category}")
+                st.markdown(f"**Found**: {category_data['Term'].iloc[0]}")
+        
 
 
 if __name__ == "__main__":