update

.idea/workspace.xml

@@ -53,7 +53,7 @@
       <option name="presentableId" value="Default" />
       <updated>1745170754325</updated>
       <workItem from="1745170755404" duration="245000" />
-      <workItem from="1745172030020" duration="2043000" />
+      <workItem from="1745172030020" duration="2752000" />
     </task>
     <servers />
   </component>

app.py

@@ -6,7 +6,7 @@ import nltk
 import os
 import json
 
-# Download necessary NLTK data packages
+# Download necessary NLTK resources function remains unchanged
 def download_nltk_resources():
     """Download required NLTK resources if not already downloaded"""
     try:
@@ -97,38 +97,178 @@ def create_app():
         # Analysis Tab
         with gr.Tab("Analysis"):
             # Use create_analysis_screen to get UI components including visualization container
-            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, visualization_container = create_analysis_screen()
+            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider = create_analysis_screen()
             
-            # Define a helper function to extract parameter values and call process_analysis_request
+            # Pre-create visualization components (initially hidden)
+            with gr.Column(visible=False) as visualization_area:
+                analysis_title = gr.Markdown("## Analysis Results")
+                prompt_title = gr.Markdown()
+                models_compared = gr.Markdown()
+                
+                # Container for model 1 words
+                with gr.Column() as model1_words_container:
+                    model1_title = gr.Markdown()
+                    model1_words = gr.Markdown()
+                
+                # Container for model 2 words
+                with gr.Column() as model2_words_container:
+                    model2_title = gr.Markdown()
+                    model2_words = gr.Markdown()
+                
+                # Similarity metrics
+                similarity_metrics_title = gr.Markdown("### Similarity Metrics")
+                similarity_metrics = gr.Markdown()
+                
+                # Status or error message area
+                status_message = gr.Markdown(visible=False)
+            
+            # Define a helper function to extract parameter values and run the analysis
             def run_analysis(dataset, selected_analyses, bow_top):
                 try:
+                    if not dataset or "entries" not in dataset or not dataset["entries"]:
+                        return (
+                            {},  # analysis_results_state
+                            False,  # analysis_output visibility
+                            False,  # visualization_area visibility
+                            "",  # prompt_title
+                            "",  # models_compared
+                            "",  # model1_title
+                            "",  # model1_words
+                            "",  # model2_title
+                            "",  # model2_words
+                            "",  # similarity_metrics
+                            True,  # status_message visibility
+                            "❌ **Error:** No dataset loaded. Please create or load a dataset first."  # status_message
+                        )
+                    
                     parameters = {
                         "bow_top": bow_top,
                     }
                     print("Running analysis with parameters:", parameters)
                     
                     # Process the analysis request
-                    analysis_results, output_update = process_analysis_request(dataset, selected_analyses, parameters)
+                    analysis_results, _ = process_analysis_request(dataset, selected_analyses, parameters)
+                    
+                    # If there's an error or no results
+                    if not analysis_results or "analyses" not in analysis_results or not analysis_results["analyses"]:
+                        return (
+                            analysis_results,
+                            False,
+                            False,
+                            "", "", "", "", "", "", "",
+                            True,
+                            "❌ **No results found.** Try different analysis options."
+                        )
+                    
+                    # Extract information to display in components
+                    prompt = list(analysis_results["analyses"].keys())[0]
+                    analyses = analysis_results["analyses"][prompt]
+                    
+                    if "bag_of_words" not in analyses:
+                        return (
+                            analysis_results,
+                            False,
+                            False,
+                            "", "", "", "", "", "", "",
+                            True,
+                            "❌ **No Bag of Words analysis found.** Make sure to select it in the options."
+                        )
+                    
+                    bow_results = analyses["bag_of_words"]
+                    models = bow_results.get("models", [])
                     
-                    # Generate visualization components
-                    print("Generating visualization components...")
-                    # Instead of directly returning the components, we'll update the container
-                    visualization_components = process_and_visualize_analysis(analysis_results)
+                    if len(models) < 2:
+                        return (
+                            analysis_results,
+                            False,
+                            False,
+                            "", "", "", "", "", "", "",
+                            True,
+                            "❌ **Not enough models to compare.** Please ensure you have two model responses."
+                        )
                     
-                    # For the third return value, return a simple value that can trigger the update
-                    # The actual components will be placed inside the container
-                    return analysis_results, True, gr.update(value=visualization_components)
+                    # Extract and format information for display
+                    model1_name = models[0]
+                    model2_name = models[1]
+                    
+                    # Format important words for each model
+                    important_words = bow_results.get("important_words", {})
+                    model1_words_text = "No important words found"
+                    model2_words_text = "No important words found"
+                    
+                    if model1_name in important_words:
+                        word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model1_name][:10]]
+                        model1_words_text = ", ".join(word_list)
+                    
+                    if model2_name in important_words:
+                        word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model2_name][:10]]
+                        model2_words_text = ", ".join(word_list)
+                    
+                    # Format similarity metrics
+                    similarity_text = "No similarity metrics found"
+                    comparisons = bow_results.get("comparisons", {})
+                    comparison_key = f"{model1_name} vs {model2_name}"
+                    
+                    if comparison_key in comparisons:
+                        metrics = comparisons[comparison_key]
+                        cosine = metrics.get("cosine_similarity", 0)
+                        jaccard = metrics.get("jaccard_similarity", 0)
+                        common_words = metrics.get("common_word_count", 0)
+                        
+                        similarity_text = f"""
+                        - **Cosine Similarity**: {cosine:.2f} (higher means more similar word frequency patterns)
+                        - **Jaccard Similarity**: {jaccard:.2f} (higher means more word overlap)
+                        - **Common Words**: {common_words} words appear in both responses
+                        """
+                    
+                    # Return all updated component values
+                    return (
+                        analysis_results,  # analysis_results_state
+                        False,  # analysis_output visibility
+                        True,   # visualization_area visibility
+                        f"## Analysis of Prompt: \"{prompt[:100]}...\"",  # prompt_title
+                        f"### Comparing responses from {model1_name} and {model2_name}",  # models_compared
+                        f"#### Top Words Used by {model1_name}",  # model1_title
+                        model1_words_text,  # model1_words
+                        f"#### Top Words Used by {model2_name}",  # model2_title
+                        model2_words_text,  # model2_words
+                        similarity_text,  # similarity_metrics
+                        False,  # status_message visibility
+                        ""  # status_message
+                    )
+                
                 except Exception as e:
                     import traceback
-                    error_msg = f"Error in run_analysis: {str(e)}\n{traceback.format_exc()}"
+                    error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
                     print(error_msg)
-                    return {"error": error_msg}, True, gr.update(value=[gr.Markdown(f"**Error:**\n\n```\n{error_msg}\n```")])
+                    
+                    return (
+                        {"error": error_msg},  # analysis_results_state
+                        True,  # analysis_output visibility (show raw JSON for debugging)
+                        False,  # visualization_area visibility
+                        "", "", "", "", "", "", "",
+                        True,  # status_message visibility
+                        f"❌ **Error during analysis:**\n\n```\n{str(e)}\n```"  # status_message
+                    )
 
             # Run analysis with proper parameters
             run_analysis_btn.click(
                 fn=run_analysis,
                 inputs=[dataset_state, analysis_options, bow_top_slider],
-                outputs=[analysis_results_state, analysis_output, visualization_container]
+                outputs=[
+                    analysis_results_state,
+                    analysis_output,
+                    visualization_area,
+                    prompt_title,
+                    models_compared,
+                    model1_title,
+                    model1_words,
+                    model2_title,
+                    model2_words,
+                    similarity_metrics,
+                    status_message,
+                    status_message
+                ]
             )
     
     return app
@@ -138,4 +278,4 @@ if __name__ == "__main__":
     download_nltk_resources()
     
     app = create_app()
-    app.launch()
+    app.launch()

ui/analysis_screen.py

@@ -102,12 +102,10 @@ def create_analysis_screen():
         
         # Analysis output area - hidden JSON component to store raw results
         analysis_output = gr.JSON(label="Analysis Results", visible=False)
-        
-        # Visualization components container
-        visualization_container = gr.Column(visible=False)
     
     # Return the bow_top_slider directly so app.py can access it
-    return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, visualization_container
+    # Note: Removed the visualization_container from return values since we'll pre-create it
+    return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider
 
 def process_analysis_request(dataset, selected_analyses, parameters):
     """

visualization/bow_visualizer.py

@@ -146,9 +146,6 @@ def create_bow_visualization(analysis_results):
     
     return output_components
 
-import gradio as gr
-import traceback
-
 def process_and_visualize_analysis(analysis_results):
     """
     Process the analysis results and create visualization components
@@ -205,6 +202,31 @@ def process_and_visualize_analysis(analysis_results):
                             f"- Cosine similarity: {cosine:.2f}\n"
                             f"- Jaccard similarity: {jaccard:.2f}"
                         ))
+                
+                # Add visualizations for word frequency differences
+                if "differential_words" in bow_results and "word_count_matrix" in bow_results and len(bow_results["models"]) >= 2:
+                    diff_words = bow_results["differential_words"]
+                    word_matrix = bow_results["word_count_matrix"]
+                    models = bow_results["models"]
+                    
+                    if diff_words and word_matrix and len(diff_words) > 0:
+                        components.append(gr.Markdown("### Words with Biggest Frequency Differences"))
+                        
+                        # Create dataframe for plotting
+                        model1, model2 = models[0], models[1]
+                        diff_data = []
+                        
+                        for word in diff_words[:10]:  # Limit to top 10 for readability
+                            if word in word_matrix:
+                                counts = word_matrix[word]
+                                model1_count = counts.get(model1, 0)
+                                model2_count = counts.get(model2, 0)
+                                
+                                # Only include if there's a meaningful difference
+                                if abs(model1_count - model2_count) > 0:
+                                    components.append(gr.Markdown(
+                                        f"- **{word}**: {model1}: {model1_count}, {model2}: {model2_count}"
+                                    ))
         
         if not components:
             components.append(gr.Markdown("No visualization components could be created from the analysis results."))
@@ -212,6 +234,7 @@ def process_and_visualize_analysis(analysis_results):
         print(f"Visualization complete: generated {len(components)} components")
         return components
     except Exception as e:
+        import traceback
         error_msg = f"Visualization error: {str(e)}\n{traceback.format_exc()}"
         print(error_msg)
-        return [gr.Markdown(f"**Error during visualization:**\n\n```\n{error_msg}\n```")]
+        return [gr.Markdown(f"**Error during visualization:**\n\n```\n{error_msg}\n```")]