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="1408000" />
+      <workItem from="1745172030020" duration="2043000" />
     </task>
     <servers />
   </component>

app.py

@@ -100,32 +100,26 @@ def create_app():
             analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, visualization_container = create_analysis_screen()
             
             # Define a helper function to extract parameter values and call process_analysis_request
-            def run_analysis(dataset, selected_analyses, bow_top_value):
-                # Check if dataset exists
-                if not dataset or "entries" not in dataset or not dataset["entries"]:
-                    error_components = [gr.Markdown("❌ **Error:** No dataset provided. Please create a dataset in the Dataset Input tab first.")]
-                    return {}, gr.update(visible=False), gr.update(visible=True, value=error_components)
-                
-                # Create parameters dictionary with the slider value
-                params = {"bow_top": bow_top_value}
-                
-                # Call the process_analysis_request function with proper parameters
+            def run_analysis(dataset, selected_analyses, bow_top):
                 try:
-                    results, _ = process_analysis_request(dataset, selected_analyses, params)
-                    print(f"Analysis completed successfully")
+                    parameters = {
+                        "bow_top": bow_top,
+                    }
+                    print("Running analysis with parameters:", parameters)
                     
-                    # Process and visualize the results
-                    visualization_components = process_and_visualize_analysis(results)
+                    # Process the analysis request
+                    analysis_results, output_update = process_analysis_request(dataset, selected_analyses, parameters)
                     
-                    return results, gr.update(visible=False, value=results), gr.update(visible=True, value=visualization_components)
-                
+                    # Generate visualization components
+                    print("Generating visualization components...")
+                    visualization_components = process_and_visualize_analysis(analysis_results)
+                    
+                    return analysis_results, True, visualization_components
                 except Exception as e:
                     import traceback
-                    error_trace = traceback.format_exc()
-                    print(f"Error in analysis: {e}")
-                    print(f"Full traceback: {error_trace}")
-                    error_components = [gr.Markdown(f"❌ **Error during analysis:** {str(e)}")]
-                    return {}, gr.update(visible=False), gr.update(visible=True, value=error_components)
+                    error_msg = f"Error in run_analysis: {str(e)}\n{traceback.format_exc()}"
+                    print(error_msg)
+                    return {"error": error_msg}, True, [gr.Markdown(f"**Error:**\n\n```\n{error_msg}\n```")]
 
             # Run analysis with proper parameters
             run_analysis_btn.click(

ui/analysis_screen.py

@@ -121,36 +121,46 @@ def process_analysis_request(dataset, selected_analyses, parameters):
     Returns:
         tuple: (analysis_results, analysis_output_display)
     """
-    print(f"Processing analysis request with: {dataset}, {selected_analyses}, {parameters}")
-    
-    if not dataset or "entries" not in dataset or not dataset["entries"]:
-        return {}, gr.update(visible=True, value=json.dumps({"error": "No dataset provided or dataset is empty"}, indent=2))
-    
-    analysis_results = {"analyses": {}}
-    
-    # Extract prompt and responses
-    prompt = dataset["entries"][0]["prompt"]
-    response_texts = [entry["response"] for entry in dataset["entries"]]
-    model_names = [entry["model"] for entry in dataset["entries"]]
-    
-    analysis_results["analyses"][prompt] = {}
-    
-    # Currently only implement Bag of Words since it's the most complete
-    if "Bag of Words" in selected_analyses:
-        # Set a default value
-        top_words = 25
+    try:
+        print(f"Processing analysis request with: {selected_analyses}")
+        print(f"Parameters: {parameters}")
+        
+        if not dataset or "entries" not in dataset or not dataset["entries"]:
+            return {}, gr.update(visible=True, value=json.dumps({"error": "No dataset provided or dataset is empty"}, indent=2))
+        
+        analysis_results = {"analyses": {}}
+        
+        # Extract prompt and responses
+        prompt = dataset["entries"][0]["prompt"]
+        response_texts = [entry["response"] for entry in dataset["entries"]]
+        model_names = [entry["model"] for entry in dataset["entries"]]
         
-        # Try to get the parameter from the parameters dict
-        if parameters and isinstance(parameters, dict) and "bow_top" in parameters:
-            top_words = parameters["bow_top"]
+        print(f"Analyzing prompt: '{prompt[:50]}...'")
+        print(f"Models: {model_names}")
+        
+        analysis_results["analyses"][prompt] = {}
+        
+        # Currently only implement Bag of Words since it's the most complete
+        if "Bag of Words" in selected_analyses:
+            # Set a default value
+            top_words = 25
+            
+            # Try to get the parameter from the parameters dict
+            if parameters and isinstance(parameters, dict) and "bow_top" in parameters:
+                top_words = parameters["bow_top"]
+                
+            print(f"Running BOW analysis with top_words={top_words}")
             
-        print(f"Running BOW analysis with top_words={top_words}")
+            # Call the BOW comparison function
+            bow_results = compare_bow(response_texts, model_names, top_words)
+            analysis_results["analyses"][prompt]["bag_of_words"] = bow_results
         
-        # Call the BOW comparison function
-        bow_results = compare_bow(response_texts, model_names, top_words)
-        analysis_results["analyses"][prompt]["bag_of_words"] = bow_results
-    
-    print("Analysis complete - results:", analysis_results)
-    
-    # Return results and update the output component
-    return analysis_results, gr.update(visible=False, value=analysis_results)  # Hide the raw JSON
+        print("Analysis complete - results:", analysis_results)
+        
+        # Return results and update the output component
+        return analysis_results, gr.update(visible=False, value=analysis_results)  # Hide the raw JSON
+    except Exception as e:
+        import traceback
+        error_msg = f"Analysis error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return {}, gr.update(visible=True, value=json.dumps({"error": error_msg}, indent=2))

visualization/bow_visualizer.py

@@ -146,35 +146,72 @@ def create_bow_visualization(analysis_results):
     
     return output_components
 
+import gradio as gr
+import traceback
+
 def process_and_visualize_analysis(analysis_results):
     """
-    Process analysis results and create visualizations
+    Process the analysis results and create visualization components
     
     Args:
-        analysis_results (dict): Analysis results
+        analysis_results (dict): The analysis results
         
     Returns:
-        list: List of gradio components with visualizations
+        list: List of gradio components for visualization
     """
-    if not analysis_results:
-        return [gr.Markdown("No analysis results available. Please run an analysis first.")]
-    
-    all_components = []
-    
-    # Display the JSON output in a collapsible section for debugging
-    json_text = json.dumps(analysis_results, indent=2)
-    all_components.append(gr.Markdown("### Raw Analysis Results (Expandable)"))
-    all_components.append(gr.Markdown("<details><summary>Click to view raw JSON results</summary>\n\n```json\n" + json_text + "\n```\n\n</details>"))
-    
-    # Check if bag of words analysis is present in any prompt's results
-    has_bow = False
-    for prompt_results in analysis_results.get("analyses", {}).values():
-        if "bag_of_words" in prompt_results:
-            has_bow = True
-            break
-    
-    # Create visualizations for Bag of Words if present
-    if has_bow:
-        all_components.extend(create_bow_visualization(analysis_results))
-    
-    return all_components
+    try:
+        print(f"Starting visualization of analysis results: {type(analysis_results)}")
+        components = []
+        
+        if not analysis_results or "analyses" not in analysis_results:
+            print("Warning: Empty or invalid analysis results")
+            components.append(gr.Markdown("No analysis results to visualize."))
+            return components
+        
+        # For each prompt in the analysis results
+        for prompt, analyses in analysis_results.get("analyses", {}).items():
+            print(f"Visualizing results for prompt: {prompt[:30]}...")
+            components.append(gr.Markdown(f"## Analysis for Prompt:\n\"{prompt}\""))
+            
+            # Check for Bag of Words analysis
+            if "bag_of_words" in analyses:
+                print("Processing Bag of Words visualization")
+                components.append(gr.Markdown("### Bag of Words Analysis"))
+                bow_results = analyses["bag_of_words"]
+                
+                # Display models compared
+                if "models" in bow_results:
+                    models = bow_results["models"]
+                    components.append(gr.Markdown(f"**Models compared**: {', '.join(models)}"))
+                
+                # Display important words for each model
+                if "important_words" in bow_results:
+                    components.append(gr.Markdown("#### Most Common Words by Model"))
+                    
+                    for model, words in bow_results["important_words"].items():
+                        print(f"Creating word list for model {model}")
+                        word_list = [f"{item['word']} ({item['count']})" for item in words[:10]]
+                        components.append(gr.Markdown(f"**{model}**: {', '.join(word_list)}"))
+                
+                # Display comparison metrics
+                if "comparisons" in bow_results:
+                    components.append(gr.Markdown("#### Similarity Metrics"))
+                    
+                    for comparison, metrics in bow_results["comparisons"].items():
+                        cosine = metrics.get("cosine_similarity", 0)
+                        jaccard = metrics.get("jaccard_similarity", 0)
+                        components.append(gr.Markdown(
+                            f"**{comparison}**:\n"
+                            f"- Cosine similarity: {cosine:.2f}\n"
+                            f"- Jaccard similarity: {jaccard:.2f}"
+                        ))
+        
+        if not components:
+            components.append(gr.Markdown("No visualization components could be created from the analysis results."))
+        
+        print(f"Visualization complete: generated {len(components)} components")
+        return components
+    except Exception as e:
+        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```")]