update

.idea/workspace.xml

@@ -4,7 +4,9 @@
     <option name="autoReloadType" value="SELECTIVE" />
   </component>
   <component name="ChangeListManager">
-    <list default="true" id="8e67814c-7f04-433c-ab7a-2b65a1106d4c" name="Changes" comment="" />
+    <list default="true" id="8e67814c-7f04-433c-ab7a-2b65a1106d4c" name="Changes" comment="">
+      <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+    </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@@ -60,7 +62,7 @@
       <option name="presentableId" value="Default" />
       <updated>1745170754325</updated>
       <workItem from="1745170755404" duration="245000" />
-      <workItem from="1745172030020" duration="22565000" />
+      <workItem from="1745172030020" duration="23339000" />
     </task>
     <servers />
   </component>

analysis_runner.py

@@ -1,158 +0,0 @@
-import logging
-import traceback
-import gradio as gr
-
-# Import the processor functions
-from processors.bow_processor import process_bow_analysis
-from processors.ngram_processor import process_ngram_analysis
-from processors.topic_processor import process_topic_modeling
-from processors.classifier_processor import process_classifier_analysis
-from processors.bias_processor import process_bias_detection
-
-# Import the empty visualization response function
-from visualization_handler import create_empty_visualization_response
-
-# Import process_analysis_request with fallback
-try:
-    from improved_analysis_handler import process_analysis_request
-    logger = logging.getLogger("gradio_app.analysis_runner")
-    logger.info("Using improved analysis handler")
-except ImportError:
-    from ui.analysis_screen import process_analysis_request
-    logger = logging.getLogger("gradio_app.analysis_runner")
-    logger.warning("Improved analysis handler not found, using default")
-
-
-def run_analysis(dataset, selected_analysis, ngram_n, ngram_top, topic_count):
-    """
-    Run the selected analysis on the provided dataset and return visualization components.
-
-    Args:
-        dataset (dict): The dataset to analyze.
-        selected_analysis (str): The type of analysis to run.
-        ngram_n (int): N-gram size for N-gram analysis.
-        ngram_top (int): Number of top N-grams to display.
-        topic_count (int): Number of topics for topic modeling.
-
-    Returns:
-        tuple: Updated visualization components.
-    """
-    try:
-        # Create parameter dictionary for the selected analysis
-        parameters = {
-            "ngram_n": ngram_n,
-            "ngram_top": ngram_top,
-            "topic_count": topic_count
-        }
-
-        logger.info(f"Running analysis with selected type: {selected_analysis}")
-        logger.info(f"Parameters: {parameters}")
-
-        # Validate dataset
-        if not dataset or "entries" not in dataset or not dataset["entries"]:
-            return default_no_dataset()
-
-        # Process the analysis request
-        analysis_results, _ = process_analysis_request(dataset, selected_analysis, parameters)
-
-        # Check for valid results
-        if not analysis_results or "analyses" not in analysis_results or not analysis_results["analyses"]:
-            return default_no_results()
-
-        # Extract information and conduct routing
-        prompt = list(analysis_results["analyses"].keys())[0]  # Get the first prompt
-        analyses = analysis_results["analyses"][prompt]
-
-        # Handle cases where analysis provides a message
-        if "message" in analyses:
-            return default_message_response(analyses["message"])
-
-        # Route to processors for specific analysis types
-        if selected_analysis == "Bag of Words" and "bag_of_words" in analyses:
-            return process_bow_analysis(analysis_results, prompt, analyses)
-
-        elif selected_analysis == "N-gram Analysis" and "ngram_analysis" in analyses:
-            return process_ngram_analysis(analysis_results, prompt, analyses)
-
-        elif selected_analysis == "Topic Modeling" and "topic_modeling" in analyses:
-            return process_topic_modeling(analysis_results, prompt, analyses)
-
-        elif selected_analysis == "Classifier" and "classifier" in analyses:
-            return process_classifier_analysis(analysis_results, prompt, analyses)
-
-        elif selected_analysis == "Bias Detection" and "bias_detection" in analyses:
-            return process_bias_detection(analysis_results, prompt, analyses)
-
-        # Fallback if no visualization is available
-        return default_no_visualization(analysis_results)
-
-    except Exception as e:
-        # Log and return an error response
-        error_message = f"Error during analysis execution: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_message)
-        return default_error_response(error_message, str(e))
-
-
-# ========= Default Responses for Handling Errors and Messages =========
-
-def default_no_dataset():
-    """
-    Returns a default response when no dataset is provided.
-    """
-    components = create_empty_visualization_response()
-    components[2] = False  # Hide visualization
-    components[12] = True  # Show status message
-    components[13] = "❌ **Error:** No dataset provided. Please upload or create a dataset."
-    return tuple(components)
-
-
-def default_no_results():
-    """
-    Returns a default response when no analysis results are found.
-    """
-    components = create_empty_visualization_response()
-    components[2] = False  # Hide visualization
-    components[12] = True  # Show status message
-    components[13] = "❌ **Error:** No results found for the selected analysis."
-    return tuple(components)
-
-
-def default_message_response(message):
-    """
-    Returns a response to display a specific message from the analysis system.
-    """
-    components = create_empty_visualization_response()
-    components[2] = True  # Show visualization area
-    components[12] = False  # No error notification
-    components[13] = f"**Message from analysis:** {message}"
-    return tuple(components)
-
-
-def default_no_visualization(analysis_results):
-    """
-    Returns a response when no visualization is available for the results.
-    """
-    components = create_empty_visualization_response()
-    components[0] = analysis_results  # Pass through current analysis state
-    components[2] = True  # Show visualization area
-    components[12] = False  # No error notification
-    components[13] = "**No visualizations available for this analysis type.**"
-    return tuple(components)
-
-
-def default_error_response(error_message, detailed_message):
-    """
-    Returns a response for errors encountered during the analysis process.
-
-    Args:
-        error_message (str): The main error message to display.
-        detailed_message (str): A detailed message (e.g., stack trace).
-
-    Returns:
-        tuple: Components to present the error.
-    """
-    components = create_empty_visualization_response()
-    components[2] = False  # Hide visualization
-    components[12] = True  # Show status message
-    components[13] = f"❌ **Error:** {detailed_message}"
-    return tuple(components)

app.py

@@ -1,30 +1,58 @@
 import gradio as gr
-import logging
-from data_handler import download_nltk_resources
-from analysis_runner import run_analysis
-from visualization_handler import create_visualization_components
 from ui.dataset_input import create_dataset_input, load_example_dataset
-from ui.analysis_screen import create_analysis_screen
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('gradio_app')
-
-# Import the process_analysis_request function
-# Try to use the improved version if available, otherwise use original
-try:
-    from improved_analysis_handler import process_analysis_request
-
-    logger.info("Using improved analysis handler")
-except ImportError:
-    logger.info("Using original analysis handler")
-    from ui.analysis_screen import process_analysis_request
+from ui.analysis_screen import create_analysis_screen, process_analysis_request
+from visualization.bow_visualizer import process_and_visualize_analysis
+import nltk
+import os
+import json
 
+# Download necessary NLTK resources function remains unchanged
+def download_nltk_resources():
+    """Download required NLTK resources if not already downloaded"""
+    try:
+        # Create nltk_data directory in the user's home directory if it doesn't exist
+        nltk_data_path = os.path.expanduser("~/nltk_data")
+        os.makedirs(nltk_data_path, exist_ok=True)
+        
+        # Add this path to NLTK's data path
+        nltk.data.path.append(nltk_data_path)
+        
+        # Download required resources
+        resources = ['punkt', 'wordnet', 'stopwords', 'punkt_tab']
+        for resource in resources:
+            try:
+                # Different resources can be in different directories in NLTK
+                locations = [
+                    f'tokenizers/{resource}',
+                    f'corpora/{resource}',
+                    f'taggers/{resource}',
+                    f'{resource}'
+                ]
+                
+                found = False
+                for location in locations:
+                    try:
+                        nltk.data.find(location)
+                        print(f"Resource {resource} already downloaded")
+                        found = True
+                        break
+                    except LookupError:
+                        continue
+                
+                if not found:
+                    print(f"Downloading {resource}...")
+                    nltk.download(resource, quiet=True)
+            except Exception as e:
+                print(f"Error with resource {resource}: {e}")
+        
+        print("NLTK resources check completed")
+    except Exception as e:
+        print(f"Error downloading NLTK resources: {e}")
 
 def create_app():
     """
-    Create a streamlined Gradio app for dataset input and analysis.
-
+    Create a streamlined Gradio app for dataset input and Bag of Words analysis. 
+    
     Returns:
         gr.Blocks: The Gradio application
     """
@@ -32,14 +60,14 @@ def create_app():
         # Application state to share data between tabs
         dataset_state = gr.State({})
         analysis_results_state = gr.State({})
-
+        
         # Dataset Input Tab
         with gr.Tab("Dataset Input"):
             dataset_inputs, example_dropdown, load_example_btn, create_btn, prompt, response1, model1, response2, model2 = create_dataset_input()
-
+            
             # Add status indicator to show when dataset is created
             dataset_status = gr.Markdown("*No dataset loaded*")
-
+            
             # Load example dataset
             load_example_btn.click(
                 fn=load_example_dataset,
@@ -51,7 +79,7 @@ def create_app():
             def create_dataset(p, r1, m1, r2, m2):
                 if not p or not r1 or not r2:
                     return {}, "❌ **Error:** Please fill in at least the prompt and both responses"
-
+                
                 dataset = {
                     "entries": [
                         {"prompt": p, "response": r1, "model": m1 or "Model 1"},
@@ -59,48 +87,601 @@ def create_app():
                     ]
                 }
                 return dataset, "✅ **Dataset created successfully!** You can now go to the Analysis tab"
-
+                
             create_btn.click(
                 fn=create_dataset,
                 inputs=[prompt, response1, model1, response2, model2],
                 outputs=[dataset_state, dataset_status]
             )
-
+        
         # Analysis Tab
         with gr.Tab("Analysis"):
-            # Create analysis screen
-            analysis_components = create_analysis_screen()
-            analysis_options = analysis_components[0]
-            analysis_params = analysis_components[1]
-            run_analysis_btn = analysis_components[2]
-            analysis_output = analysis_components[3]
-            ngram_n = analysis_components[4]
-            topic_count = analysis_components[5]
+            # Use create_analysis_screen to get UI components including visualization container
+            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count, bias_methods = create_analysis_screen()
+            
+            # Pre-create visualization components (initially hidden)
+            visualization_area_visible = gr.Checkbox(value=False, visible=False, label="Visualization Visible")
+            analysis_title = gr.Markdown("## Analysis Results", visible=False)
+            prompt_title = gr.Markdown(visible=False)
+            models_compared = gr.Markdown(visible=False)
             
-            # Add the missing ngram_top parameter
-            ngram_top = gr.Slider(minimum=5, maximum=50, value=20, step=5, 
-                                 label="Number of Top N-grams to Display")
+            # Container for model 1 words
+            model1_title = gr.Markdown(visible=False)
+            model1_words = gr.Markdown(visible=False)
+            
+            # Container for model 2 words
+            model2_title = gr.Markdown(visible=False)
+            model2_words = gr.Markdown(visible=False)
+            
+            # Similarity metrics
+            similarity_metrics_title = gr.Markdown("### Similarity Metrics", visible=False)
+            similarity_metrics = gr.Markdown(visible=False)
+            
+            # Status or error message area
+            status_message_visible = gr.Checkbox(value=False, visible=False, label="Status Message Visible")
+            status_message = gr.Markdown(visible=False)
+            
+            # Define a helper function to extract parameter values and run the analysis
+            def run_analysis(dataset, selected_analysis, bow_top, ngram_n, ngram_top, topic_count, bias_methods):
+                try:
+                    if not dataset or "entries" not in dataset or not dataset["entries"]:
+                        return (
+                            {},  # analysis_results_state
+                            False,  # analysis_output visibility
+                            False,  # visualization_area_visible
+                            gr.update(visible=False),  # analysis_title
+                            gr.update(visible=False),  # prompt_title
+                            gr.update(visible=False),  # models_compared
+                            gr.update(visible=False),  # model1_title
+                            gr.update(visible=False),  # model1_words
+                            gr.update(visible=False),  # model2_title
+                            gr.update(visible=False),  # model2_words
+                            gr.update(visible=False),  # similarity_metrics_title
+                            gr.update(visible=False),  # similarity_metrics
+                            True,  # status_message_visible
+                            gr.update(visible=True, value="❌ **Error:** No dataset loaded. Please create or load a dataset first.")  # status_message
+                        )
+                    
+                    parameters = {
+                        "bow_top": bow_top,
+                        "ngram_n": ngram_n,
+                        "ngram_top": ngram_top,
+                        "topic_count": topic_count,
+                        "bias_methods": bias_methods  # Add this parameter
+                    }
+                    print(f"Running analysis with selected type: {selected_analysis}")
+                    print("Parameters:", parameters)
+                    
+                    # Process the analysis request - passing selected_analysis as a string
+                    analysis_results, _ = process_analysis_request(dataset, selected_analysis, 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,
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            True,
+                            gr.update(visible=True, value="❌ **No results found.** Try a different analysis option.")
+                        )
+                    
+                    # Extract information to display in components
+                    prompt = list(analysis_results["analyses"].keys())[0]
+                    analyses = analysis_results["analyses"][prompt]
+                    
+                    # Initialize visualization components visibilities and contents
+                    visualization_area_visible = False
+                    prompt_title_visible = False
+                    prompt_title_value = ""
+                    models_compared_visible = False
+                    models_compared_value = ""
+                    
+                    model1_title_visible = False
+                    model1_title_value = ""
+                    model1_words_visible = False
+                    model1_words_value = ""
+                    
+                    model2_title_visible = False
+                    model2_title_value = ""
+                    model2_words_visible = False
+                    model2_words_value = ""
+                    
+                    similarity_title_visible = False
+                    similarity_metrics_visible = False
+                    similarity_metrics_value = ""
+                    
+                    # Check for messages from placeholder analyses
+                    if "message" in analyses:
+                        return (
+                            analysis_results,
+                            False,
+                            False,
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            True,
+                            gr.update(visible=True, value=f"ℹ️ **{analyses['message']}**")
+                        )
+                    
+                    # Process based on the selected analysis type
+                    if selected_analysis == "Bag of Words" and "bag_of_words" in analyses:
+                        visualization_area_visible = True
+                        bow_results = analyses["bag_of_words"]
+                        models = bow_results.get("models", [])
+                        
+                        if len(models) >= 2:
+                            prompt_title_visible = True
+                            prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                            
+                            models_compared_visible = True
+                            models_compared_value = f"### Comparing responses from {models[0]} and {models[1]}"
+                            
+                            # 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", {})
+                            
+                            if model1_name in important_words:
+                                model1_title_visible = True
+                                model1_title_value = f"#### Top Words Used by {model1_name}"
+                                
+                                word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model1_name][:10]]
+                                model1_words_visible = True
+                                model1_words_value = ", ".join(word_list)
+                            
+                            if model2_name in important_words:
+                                model2_title_visible = True
+                                model2_title_value = f"#### Top Words Used by {model2_name}"
+                                
+                                word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model2_name][:10]]
+                                model2_words_visible = True
+                                model2_words_value = ", ".join(word_list)
+                            
+                            # Format similarity metrics
+                            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)
+                                semantic = metrics.get("semantic_similarity", 0)
+                                common_words = metrics.get("common_word_count", 0)
+                                
+                                similarity_title_visible = True
+                                similarity_metrics_visible = True
+                                similarity_metrics_value = f"""
+                                - **Cosine Similarity**: {cosine:.2f} (higher means more similar word frequency patterns)
+                                - **Jaccard Similarity**: {jaccard:.2f} (higher means more word overlap)
+                                - **Semantic Similarity**: {semantic:.2f} (higher means more similar meaning)
+                                - **Common Words**: {common_words} words appear in both responses
+                                """
+                                
+                    # Check for N-gram analysis
+                    elif selected_analysis == "N-gram Analysis" and "ngram_analysis" in analyses:
+                        visualization_area_visible = True
+                        ngram_results = analyses["ngram_analysis"]
+                        models = ngram_results.get("models", [])
+                        ngram_size = ngram_results.get("ngram_size", 2)
+                        size_name = "Unigrams" if ngram_size == 1 else f"{ngram_size}-grams"
+                        
+                        if len(models) >= 2:
+                            prompt_title_visible = True
+                            prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                            
+                            models_compared_visible = True
+                            models_compared_value = f"### {size_name} Analysis: Comparing responses from {models[0]} and {models[1]}"
+                            
+                            # Extract and format information for display
+                            model1_name = models[0]
+                            model2_name = models[1]
+                            
+                            # Format important n-grams for each model
+                            important_ngrams = ngram_results.get("important_ngrams", {})
+                            
+                            if model1_name in important_ngrams:
+                                model1_title_visible = True
+                                model1_title_value = f"#### Top {size_name} Used by {model1_name}"
+                                
+                                ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in important_ngrams[model1_name][:10]]
+                                model1_words_visible = True
+                                model1_words_value = ", ".join(ngram_list)
+                            
+                            if model2_name in important_ngrams:
+                                model2_title_visible = True
+                                model2_title_value = f"#### Top {size_name} Used by {model2_name}"
+                                
+                                ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in important_ngrams[model2_name][:10]]
+                                model2_words_visible = True
+                                model2_words_value = ", ".join(ngram_list)
+                            
+                            # Format similarity metrics if available
+                            if "comparisons" in ngram_results:
+                                comparison_key = f"{model1_name} vs {model2_name}"
+                                
+                                if comparison_key in ngram_results["comparisons"]:
+                                    metrics = ngram_results["comparisons"][comparison_key]
+                                    common_count = metrics.get("common_ngram_count", 0)
+                                    
+                                    similarity_title_visible = True
+                                    similarity_metrics_visible = True
+                                    similarity_metrics_value = f"""
+                                    - **Common {size_name}**: {common_count} {size_name.lower()} appear in both responses
+                                    """
+                    
+                    # Check for Topic Modeling analysis
+                    elif selected_analysis == "Topic Modeling" and "topic_modeling" in analyses:
+                        visualization_area_visible = True
+                        topic_results = analyses["topic_modeling"]
+                        models = topic_results.get("models", [])
+                        method = topic_results.get("method", "lda").upper()
+                        n_topics = topic_results.get("n_topics", 3)
+                        
+                        if len(models) >= 2:
+                            prompt_title_visible = True
+                            prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                            
+                            models_compared_visible = True
+                            models_compared_value = f"### Topic Modeling Analysis ({method}, {n_topics} topics)"
+                            
+                            # Extract and format topic information
+                            topics = topic_results.get("topics", [])
+                            
+                            if topics:
+                                # Format topic info for display
+                                topic_info = []
+                                for topic in topics[:3]:  # Show first 3 topics
+                                    topic_id = topic.get("id", 0)
+                                    words = topic.get("words", [])[:5]  # Top 5 words per topic
+                                    
+                                    if words:
+                                        topic_info.append(f"**Topic {topic_id+1}**: {', '.join(words)}")
+                                
+                                if topic_info:
+                                    model1_title_visible = True
+                                    model1_title_value = "#### Discovered Topics"
+                                    model1_words_visible = True
+                                    model1_words_value = "\n".join(topic_info)
+                            
+                            # Get topic distributions for models
+                            model_topics = topic_results.get("model_topics", {})
+                            
+                            if model_topics:
+                                model1_name = models[0]
+                                model2_name = models[1]
+                                
+                                # Format topic distribution info
+                                if model1_name in model_topics and model2_name in model_topics:
+                                    model2_title_visible = True
+                                    model2_title_value = "#### Topic Distribution"
+                                    model2_words_visible = True
+                                    
+                                    # Simple distribution display
+                                    dist1 = model_topics[model1_name]
+                                    dist2 = model_topics[model2_name]
+                                    
+                                    model2_words_value = f"""
+                                    **{model1_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist1[:3])])}
+                                    
+                                    **{model2_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist2[:3])])}
+                                    """
+                                    
+                            # Add similarity metrics if available
+                            comparisons = topic_results.get("comparisons", {})
+                            if comparisons:
+                                comparison_key = f"{model1_name} vs {model2_name}"
+                                
+                                if comparison_key in comparisons:
+                                    metrics = comparisons[comparison_key]
+                                    js_div = metrics.get("js_divergence", 0)
+                                    
+                                    similarity_title_visible = True
+                                    similarity_metrics_visible = True
+                                    similarity_metrics_value = f"""
+                                    - **Topic Distribution Divergence**: {js_div:.4f} (lower means more similar topic distributions)
+                                    """
+                    
+                    # Check for Classifier analysis
+                    elif selected_analysis == "Classifier" and "classifier" in analyses:
+                        visualization_area_visible = True
+                        classifier_results = analyses["classifier"]
+                        models = classifier_results.get("models", [])
+                        
+                        if len(models) >= 2:
+                            prompt_title_visible = True
+                            prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                            
+                            models_compared_visible = True
+                            models_compared_value = f"### Classifier Analysis for {models[0]} and {models[1]}"
+                            
+                            # Extract and format classifier information
+                            model1_name = models[0]
+                            model2_name = models[1]
+                            
+                            # Display classifications for each model
+                            classifications = classifier_results.get("classifications", {})
+                            
+                            if classifications:
+                                model1_title_visible = True
+                                model1_title_value = f"#### Classification Results"
+                                model1_words_visible = True
+                                
+                                model1_results = classifications.get(model1_name, {})
+                                model2_results = classifications.get(model2_name, {})
+                                
+                                model1_words_value = f"""
+                                **{model1_name}**:
+                                - Formality: {model1_results.get('formality', 'N/A')}
+                                - Sentiment: {model1_results.get('sentiment', 'N/A')}
+                                - Complexity: {model1_results.get('complexity', 'N/A')}
+                                
+                                **{model2_name}**:
+                                - Formality: {model2_results.get('formality', 'N/A')}
+                                - Sentiment: {model2_results.get('sentiment', 'N/A')}
+                                - Complexity: {model2_results.get('complexity', 'N/A')}
+                                """
+                                
+                                # Show comparison
+                                model2_title_visible = True
+                                model2_title_value = f"#### Classification Comparison"
+                                model2_words_visible = True
+                                
+                                differences = classifier_results.get("differences", {})
+                                model2_words_value = "\n".join([
+                                    f"- **{category}**: {diff}" 
+                                    for category, diff in differences.items()
+                                ])
 
-            # Create visualization components
-            visualization_components = create_visualization_components()
+                    # Check for Bias Detection analysis
+                    elif selected_analysis == "Bias Detection" and "bias_detection" in analyses:
+                        visualization_area_visible = True
+                        bias_results = analyses["bias_detection"]
+                        models = bias_results.get("models", [])
+                        
+                        if len(models) >= 2:
+                            prompt_title_visible = True
+                            prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                            
+                            models_compared_visible = True
+                            models_compared_value = f"### Bias Analysis: Comparing responses from {models[0]} and {models[1]}"
+                            
+                            # Display comparative bias results
+                            model1_name = models[0]
+                            model2_name = models[1]
+                            
+                            if "comparative" in bias_results:
+                                comparative = bias_results["comparative"]
+                                
+                                # Format summary for display
+                                model1_title_visible = True
+                                model1_title_value = "#### Bias Detection Summary"
+                                model1_words_visible = True
+                                
+                                summary_parts = []
+                                
+                                # Add sentiment comparison
+                                if "sentiment" in comparative:
+                                    sent = comparative["sentiment"]
+                                    is_significant = sent.get("significant", False)
+                                    summary_parts.append(
+                                        f"**Sentiment Bias**: {model1_name} shows {sent.get(model1_name, 'N/A')} sentiment, " +
+                                        f"while {model2_name} shows {sent.get(model2_name, 'N/A')} sentiment. " +
+                                        f"({'Significant' if is_significant else 'Minor'} difference)"
+                                    )
+                                
+                                # Add partisan comparison
+                                if "partisan" in comparative:
+                                    part = comparative["partisan"]
+                                    is_significant = part.get("significant", False)
+                                    summary_parts.append(
+                                        f"**Partisan Leaning**: {model1_name} appears {part.get(model1_name, 'N/A')}, " +
+                                        f"while {model2_name} appears {part.get(model2_name, 'N/A')}. " +
+                                        f"({'Significant' if is_significant else 'Minor'} difference)"
+                                    )
+                                
+                                # Add framing comparison
+                                if "framing" in comparative:
+                                    frame = comparative["framing"]
+                                    different_frames = frame.get("different_frames", False)
+                                    m1_frame = frame.get(model1_name, "N/A").replace('_', ' ').title()
+                                    m2_frame = frame.get(model2_name, "N/A").replace('_', ' ').title()
+                                    summary_parts.append(
+                                        f"**Issue Framing**: {model1_name} primarily frames issues in {m1_frame} terms, " +
+                                        f"while {model2_name} uses {m2_frame} framing. " +
+                                        f"({'Different' if different_frames else 'Similar'} approaches)"
+                                    )
+                                
+                                # Add overall assessment
+                                if "overall" in comparative:
+                                    overall = comparative["overall"]
+                                    significant = overall.get("significant_bias_difference", False)
+                                    summary_parts.append(
+                                        f"**Overall Assessment**: " +
+                                        f"Analysis shows a {overall.get('difference', 0):.2f}/1.0 difference in bias patterns. " +
+                                        f"({'Significant' if significant else 'Minor'} overall bias difference)"
+                                    )
+                                
+                                # Combine all parts
+                                model1_words_value = "\n\n".join(summary_parts)
+                                
+                                # Format detailed term analysis
+                                if (model1_name in bias_results and "partisan" in bias_results[model1_name] and
+                                    model2_name in bias_results and "partisan" in bias_results[model2_name]):
+                                    
+                                    model2_title_visible = True
+                                    model2_title_value = "#### Partisan Term Analysis"
+                                    model2_words_visible = True
+                                    
+                                    m1_lib = bias_results[model1_name]["partisan"].get("liberal_terms", [])
+                                    m1_con = bias_results[model1_name]["partisan"].get("conservative_terms", [])
+                                    m2_lib = bias_results[model2_name]["partisan"].get("liberal_terms", [])
+                                    m2_con = bias_results[model2_name]["partisan"].get("conservative_terms", [])
+                                    
+                                    model2_words_value = f"""
+                                    **{model1_name}**:
+                                    - Liberal terms: {', '.join(m1_lib) if m1_lib else 'None detected'}
+                                    - Conservative terms: {', '.join(m1_con) if m1_con else 'None detected'}
+                                    
+                                    **{model2_name}**:
+                                    - Liberal terms: {', '.join(m2_lib) if m2_lib else 'None detected'}
+                                    - Conservative terms: {', '.join(m2_con) if m2_con else 'None detected'}
+                                    """
+                    
+                    # If we don't have visualization data from any analysis
+                    if not visualization_area_visible:
+                        return (
+                            analysis_results,
+                            False,
+                            False,
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            gr.update(visible=False),
+                            True,
+                            gr.update(visible=True, value="❌ **No visualization data found.** Make sure to select a valid analysis option.")
+                        )
 
+                    # Return all updated component values
+                    return (
+                        analysis_results,  # analysis_results_state
+                        False,  # analysis_output visibility
+                        True,   # visualization_area_visible
+                        gr.update(visible=True),  # analysis_title
+                        gr.update(visible=prompt_title_visible, value=prompt_title_value),  # prompt_title
+                        gr.update(visible=models_compared_visible, value=models_compared_value),  # models_compared
+                        gr.update(visible=model1_title_visible, value=model1_title_value),  # model1_title
+                        gr.update(visible=model1_words_visible, value=model1_words_value),  # model1_words
+                        gr.update(visible=model2_title_visible, value=model2_title_value),  # model2_title
+                        gr.update(visible=model2_words_visible, value=model2_words_value),  # model2_words
+                        gr.update(visible=similarity_title_visible),  # similarity_metrics_title
+                        gr.update(visible=similarity_metrics_visible, value=similarity_metrics_value),  # similarity_metrics
+                        False,  # status_message_visible
+                        gr.update(visible=False)  # status_message
+                    )
+                
+                except Exception as e:
+                    import traceback
+                    error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
+                    print(error_msg)
+                    
+                    return (
+                        {"error": error_msg},  # analysis_results_state
+                        True,  # analysis_output visibility (show raw JSON for debugging)
+                        False,  # visualization_area_visible
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False),
+                        True,  # status_message_visible
+                        gr.update(visible=True, value=f"❌ **Error during analysis:**\n\n```\n{str(e)}\n```")  # status_message
+                    )
+                    
+        # Add a new LLM Analysis tab
+        with gr.Tab("LLM Analysis"):
+            gr.Markdown("## LLM-Based Response Analysis")
+            
+            with gr.Row():
+                with gr.Column():
+                    llm_analysis_type = gr.Radio(
+                        choices=["Response Quality", "Response Comparison", "Factual Accuracy"],
+                        label="Analysis Type",
+                        value="Response Comparison"
+                    )
+                    
+                    llm_model = gr.Dropdown(
+                        choices=["OpenAI GPT-4", "Anthropic Claude", "Local LLM"],
+                        label="Analysis Model",
+                        value="OpenAI GPT-4"
+                    )
+                    
+                    run_llm_analysis_btn = gr.Button("Run LLM Analysis", variant="primary")
+                
+                with gr.Column():
+                    llm_analysis_prompt = gr.Textbox(
+                        label="Custom Analysis Instructions (Optional)",
+                        placeholder="Enter any specific instructions for the analysis...",
+                        lines=3
+                    )
+                    
+                    llm_analysis_status = gr.Markdown("*No analysis has been run*")
+            
+            llm_analysis_result = gr.Markdown(visible=False)
+            
+            # Placeholder function for LLM analysis
+            def run_llm_analysis(dataset, analysis_type, model, custom_prompt):
+                if not dataset or "entries" not in dataset or not dataset["entries"]:
+                    return (
+                        gr.update(visible=True, value="❌ **Error:** No dataset loaded. Please create or load a dataset first."),
+                        gr.update(visible=False)
+                    )
+                
+                # Placeholder for actual implementation
+                return (
+                    gr.update(visible=True, value="⏳ **Implementation in progress**\n\nLLM-based analysis will be available in a future update."),
+                    gr.update(visible=False)
+                )
+            
             # Connect the run button to the analysis function
-            run_analysis_btn.click(
-                fn=run_analysis,
-                inputs=[dataset_state, analysis_options, ngram_n, ngram_top, topic_count],
-                outputs=visualization_components
+            run_llm_analysis_btn.click(
+                fn=run_llm_analysis,
+                inputs=[dataset_state, llm_analysis_type, llm_model, llm_analysis_prompt],
+                outputs=[llm_analysis_status, llm_analysis_result]
             )
 
+        # Run analysis with proper parameters
+        run_analysis_btn.click(
+            fn=run_analysis,
+            inputs=[dataset_state, analysis_options, bow_top_slider, ngram_n, ngram_top, topic_count, bias_methods],
+            outputs=[
+                analysis_results_state,
+                analysis_output,
+                visualization_area_visible,
+                analysis_title,
+                prompt_title,
+                models_compared,
+                model1_title,
+                model1_words,
+                model2_title,
+                model2_words,
+                similarity_metrics_title,
+                similarity_metrics,
+                status_message_visible,
+                status_message
+            ]
+        )
+    
     return app
 
-
 if __name__ == "__main__":
     # Download required NLTK resources before launching the app
     download_nltk_resources()
-
-    logger.info("Starting LLM Response Comparator application")
-    logger.info("===== Application Startup =====")
-
-    # Create and launch the application
+    
     app = create_app()
     app.launch()

data_handler.py

@@ -1,67 +0,0 @@
-import os
-import nltk
-import logging
-
-# Set up logging
-logger = logging.getLogger('gradio_app.data_handler')
-
-
-def download_nltk_resources():
-    """
-    Download required NLTK resources if not already downloaded.
-
-    Ensures that all necessary NLTK resources are available for the application.
-    """
-    try:
-        # Define the path for NLTK data
-        nltk_data_path = os.path.expanduser("~/nltk_data")
-        os.makedirs(nltk_data_path, exist_ok=True)
-
-        # Add this path to NLTK's data path
-        if nltk_data_path not in nltk.data.path:
-            nltk.data.path.append(nltk_data_path)
-
-        # List of required NLTK resources
-        resources = ['punkt', 'wordnet', 'stopwords', 'vader_lexicon']
-
-        for resource in resources:
-            try:
-                # Check if the resource is already available
-                if not is_nltk_resource_available(resource):
-                    logger.info(f"Downloading {resource}...")
-                    nltk.download(resource, download_dir=nltk_data_path, quiet=True)
-                else:
-                    logger.info(f"Resource {resource} already downloaded")
-            except Exception as e:
-                logger.error(f"Error downloading resource {resource}: {e}")
-
-        logger.info("NLTK resources check completed successfully")
-    except Exception as e:
-        logger.error(f"Error during NLTK resource setup: {e}")
-
-
-def is_nltk_resource_available(resource):
-    """
-    Check if an NLTK resource is already available.
-
-    Args:
-        resource (str): The name of the NLTK resource to check.
-
-    Returns:
-        bool: True if the resource is available, False otherwise.
-    """
-    locations = [
-        f'tokenizers/{resource}',
-        f'corpora/{resource}',
-        f'taggers/{resource}',
-        f'{resource}'
-    ]
-
-    for location in locations:
-        try:
-            nltk.data.find(location)
-            return True
-        except LookupError:
-            continue
-
-    return False

improved_analysis_handler.py

@@ -1,217 +0,0 @@
-import gradio as gr
-import json
-import logging
-from visualization.bow_visualizer import process_and_visualize_analysis
-from processors.topic_modeling import compare_topics
-from processors.ngram_analysis import compare_ngrams
-from processors.bow_analysis import compare_bow
-from processors.text_classifiers import classify_formality, classify_sentiment, classify_complexity, compare_classifications
-# Add import for bias detection
-from processors.bias_detection import compare_bias
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('analysis_handler')
-
-def process_analysis_request(dataset, selected_analysis, parameters):
-    """
-    Process the analysis request based on the selected options.
-    
-    Args:
-        dataset (dict): The input dataset
-        selected_analysis (str): The selected analysis type
-        parameters (dict): Additional parameters for the analysis
-    
-    Returns:
-        tuple: A tuple containing (analysis_results, visualization_data)
-    """
-    logger.info(f"Processing analysis request: {selected_analysis}")
-    
-    if not dataset or "entries" not in dataset or not dataset["entries"]:
-        logger.warning("No valid dataset provided for analysis")
-        return {}, None
-        
-    # Initialize the results structure
-    results = {"analyses": {}}
-    
-    # Get the prompt text from the first entry
-    prompt_text = dataset["entries"][0].get("prompt", "")
-    if not prompt_text:
-        logger.warning("No prompt found in dataset")
-        return {"error": "No prompt found in dataset"}, None
-        
-    # Initialize the analysis container for this prompt
-    results["analyses"][prompt_text] = {}
-    
-    # Get model names and responses
-    model1_name = dataset["entries"][0].get("model", "Model 1")
-    model2_name = dataset["entries"][1].get("model", "Model 2")
-    
-    model1_response = dataset["entries"][0].get("response", "")
-    model2_response = dataset["entries"][1].get("response", "")
-    
-    logger.info(f"Comparing responses from {model1_name} and {model2_name}")
-    
-    try:
-        # Process based on the selected analysis type
-        if selected_analysis == "Bag of Words":
-            # Get the top_n parameter and ensure it's an integer
-            top_n = parameters.get("bow_top", 25)
-            if isinstance(top_n, str):
-                top_n = int(top_n)
-            
-            logger.info(f"Running Bag of Words analysis with top_n={top_n}")
-            
-            # Perform Bag of Words analysis using the processor
-            bow_results = compare_bow(
-                [model1_response, model2_response],
-                [model1_name, model2_name],
-                top_n=top_n
-            )
-            results["analyses"][prompt_text]["bag_of_words"] = bow_results
-            
-        elif selected_analysis == "N-gram Analysis":
-            # Perform N-gram analysis
-            ngram_size = parameters.get("ngram_n", 2)
-            if isinstance(ngram_size, str):
-                ngram_size = int(ngram_size)
-                
-            top_n = parameters.get("ngram_top", 15)
-            if isinstance(top_n, str):
-                top_n = int(top_n)
-            
-            logger.info(f"Running N-gram analysis with n={ngram_size}, top_n={top_n}")
-            
-            # Use the processor from the dedicated ngram_analysis module
-            from processors.ngram_analysis import compare_ngrams as ngram_processor
-            ngram_results = ngram_processor(
-                [model1_response, model2_response],
-                [model1_name, model2_name],
-                n=ngram_size,
-                top_n=top_n
-            )
-            results["analyses"][prompt_text]["ngram_analysis"] = ngram_results
-            
-        elif selected_analysis == "Topic Modeling":
-            # Perform topic modeling analysis
-            topic_count = parameters.get("topic_count", 3)
-            if isinstance(topic_count, str):
-                topic_count = int(topic_count)
-            
-            logger.info(f"Running Topic Modeling analysis with n_topics={topic_count}")
-            
-            try:
-                # Import the improved topic modeling module
-                try:
-                    # First try to import from improved module if available
-                    from improved_topic_modeling import compare_topics as improved_compare_topics
-                    logger.info("Using improved topic modeling implementation")
-                    topic_results = improved_compare_topics(
-                        texts_set_1=[model1_response], 
-                        texts_set_2=[model2_response], 
-                        n_topics=topic_count,
-                        model_names=[model1_name, model2_name])
-                except ImportError:
-                    # Fall back to original implementation
-                    logger.info("Using original topic modeling implementation")
-                    from processors.topic_modeling import compare_topics
-                    topic_results = compare_topics(
-                        texts_set_1=[model1_response], 
-                        texts_set_2=[model2_response], 
-                        n_topics=topic_count,
-                        model_names=[model1_name, model2_name])
-                
-                results["analyses"][prompt_text]["topic_modeling"] = topic_results
-                
-                # Ensure the topic modeling results contain the necessary fields
-                if "topics" not in topic_results or not topic_results["topics"]:
-                    logger.warning("No topics found in topic modeling results")
-                    topic_results["message"] = "No significant topics were discovered in the text. Try a different analysis method or adjust parameters."
-                
-                if "model_topics" not in topic_results or not topic_results["model_topics"]:
-                    logger.warning("No model topics found in topic modeling results")
-                    if "message" not in topic_results:
-                        topic_results["message"] = "Could not calculate topic distributions for the models."
-                
-            except Exception as e:
-                import traceback
-                error_msg = f"Topic modeling error: {str(e)}\n{traceback.format_exc()}"
-                logger.error(error_msg)
-                results["analyses"][prompt_text]["topic_modeling"] = {
-                    "models": [model1_name, model2_name],
-                    "error": str(e),
-                    "message": "Topic modeling failed. Please try with longer text or different parameters.",
-                    "stack_trace": traceback.format_exc()
-                }
-        
-        elif selected_analysis == "Classifier":
-            # Perform classifier analysis
-            logger.info("Running Classifier analysis")
-            
-            results["analyses"][prompt_text]["classifier"] = {
-                "models": [model1_name, model2_name],
-                "classifications": {
-                    model1_name: {
-                        "formality": classify_formality(model1_response),
-                        "sentiment": classify_sentiment(model1_response),
-                        "complexity": classify_complexity(model1_response)
-                    },
-                    model2_name: {
-                        "formality": classify_formality(model2_response),
-                        "sentiment": classify_sentiment(model2_response),
-                        "complexity": classify_complexity(model2_response)
-                    }
-                },
-                "differences": compare_classifications(model1_response, model2_response)
-            }
-            
-        elif selected_analysis == "Bias Detection":
-            # Perform bias detection analysis
-            logger.info("Running Bias Detection analysis")
-            
-            try:
-                # Perform bias detection analysis
-                logger.info(f"Starting bias detection for {model1_name} and {model2_name}")
-                logger.info(f"Text lengths - Text1: {len(model1_response)}, Text2: {len(model2_response)}")
-                
-                bias_results = compare_bias(
-                    model1_response, 
-                    model2_response,
-                    model_names=[model1_name, model2_name]
-                )
-                
-                logger.info(f"Bias detection complete. Result has keys: {bias_results.keys() if bias_results else 'None'}")
-                results["analyses"][prompt_text]["bias_detection"] = bias_results
-                
-            except Exception as e:
-                import traceback
-                error_msg = f"Bias detection error: {str(e)}\n{traceback.format_exc()}"
-                logger.error(error_msg)
-                results["analyses"][prompt_text]["bias_detection"] = {
-                    "models": [model1_name, model2_name],
-                    "error": str(e),
-                    "message": "Bias detection failed. Try with different parameters.",
-                    "stack_trace": traceback.format_exc()
-                }
-        
-        else:
-            # Unknown analysis type
-            logger.warning(f"Unknown analysis type: {selected_analysis}")
-            results["analyses"][prompt_text]["message"] = "Please select a valid analysis type."
-    
-    except Exception as e:
-        import traceback
-        error_msg = f"Error processing analysis request: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_msg)
-        results = {
-            "error": str(e),
-            "stack_trace": traceback.format_exc(),
-            "analyses": {
-                prompt_text: {
-                    "message": f"Analysis failed: {str(e)}"
-                }
-            }
-        }
-    
-    # Return both the analysis results and a placeholder for visualization data
-    return results, None

processors/bias_detection.py

@@ -8,22 +8,13 @@ import re
 import json
 import os
 import numpy as np
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('bias_detection')
 
 # Ensure NLTK resources are available
 def download_nltk_resources():
     """Download required NLTK resources if not already downloaded"""
     try:
-        logger.info("Downloading NLTK resources for bias detection...")
         nltk.download('vader_lexicon', quiet=True)
-        nltk.download('punkt', quiet=True)
-        nltk.download('stopwords', quiet=True)
-    except Exception as e:
-        logger.error(f"Error downloading NLTK resources: {e}")
+    except:
         pass
         
 download_nltk_resources()
@@ -33,15 +24,11 @@ download_nltk_resources()
 PARTISAN_WORDS = {
     "liberal": [
         "progressive", "equity", "climate", "reform", "collective", 
-        "diversity", "inclusive", "sustainable", "justice", "regulation",
-        "equity", "social", "community", "rights", "environment",
-        "equality", "welfare", "public", "protection", "universal"
+        "diversity", "inclusive", "sustainable", "justice", "regulation"
     ],
     "conservative": [
         "traditional", "freedom", "liberty", "individual", "faith", 
-        "values", "efficient", "deregulation", "patriot", "security",
-        "family", "business", "market", "nation", "protect",
-        "heritage", "responsibility", "constitution", "fiscal", "private"
+        "values", "efficient", "deregulation", "patriot", "security"
     ]
 }
 
@@ -75,37 +62,25 @@ def detect_sentiment_bias(text):
     Returns:
         dict: Sentiment analysis results
     """
-    try:
-        logger.info(f"Starting sentiment analysis on text (length: {len(text)})")
-        sia = SentimentIntensityAnalyzer()
-        sentiment = sia.polarity_scores(text)
-        
-        # Determine if sentiment indicates bias
-        if sentiment['compound'] >= 0.25:
-            bias_direction = "positive"
-            bias_strength = min(1.0, sentiment['compound'] * 2)  # Scale to 0-1
-        elif sentiment['compound'] <= -0.25:
-            bias_direction = "negative"
-            bias_strength = min(1.0, abs(sentiment['compound'] * 2))  # Scale to 0-1
-        else:
-            bias_direction = "neutral"
-            bias_strength = 0.0
-        
-        logger.info(f"Sentiment analysis complete. Direction: {bias_direction}, Strength: {bias_strength:.2f}")
-        return {
-            "sentiment_scores": sentiment,
-            "bias_direction": bias_direction,
-            "bias_strength": bias_strength
-        }
-    except Exception as e:
-        logger.error(f"Error in sentiment analysis: {str(e)}")
-        # Return a default neutral sentiment to prevent failures
-        return {
-            "sentiment_scores": {"pos": 0, "neg": 0, "neu": 1, "compound": 0},
-            "bias_direction": "neutral",
-            "bias_strength": 0.0,
-            "error": str(e)
-        }
+    sia = SentimentIntensityAnalyzer()
+    sentiment = sia.polarity_scores(text)
+    
+    # Determine if sentiment indicates bias
+    if sentiment['compound'] >= 0.25:
+        bias_direction = "positive"
+        bias_strength = min(1.0, sentiment['compound'] * 2)  # Scale to 0-1
+    elif sentiment['compound'] <= -0.25:
+        bias_direction = "negative"
+        bias_strength = min(1.0, abs(sentiment['compound'] * 2))  # Scale to 0-1
+    else:
+        bias_direction = "neutral"
+        bias_strength = 0.0
+    
+    return {
+        "sentiment_scores": sentiment,
+        "bias_direction": bias_direction,
+        "bias_strength": bias_strength
+    }
 
 def detect_partisan_leaning(text):
     """
@@ -117,73 +92,55 @@ def detect_partisan_leaning(text):
     Returns:
         dict: Partisan leaning analysis results
     """
-    try:
-        logger.info(f"Starting partisan leaning analysis on text (length: {len(text)})")
-        text_lower = text.lower()
-        
-        # Count partisan words
-        liberal_count = 0
-        conservative_count = 0
-        
-        liberal_matches = []
-        conservative_matches = []
-        
-        # Search for partisan words in text
-        for word in PARTISAN_WORDS["liberal"]:
-            matches = re.findall(r'\b' + word + r'\b', text_lower)
-            if matches:
-                liberal_count += len(matches)
-                liberal_matches.extend(matches)
-                
-        for word in PARTISAN_WORDS["conservative"]:
-            matches = re.findall(r'\b' + word + r'\b', text_lower)
-            if matches:
-                conservative_count += len(matches)
-                conservative_matches.extend(matches)
-        
-        logger.info(f"Found {liberal_count} liberal terms and {conservative_count} conservative terms")
-        
-        # Calculate partisan lean score (-1 to 1, negative = liberal, positive = conservative)
-        total_count = liberal_count + conservative_count
-        if total_count > 0:
-            lean_score = (conservative_count - liberal_count) / total_count
-        else:
-            lean_score = 0
-        
-        # Determine leaning based on score
-        if lean_score <= -0.2:
-            leaning = "liberal"
-            strength = min(1.0, abs(lean_score * 2))
-        elif lean_score >= 0.2:
-            leaning = "conservative"
-            strength = min(1.0, lean_score * 2)
-        else:
-            leaning = "balanced"
-            strength = 0.0
-        
-        logger.info(f"Partisan analysis complete. Leaning: {leaning}, Score: {lean_score:.2f}")
-        return {
-            "liberal_count": liberal_count,
-            "conservative_count": conservative_count,
-            "liberal_terms": liberal_matches,
-            "conservative_terms": conservative_matches,
-            "lean_score": lean_score,
-            "leaning": leaning,
-            "strength": strength
-        }
-    except Exception as e:
-        logger.error(f"Error in partisan leaning analysis: {str(e)}")
-        # Return default balanced values to prevent failures
-        return {
-            "liberal_count": 0,
-            "conservative_count": 0,
-            "liberal_terms": [],
-            "conservative_terms": [],
-            "lean_score": 0,
-            "leaning": "balanced",
-            "strength": 0.0,
-            "error": str(e)
-        }
+    text_lower = text.lower()
+    
+    # Count partisan words
+    liberal_count = 0
+    conservative_count = 0
+    
+    liberal_matches = []
+    conservative_matches = []
+    
+    # Search for partisan words in text
+    for word in PARTISAN_WORDS["liberal"]:
+        matches = re.findall(r'\b' + word + r'\b', text_lower)
+        if matches:
+            liberal_count += len(matches)
+            liberal_matches.extend(matches)
+            
+    for word in PARTISAN_WORDS["conservative"]:
+        matches = re.findall(r'\b' + word + r'\b', text_lower)
+        if matches:
+            conservative_count += len(matches)
+            conservative_matches.extend(matches)
+    
+    # Calculate partisan lean score (-1 to 1, negative = liberal, positive = conservative)
+    total_count = liberal_count + conservative_count
+    if total_count > 0:
+        lean_score = (conservative_count - liberal_count) / total_count
+    else:
+        lean_score = 0
+    
+    # Determine leaning based on score
+    if lean_score <= -0.2:
+        leaning = "liberal"
+        strength = min(1.0, abs(lean_score * 2))
+    elif lean_score >= 0.2:
+        leaning = "conservative"
+        strength = min(1.0, lean_score * 2)
+    else:
+        leaning = "balanced"
+        strength = 0.0
+    
+    return {
+        "liberal_count": liberal_count,
+        "conservative_count": conservative_count,
+        "liberal_terms": liberal_matches,
+        "conservative_terms": conservative_matches,
+        "lean_score": lean_score,
+        "leaning": leaning,
+        "strength": strength
+    }
 
 def detect_framing_bias(text):
     """
@@ -195,61 +152,45 @@ def detect_framing_bias(text):
     Returns:
         dict: Framing analysis results
     """
-    try:
-        logger.info(f"Starting framing analysis on text (length: {len(text)})")
-        text_lower = text.lower()
-        framing_counts = {}
-        framing_examples = {}
-        
-        # Count framing patterns
-        for frame, patterns in FRAMING_PATTERNS.items():
-            framing_counts[frame] = 0
-            framing_examples[frame] = []
-            
-            for pattern in patterns:
-                matches = re.findall(pattern, text_lower)
-                if matches:
-                    framing_counts[frame] += len(matches)
-                    # Store up to 5 examples of each frame
-                    unique_matches = set(matches)
-                    framing_examples[frame].extend(list(unique_matches)[:5])
-        
-        logger.info(f"Frame counts: {framing_counts}")
-        
-        # Calculate dominant frame
-        total_framing = sum(framing_counts.values())
-        framing_distribution = {}
+    text_lower = text.lower()
+    framing_counts = {}
+    framing_examples = {}
+    
+    # Count framing patterns
+    for frame, patterns in FRAMING_PATTERNS.items():
+        framing_counts[frame] = 0
+        framing_examples[frame] = []
         
-        if total_framing > 0:
-            for frame, count in framing_counts.items():
-                framing_distribution[frame] = count / total_framing
-            
-            dominant_frame = max(framing_counts.items(), key=lambda x: x[1])[0]
-            frame_bias_strength = max(0.0, framing_distribution[dominant_frame] - 0.25)
-        else:
-            dominant_frame = "none"
-            frame_bias_strength = 0.0
-            framing_distribution = {frame: 0.0 for frame in FRAMING_PATTERNS.keys()}
+        for pattern in patterns:
+            matches = re.findall(pattern, text_lower)
+            if matches:
+                framing_counts[frame] += len(matches)
+                # Store up to 5 examples of each frame
+                unique_matches = set(matches)
+                framing_examples[frame].extend(list(unique_matches)[:5])
+    
+    # Calculate dominant frame
+    total_framing = sum(framing_counts.values())
+    framing_distribution = {}
+    
+    if total_framing > 0:
+        for frame, count in framing_counts.items():
+            framing_distribution[frame] = count / total_framing
         
-        logger.info(f"Framing analysis complete. Dominant frame: {dominant_frame}")
-        return {
-            "framing_counts": framing_counts,
-            "framing_examples": framing_examples,
-            "framing_distribution": framing_distribution,
-            "dominant_frame": dominant_frame,
-            "frame_bias_strength": frame_bias_strength
-        }
-    except Exception as e:
-        logger.error(f"Error in framing analysis: {str(e)}")
-        # Return default values to prevent failures
-        return {
-            "framing_counts": {frame: 0 for frame in FRAMING_PATTERNS.keys()},
-            "framing_examples": {frame: [] for frame in FRAMING_PATTERNS.keys()},
-            "framing_distribution": {frame: 0.0 for frame in FRAMING_PATTERNS.keys()},
-            "dominant_frame": "none",
-            "frame_bias_strength": 0.0,
-            "error": str(e)
-        }
+        dominant_frame = max(framing_counts.items(), key=lambda x: x[1])[0]
+        frame_bias_strength = max(0.0, framing_distribution[dominant_frame] - 0.25)
+    else:
+        dominant_frame = "none"
+        frame_bias_strength = 0.0
+        framing_distribution = {frame: 0.0 for frame in FRAMING_PATTERNS.keys()}
+    
+    return {
+        "framing_counts": framing_counts,
+        "framing_examples": framing_examples,
+        "framing_distribution": framing_distribution,
+        "dominant_frame": dominant_frame,
+        "frame_bias_strength": frame_bias_strength
+    }
 
 def compare_bias(text1, text2, model_names=None):
     """
@@ -263,112 +204,71 @@ def compare_bias(text1, text2, model_names=None):
     Returns:
         dict: Comparative bias analysis
     """
-    logger.info(f"Starting bias comparison analysis")
-    logger.info(f"Text lengths - Text1: {len(text1)}, Text2: {len(text2)}")
-    
     # Set default model names if not provided
     if model_names is None or len(model_names) < 2:
-        logger.info(f"Using default model names")
         model_names = ["Model 1", "Model 2"]
-    else:
-        logger.info(f"Using provided model names: {model_names}")
     
     model1_name, model2_name = model_names[0], model_names[1]
     
-    try:
-        # Analyze each text
-        sentiment_results1 = detect_sentiment_bias(text1)
-        sentiment_results2 = detect_sentiment_bias(text2)
-        
-        partisan_results1 = detect_partisan_leaning(text1)
-        partisan_results2 = detect_partisan_leaning(text2)
-        
-        framing_results1 = detect_framing_bias(text1)
-        framing_results2 = detect_framing_bias(text2)
-        
-        # Determine if there's a significant difference in bias
-        sentiment_difference = abs(sentiment_results1["bias_strength"] - sentiment_results2["bias_strength"])
-        
-        # For partisan leaning, compare the scores (negative is liberal, positive is conservative)
-        partisan_difference = abs(partisan_results1["lean_score"] - partisan_results2["lean_score"])
-        
-        # Calculate overall bias difference
-        overall_difference = (sentiment_difference + partisan_difference) / 2
-        
-        # Compare dominant frames
-        frame_difference = framing_results1["dominant_frame"] != framing_results2["dominant_frame"] and \
-                          (framing_results1["frame_bias_strength"] > 0.1 or framing_results2["frame_bias_strength"] > 0.1)
-        
-        logger.info(f"Differences calculated - Sentiment: {sentiment_difference:.2f}, Partisan: {partisan_difference:.2f}")
-        
-        # Create comparative analysis
-        comparative = {
-            "sentiment": {
-                model1_name: sentiment_results1["bias_direction"],
-                model2_name: sentiment_results2["bias_direction"],
-                "difference": sentiment_difference,
-                "significant": sentiment_difference > 0.3
-            },
-            "partisan": {
-                model1_name: partisan_results1["leaning"],
-                model2_name: partisan_results2["leaning"],
-                "difference": partisan_difference,
-                "significant": partisan_difference > 0.4
-            },
-            "framing": {
-                model1_name: framing_results1["dominant_frame"],
-                model2_name: framing_results2["dominant_frame"],
-                "different_frames": frame_difference
-            },
-            "overall": {
-                "difference": overall_difference,
-                "significant_bias_difference": overall_difference > 0.35
-            }
-        }
-        
-        # Assemble the complete result
-        result = {
-            "models": model_names,
-            model1_name: {
-                "sentiment": sentiment_results1,
-                "partisan": partisan_results1,
-                "framing": framing_results1
-            },
-            model2_name: {
-                "sentiment": sentiment_results2,
-                "partisan": partisan_results2,
-                "framing": framing_results2
-            },
-            "comparative": comparative
+    # Analyze each text
+    sentiment_results1 = detect_sentiment_bias(text1)
+    sentiment_results2 = detect_sentiment_bias(text2)
+    
+    partisan_results1 = detect_partisan_leaning(text1)
+    partisan_results2 = detect_partisan_leaning(text2)
+    
+    framing_results1 = detect_framing_bias(text1)
+    framing_results2 = detect_framing_bias(text2)
+    
+    # Determine if there's a significant difference in bias
+    sentiment_difference = abs(sentiment_results1["bias_strength"] - sentiment_results2["bias_strength"])
+    
+    # For partisan leaning, compare the scores (negative is liberal, positive is conservative)
+    partisan_difference = abs(partisan_results1["lean_score"] - partisan_results2["lean_score"])
+    
+    # Calculate overall bias difference
+    overall_difference = (sentiment_difference + partisan_difference) / 2
+    
+    # Compare dominant frames
+    frame_difference = framing_results1["dominant_frame"] != framing_results2["dominant_frame"] and \
+                      (framing_results1["frame_bias_strength"] > 0.1 or framing_results2["frame_bias_strength"] > 0.1)
+    
+    # Create comparative analysis
+    comparative = {
+        "sentiment": {
+            model1_name: sentiment_results1["bias_direction"],
+            model2_name: sentiment_results2["bias_direction"],
+            "difference": sentiment_difference,
+            "significant": sentiment_difference > 0.3
+        },
+        "partisan": {
+            model1_name: partisan_results1["leaning"],
+            model2_name: partisan_results2["leaning"],
+            "difference": partisan_difference,
+            "significant": partisan_difference > 0.4
+        },
+        "framing": {
+            model1_name: framing_results1["dominant_frame"],
+            model2_name: framing_results2["dominant_frame"],
+            "different_frames": frame_difference
+        },
+        "overall": {
+            "difference": overall_difference,
+            "significant_bias_difference": overall_difference > 0.35
         }
-        
-        logger.info(f"Bias comparison complete. Result has {len(result)} top-level keys.")
-        logger.info(f"Result keys: {result.keys()}")
-        return result
-        
-    except Exception as e:
-        import traceback
-        error_msg = f"Error in bias comparison: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_msg)
-        
-        # Return an error result that won't break visualization
-        return {
-            "models": model_names,
-            "error": str(e),
-            "comparative": {
-                "sentiment": {model1_name: "neutral", model2_name: "neutral", "difference": 0, "significant": False},
-                "partisan": {model1_name: "balanced", model2_name: "balanced", "difference": 0, "significant": False},
-                "framing": {model1_name: "none", model2_name: "none", "different_frames": False},
-                "overall": {"difference": 0, "significant_bias_difference": False}
-            },
-            model1_name: {
-                "sentiment": {"bias_direction": "neutral", "bias_strength": 0},
-                "partisan": {"leaning": "balanced", "strength": 0},
-                "framing": {"dominant_frame": "none"}
-            },
-            model2_name: {
-                "sentiment": {"bias_direction": "neutral", "bias_strength": 0},
-                "partisan": {"leaning": "balanced", "strength": 0},
-                "framing": {"dominant_frame": "none"}
-            }
-        }
+    }
+    
+    return {
+        "models": model_names,
+        model1_name: {
+            "sentiment": sentiment_results1,
+            "partisan": partisan_results1,
+            "framing": framing_results1
+        },
+        model2_name: {
+            "sentiment": sentiment_results2,
+            "partisan": partisan_results2,
+            "framing": framing_results2
+        },
+        "comparative": comparative
+    }

processors/bias_processor.py

@@ -1,56 +0,0 @@
-import gradio as gr
-import logging
-
-logger = logging.getLogger("gradio_app.bias_processor")
-
-
-def process_bias_detection(analysis_results, prompt, analyses):
-    """
-    Process and return visualization components for bias detection.
-
-    Args:
-        analysis_results (dict): The full analysis results.
-        prompt (str): The prompt or key associated with the analysis.
-        analyses (dict): The specific analysis results for bias detection.
-
-    Returns:
-        tuple: Visualization components for the Gradio app.
-    """
-    try:
-        logger.info("Processing Bias Detection results...")
-
-        # Import the bias visualizer function
-        from visualization.bias_visualizer import process_and_visualize_bias_analysis
-        
-        # Use the specialized bias visualizer
-        return process_and_visualize_bias_analysis(analysis_results)
-
-    except Exception as e:
-        # Log and return an error response
-        import traceback
-        error_message = f"Error processing Bias Detection results: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_message)
-        return default_error_response(error_message)
-
-
-def default_error_response(error_message):
-    """Returns default error response for bias detection visualization"""
-    # Create a complete response with the correct number of components (16)
-    return [
-        {},  # analysis_results_state
-        False,  # analysis_output visibility
-        True,  # visualization_area_visible
-        gr.update(visible=True),  # analysis_title
-        gr.update(visible=False),  # prompt_title
-        gr.update(visible=False),  # models_compared
-        gr.update(visible=False),  # model1_title
-        gr.update(visible=False),  # model1_words
-        gr.update(visible=False),  # model2_title
-        gr.update(visible=False),  # model2_words
-        gr.update(visible=False),  # similarity_metrics_title
-        gr.update(visible=False),  # similarity_metrics
-        True,  # status_message_visible
-        gr.update(visible=True, value=f"Error: {error_message}"),  # status_message
-        gr.update(visible=False),  # column
-        gr.update(visible=False)   # html/bias_visualizations
-    ]

processors/bow_processor.py

@@ -1,107 +0,0 @@
-import gradio as gr
-import logging
-
-# Set up logging
-logger = logging.getLogger('gradio_app.processors.bow')
-
-
-def process_bow_analysis(analysis_results, prompt, analyses):
-    """
-    Process Bag of Words analysis and return UI updates
-
-    Args:
-        analysis_results (dict): Complete analysis results
-        prompt (str): The prompt being analyzed
-        analyses (dict): Analysis data for the prompt
-
-    Returns:
-        tuple: UI component updates
-    """
-    visualization_area_visible = True
-    bow_results = analyses["bag_of_words"]
-    models = bow_results.get("models", [])
-
-    if len(models) < 2:
-        from analysis_runner import default_no_visualization
-        return default_no_visualization(analysis_results)
-
-    prompt_title_visible = True
-    prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
-
-    models_compared_visible = True
-    models_compared_value = f"### Comparing responses from {models[0]} and {models[1]}"
-
-    # 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_title_visible = False
-    model1_title_value = ""
-    model1_words_visible = False
-    model1_words_value = ""
-
-    if model1_name in important_words:
-        model1_title_visible = True
-        model1_title_value = f"#### Top Words Used by {model1_name}"
-
-        word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model1_name][:10]]
-        model1_words_visible = True
-        model1_words_value = ", ".join(word_list)
-
-    model2_title_visible = False
-    model2_title_value = ""
-    model2_words_visible = False
-    model2_words_value = ""
-
-    if model2_name in important_words:
-        model2_title_visible = True
-        model2_title_value = f"#### Top Words Used by {model2_name}"
-
-        word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model2_name][:10]]
-        model2_words_visible = True
-        model2_words_value = ", ".join(word_list)
-
-    similarity_title_visible = False
-    similarity_metrics_visible = False
-    similarity_metrics_value = ""
-
-    # Format similarity metrics
-    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)
-        semantic = metrics.get("semantic_similarity", 0)
-        common_words = metrics.get("common_word_count", 0)
-
-        similarity_title_visible = True
-        similarity_metrics_visible = True
-        similarity_metrics_value = f"""
-        - **Cosine Similarity**: {cosine:.2f} (higher means more similar word frequency patterns)
-        - **Jaccard Similarity**: {jaccard:.2f} (higher means more word overlap)
-        - **Semantic Similarity**: {semantic:.2f} (higher means more similar meaning)
-        - **Common Words**: {common_words} words appear in both responses
-        """
-
-    return (
-        analysis_results,  # analysis_results_state
-        False,  # analysis_output visibility
-        True,  # visualization_area_visible
-        gr.update(visible=True),  # analysis_title
-        gr.update(visible=prompt_title_visible, value=prompt_title_value),  # prompt_title
-        gr.update(visible=models_compared_visible, value=models_compared_value),  # models_compared
-        gr.update(visible=model1_title_visible, value=model1_title_value),  # model1_title
-        gr.update(visible=model1_words_visible, value=model1_words_value),  # model1_words
-        gr.update(visible=model2_title_visible, value=model2_title_value),  # model2_title
-        gr.update(visible=model2_words_visible, value=model2_words_value),  # model2_words
-        gr.update(visible=similarity_title_visible),  # similarity_metrics_title
-        gr.update(visible=similarity_metrics_visible, value=similarity_metrics_value),  # similarity_metrics
-        False,  # status_message_visible
-        gr.update(visible=False),  # status_message
-        gr.update(visible=False)  # bias_visualizations - Not visible for BoW analysis
-    )

processors/classifier_processor.py

@@ -1,99 +0,0 @@
-import gradio as gr
-import logging
-
-# Set up logging
-logger = logging.getLogger('gradio_app.processors.classifier')
-
-
-def process_classifier_analysis(analysis_results, prompt, analyses):
-    """
-    Process Classifier analysis and return UI updates
-
-    Args:
-        analysis_results (dict): Complete analysis results
-        prompt (str): The prompt being analyzed
-        analyses (dict): Analysis data for the prompt
-
-    Returns:
-        tuple: UI component updates
-    """
-    visualization_area_visible = True
-    classifier_results = analyses["classifier"]
-    models = classifier_results.get("models", [])
-
-    if len(models) < 2:
-        from analysis_runner import default_no_visualization
-        return default_no_visualization(analysis_results)
-
-    prompt_title_visible = True
-    prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
-
-    models_compared_visible = True
-    models_compared_value = f"### Classifier Analysis for {models[0]} and {models[1]}"
-
-    # Extract and format classifier information
-    model1_name = models[0]
-    model2_name = models[1]
-
-    # Display classifications for each model
-    classifications = classifier_results.get("classifications", {})
-
-    model1_title_visible = False
-    model1_title_value = ""
-    model1_words_visible = False
-    model1_words_value = ""
-
-    if classifications:
-        model1_title_visible = True
-        model1_title_value = f"#### Classification Results"
-        model1_words_visible = True
-
-        model1_results = classifications.get(model1_name, {})
-        model2_results = classifications.get(model2_name, {})
-
-        model1_words_value = f"""
-        **{model1_name}**:
-        - Formality: {model1_results.get('formality', 'N/A')}
-        - Sentiment: {model1_results.get('sentiment', 'N/A')}
-        - Complexity: {model1_results.get('complexity', 'N/A')}
-
-        **{model2_name}**:
-        - Formality: {model2_results.get('formality', 'N/A')}
-        - Sentiment: {model2_results.get('sentiment', 'N/A')}
-        - Complexity: {model2_results.get('complexity', 'N/A')}
-        """
-
-    # Show comparison
-    model2_title_visible = False
-    model2_title_value = ""
-    model2_words_visible = False
-    model2_words_value = ""
-
-    differences = classifier_results.get("differences", {})
-    if differences:
-        model2_title_visible = True
-        model2_title_value = f"#### Classification Comparison"
-        model2_words_visible = True
-
-        model2_words_value = "\n".join([
-            f"- **{category}**: {diff}"
-            for category, diff in differences.items()
-        ])
-
-    return (
-        analysis_results,  # analysis_results_state
-        False,  # analysis_output visibility
-        True,  # visualization_area_visible
-        gr.update(visible=True),  # analysis_title
-        gr.update(visible=prompt_title_visible, value=prompt_title_value),  # prompt_title
-        gr.update(visible=models_compared_visible, value=models_compared_value),  # models_compared
-        gr.update(visible=model1_title_visible, value=model1_title_value),  # model1_title
-        gr.update(visible=model1_words_visible, value=model1_words_value),  # model1_words
-        gr.update(visible=model2_title_visible, value=model2_title_value),  # model2_title
-        gr.update(visible=model2_words_visible, value=model2_words_value),  # model2_words
-        gr.update(visible=False),  # similarity_metrics_title
-        gr.update(visible=False),  # similarity_metrics
-        False,  # status_message_visible
-        gr.update(visible=False),  # status_message
-        gr.update(visible=False)  # bias_visualizations - Not visible for Classifier analysis
-    )

processors/ngram_processor.py

@@ -1,103 +0,0 @@
-import gradio as gr
-import logging
-
-# Set up logging
-logger = logging.getLogger('gradio_app.processors.ngram')
-
-
-def process_ngram_analysis(analysis_results, prompt, analyses):
-    """
-    Process N-gram analysis and return UI updates
-
-    Args:
-        analysis_results (dict): Complete analysis results
-        prompt (str): The prompt being analyzed
-        analyses (dict): Analysis data for the prompt
-
-    Returns:
-        tuple: UI component updates
-    """
-    visualization_area_visible = True
-    ngram_results = analyses["ngram_analysis"]
-    models = ngram_results.get("models", [])
-    ngram_size = ngram_results.get("ngram_size", 2)
-    size_name = "Unigrams" if ngram_size == 1 else f"{ngram_size}-grams"
-
-    if len(models) < 2:
-        from analysis_runner import default_no_visualization
-        return default_no_visualization(analysis_results)
-
-    prompt_title_visible = True
-    prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
-
-    models_compared_visible = True
-    models_compared_value = f"### {size_name} Analysis: Comparing responses from {models[0]} and {models[1]}"
-
-    # Extract and format information for display
-    model1_name = models[0]
-    model2_name = models[1]
-
-    # Format important n-grams for each model
-    important_ngrams = ngram_results.get("important_ngrams", {})
-
-    model1_title_visible = False
-    model1_title_value = ""
-    model1_words_visible = False
-    model1_words_value = ""
-
-    if model1_name in important_ngrams:
-        model1_title_visible = True
-        model1_title_value = f"#### Top {size_name} Used by {model1_name}"
-
-        ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in important_ngrams[model1_name][:10]]
-        model1_words_visible = True
-        model1_words_value = ", ".join(ngram_list)
-
-    model2_title_visible = False
-    model2_title_value = ""
-    model2_words_visible = False
-    model2_words_value = ""
-
-    if model2_name in important_ngrams:
-        model2_title_visible = True
-        model2_title_value = f"#### Top {size_name} Used by {model2_name}"
-
-        ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in important_ngrams[model2_name][:10]]
-        model2_words_visible = True
-        model2_words_value = ", ".join(ngram_list)
-
-    similarity_title_visible = False
-    similarity_metrics_visible = False
-    similarity_metrics_value = ""
-
-    # Format similarity metrics if available
-    if "comparisons" in ngram_results:
-        comparison_key = f"{model1_name} vs {model2_name}"
-
-        if comparison_key in ngram_results["comparisons"]:
-            metrics = ngram_results["comparisons"][comparison_key]
-            common_count = metrics.get("common_ngram_count", 0)
-
-            similarity_title_visible = True
-            similarity_metrics_visible = True
-            similarity_metrics_value = f"""
-            - **Common {size_name}**: {common_count} {size_name.lower()} appear in both responses
-            """
-
-    return (
-        analysis_results,  # analysis_results_state
-        False,  # analysis_output visibility
-        True,  # visualization_area_visible
-        gr.update(visible=True),  # analysis_title
-        gr.update(visible=prompt_title_visible, value=prompt_title_value),  # prompt_title
-        gr.update(visible=models_compared_visible, value=models_compared_value),  # models_compared
-        gr.update(visible=model1_title_visible, value=model1_title_value),  # model1_title
-        gr.update(visible=model1_words_visible, value=model1_words_value),  # model1_words
-        gr.update(visible=model2_title_visible, value=model2_title_value),  # model2_title
-        gr.update(visible=model2_words_visible, value=model2_words_value),  # model2_words
-        gr.update(visible=similarity_title_visible),  # similarity_metrics_title
-        gr.update(visible=similarity_metrics_visible, value=similarity_metrics_value),  # similarity_metrics
-        False,  # status_message_visible
-        gr.update(visible=False),  # status_message
-        gr.update(visible=False)  # bias_visualizations - Not visible for N-gram analysis
-    )

processors/topic_modeling.py

@@ -1,6 +1,5 @@
 """
-Enhanced topic modeling processor for comparing text responses with better error handling
-and more robust algorithm configuration
+Topic modeling processor for comparing text responses
 """
 from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
 from sklearn.decomposition import LatentDirichletAllocation, NMF
@@ -8,12 +7,6 @@ import numpy as np
 import nltk
 from nltk.corpus import stopwords
 import re
-from scipy.spatial import distance
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('topic_modeling')
 
 def preprocess_text(text):
     """
@@ -25,25 +18,20 @@ def preprocess_text(text):
     Returns:
         str: Preprocessed text
     """
-    try:
-        # Convert to lowercase
-        text = text.lower()
-        
-        # Remove special characters and digits
-        text = re.sub(r'[^a-zA-Z\s]', '', text)
-        
-        # Tokenize
-        tokens = nltk.word_tokenize(text)
-        
-        # Remove stopwords
-        stop_words = set(stopwords.words('english'))
-        tokens = [token for token in tokens if token not in stop_words and len(token) > 3]
-        
-        return ' '.join(tokens)
-    except Exception as e:
-        logger.error(f"Error in preprocess_text: {str(e)}")
-        # Return original text if preprocessing fails
-        return text
+    # Convert to lowercase
+    text = text.lower()
+    
+    # Remove special characters and digits
+    text = re.sub(r'[^a-zA-Z\s]', '', text)
+    
+    # Tokenize
+    tokens = nltk.word_tokenize(text)
+    
+    # Remove stopwords
+    stop_words = set(stopwords.words('english'))
+    tokens = [token for token in tokens if token not in stop_words and len(token) > 3]
+    
+    return ' '.join(tokens)
 
 def get_top_words_per_topic(model, feature_names, n_top_words=10):
     """
@@ -82,14 +70,6 @@ def extract_topics(texts, n_topics=3, n_top_words=10, method="lda"):
     Returns:
         dict: Topic modeling results with topics and document-topic distributions
     """
-    if isinstance(n_topics, str):
-        n_topics = int(n_topics)
-        
-    # Ensure n_topics is at least 2
-    n_topics = max(2, n_topics)
-    
-    logger.info(f"Starting topic modeling with method={method}, n_topics={n_topics}")
-    
     result = {
         "method": method,
         "n_topics": n_topics,
@@ -97,102 +77,45 @@ def extract_topics(texts, n_topics=3, n_top_words=10, method="lda"):
         "document_topics": []
     }
     
-    try:
-        # Preprocess texts
-        logger.info("Preprocessing texts")
-        preprocessed_texts = [preprocess_text(text) for text in texts]
-        
-        # Check if texts are not empty after preprocessing
-        preprocessed_texts = [text for text in preprocessed_texts if len(text.strip()) > 0]
-        if not preprocessed_texts:
-            logger.warning("All texts are empty after preprocessing")
-            return result
-        
-        # Create document-term matrix
-        logger.info(f"Creating document-term matrix using {method}")
-        if method == "nmf":
-            # For NMF, use TF-IDF vectorization
-            vectorizer = TfidfVectorizer(max_features=1000, min_df=1, max_df=0.95, stop_words='english')
-        else:
-            # For LDA, use CountVectorizer
-            vectorizer = CountVectorizer(max_features=1000, min_df=1, max_df=0.95, stop_words='english')
-        
-        try:
-            X = vectorizer.fit_transform(preprocessed_texts)
-            feature_names = vectorizer.get_feature_names_out()
-            
-            # Check if we have enough features
-            if X.shape[1] < n_topics:
-                logger.warning(f"Only {X.shape[1]} features found, reducing n_topics from {n_topics}")
-                n_topics = max(2, X.shape[1] - 1)
-                result["n_topics"] = n_topics
-            
-            # Apply topic modeling
-            logger.info(f"Applying {method.upper()} with {n_topics} topics")
-            if method == "nmf":
-                # Non-negative Matrix Factorization
-                model = NMF(n_components=n_topics, random_state=42, max_iter=1000)
-            else:
-                # Latent Dirichlet Allocation
-                model = LatentDirichletAllocation(
-                    n_components=n_topics, 
-                    random_state=42, 
-                    max_iter=20,
-                    learning_method='online'
-                )
-            
-            topic_distribution = model.fit_transform(X)
-            
-            # Get top words for each topic
-            logger.info("Extracting top words for each topic")
-            result["topics"] = get_top_words_per_topic(model, feature_names, n_top_words)
-            
-            # Get topic distribution for each document
-            logger.info("Calculating topic distributions for documents")
-            for i, dist in enumerate(topic_distribution):
-                # Normalize for easier comparison
-                normalized_dist = dist / np.sum(dist) if np.sum(dist) > 0 else dist
-                result["document_topics"].append({
-                    "document_id": i,
-                    "distribution": normalized_dist.tolist()
-                })
-                
-            logger.info("Topic modeling completed successfully")
-            
-        except Exception as e:
-            logger.error(f"Error in vectorization or modeling: {str(e)}")
-            result["error"] = f"Topic modeling failed: {str(e)}"
-            
-    except Exception as e:
-        logger.error(f"General error in extract_topics: {str(e)}")
-        result["error"] = f"Topic modeling failed: {str(e)}"
+    # Preprocess texts
+    preprocessed_texts = [preprocess_text(text) for text in texts]
     
-    return result
-
-def calculate_jensen_shannon_divergence(p, q):
-    """
-    Calculate Jensen-Shannon divergence between two probability distributions
+    # Create document-term matrix
+    if method == "nmf":
+        # For NMF, use TF-IDF vectorization
+        # Adjust min_df and max_df for small document sets
+        vectorizer = TfidfVectorizer(max_features=1000, min_df=1, max_df=1.0)
+    else:
+        # For LDA, use CountVectorizer
+        # Adjust min_df and max_df for small document sets
+        vectorizer = CountVectorizer(max_features=1000, min_df=1, max_df=1.0)
     
-    Args:
-        p (array): First probability distribution
-        q (array): Second probability distribution
-        
-    Returns:
-        float: Jensen-Shannon divergence
-    """
-    # Ensure inputs are numpy arrays
-    p = np.array(p)
-    q = np.array(q)
+    X = vectorizer.fit_transform(preprocessed_texts)
+    feature_names = vectorizer.get_feature_names_out()
+    
+    # Apply topic modeling
+    if method == "nmf":
+        # Non-negative Matrix Factorization
+        model = NMF(n_components=n_topics, random_state=42, max_iter=1000)
+    else:
+        # Latent Dirichlet Allocation
+        model = LatentDirichletAllocation(n_components=n_topics, random_state=42, max_iter=20)
+    
+    topic_distribution = model.fit_transform(X)
     
-    # Normalize if not already normalized
-    if np.sum(p) != 1.0:
-        p = p / np.sum(p) if np.sum(p) > 0 else p
-    if np.sum(q) != 1.0:
-        q = q / np.sum(q) if np.sum(q) > 0 else q
+    # Get top words for each topic
+    result["topics"] = get_top_words_per_topic(model, feature_names, n_top_words)
     
-    # Calculate Jensen-Shannon divergence
-    m = 0.5 * (p + q)
-    return 0.5 * (distance.jensenshannon(p, m) + distance.jensenshannon(q, m))
+    # Get topic distribution for each document
+    for i, dist in enumerate(topic_distribution):
+        # Normalize for easier comparison
+        normalized_dist = dist / np.sum(dist) if np.sum(dist) > 0 else dist
+        result["document_topics"].append({
+            "document_id": i,
+            "distribution": normalized_dist.tolist()
+        })
+    
+    return result
 
 def compare_topics(texts_set_1, texts_set_2, n_topics=3, n_top_words=10, method="lda", model_names=None):
     """
@@ -209,98 +132,50 @@ def compare_topics(texts_set_1, texts_set_2, n_topics=3, n_top_words=10, method=
     Returns:
         dict: Comparison results with topics from both sets and similarity metrics
     """
-    logger.info(f"Starting topic comparison with n_topics={n_topics}, method={method}")
-    
     # Set default model names if not provided
     if model_names is None:
         model_names = ["Model 1", "Model 2"]
     
-    # Initialize the result structure
+    # Extract topics for each set
+    topics_set_1 = extract_topics(texts_set_1, n_topics, n_top_words, method)
+    topics_set_2 = extract_topics(texts_set_2, n_topics, n_top_words, method)
+    
+    # Calculate similarity between topics
+    similarity_matrix = []
+    for topic1 in topics_set_1["topics"]:
+        topic_similarities = []
+        words1 = set(topic1["words"])
+        for topic2 in topics_set_2["topics"]:
+            words2 = set(topic2["words"])
+            # Jaccard similarity: intersection over union
+            intersection = len(words1.intersection(words2))
+            union = len(words1.union(words2))
+            similarity = intersection / union if union > 0 else 0
+            topic_similarities.append(similarity)
+        similarity_matrix.append(topic_similarities)
+    
+    # Find the best matching topic pairs
+    matched_topics = []
+    for i, similarities in enumerate(similarity_matrix):
+        best_match_idx = np.argmax(similarities)
+        matched_topics.append({
+            "set1_topic_id": i,
+            "set1_topic_words": topics_set_1["topics"][i]["words"],
+            "set2_topic_id": best_match_idx,
+            "set2_topic_words": topics_set_2["topics"][best_match_idx]["words"],
+            "similarity": similarities[best_match_idx]
+        })
+    
+    # Construct result
     result = {
         "method": method,
         "n_topics": n_topics,
-        "models": model_names,
-        "model_topics": {},
-        "topics": [],
-        "comparisons": {}
+        "set1_topics": topics_set_1["topics"],
+        "set2_topics": topics_set_2["topics"],
+        "similarity_matrix": similarity_matrix,
+        "matched_topics": matched_topics,
+        "average_similarity": np.mean([match["similarity"] for match in matched_topics]),
+        "models": model_names  # Add model names to result
     }
     
-    try:
-        # Extract topics for each set separately
-        # For very short texts, try combining all texts from each model
-        combined_text_1 = " ".join(texts_set_1)
-        combined_text_2 = " ".join(texts_set_2)
-        
-        # Process all texts together to find common topics
-        all_texts = texts_set_1 + texts_set_2
-        logger.info(f"Processing {len(all_texts)} total texts")
-        
-        # Extract topics from combined corpus
-        combined_result = extract_topics(all_texts, n_topics, n_top_words, method)
-        
-        # Check for errors
-        if "error" in combined_result:
-            logger.warning(f"Error in combined topic extraction: {combined_result['error']}")
-            result["error"] = combined_result["error"]
-            return result
-        
-        # Store topics from combined analysis
-        result["topics"] = combined_result["topics"]
-        
-        # Now process each text set to get their topic distributions
-        model1_doc_topics = []
-        model2_doc_topics = []
-        
-        # Try to use the same model from combined analysis for consistency
-        if "document_topics" in combined_result and len(combined_result["document_topics"]) == len(all_texts):
-            # Get document topics for each model
-            n_docs_model1 = len(texts_set_1)
-            for i, doc_topic in enumerate(combined_result["document_topics"]):
-                if i < n_docs_model1:
-                    model1_doc_topics.append(doc_topic["distribution"])
-                else:
-                    model2_doc_topics.append(doc_topic["distribution"])
-        else:
-            # Fallback: run separate topic modeling for each model
-            logger.info("Using separate topic modeling for each model")
-            model1_result = extract_topics([combined_text_1], n_topics, n_top_words, method)
-            model2_result = extract_topics([combined_text_2], n_topics, n_top_words, method)
-            
-            if "document_topics" in model1_result and model1_result["document_topics"]:
-                model1_doc_topics = [doc["distribution"] for doc in model1_result["document_topics"]]
-            
-            if "document_topics" in model2_result and model2_result["document_topics"]:
-                model2_doc_topics = [doc["distribution"] for doc in model2_result["document_topics"]]
-        
-        # Calculate average topic distribution for each model
-        if model1_doc_topics:
-            model1_avg_distribution = np.mean(model1_doc_topics, axis=0).tolist()
-            result["model_topics"][model_names[0]] = model1_avg_distribution
-        
-        if model2_doc_topics:
-            model2_avg_distribution = np.mean(model2_doc_topics, axis=0).tolist()
-            result["model_topics"][model_names[1]] = model2_avg_distribution
-        
-        # Calculate similarity between models' topic distributions
-        if model_names[0] in result["model_topics"] and model_names[1] in result["model_topics"]:
-            comparison_key = f"{model_names[0]} vs {model_names[1]}"
-            dist1 = result["model_topics"][model_names[0]]
-            dist2 = result["model_topics"][model_names[1]]
-            
-            # Calculate Jensen-Shannon divergence (smaller means more similar)
-            js_div = calculate_jensen_shannon_divergence(dist1, dist2)
-            
-            # Create comparison result
-            result["comparisons"][comparison_key] = {
-                "js_divergence": js_div
-            }
-            
-            logger.info(f"Topic comparison completed successfully. JS divergence: {js_div:.4f}")
-        else:
-            logger.warning("Could not calculate model comparisons due to missing topic distributions")
-            
-    except Exception as e:
-        logger.error(f"Error in compare_topics: {str(e)}")
-        result["error"] = f"Topic comparison failed: {str(e)}"
-    
-    return result
+    return result

processors/topic_processor.py

@@ -1,156 +0,0 @@
-import gradio as gr
-import logging
-
-# Set up logging
-logger = logging.getLogger('gradio_app.processors.topic')
-
-
-def process_topic_modeling(analysis_results, prompt, analyses):
-    """
-    Process Topic Modeling analysis and return UI updates
-
-    Args:
-        analysis_results (dict): Complete analysis results
-        prompt (str): The prompt being analyzed
-        analyses (dict): Analysis data for the prompt
-
-    Returns:
-        tuple: UI component updates
-    """
-    topic_results = analyses["topic_modeling"]
-
-    # Check for errors in topic modeling
-    if "error" in topic_results:
-        return (
-            analysis_results,
-            False,  # Don't show raw JSON
-            False,  # Don't show visualization area
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            True,  # Show status message
-            gr.update(visible=True, value=f"❌ **Topic modeling error:** {topic_results['error']}"),
-            gr.update(visible=False)  # bias_visualizations
-        )
-
-    visualization_area_visible = True
-    models = topic_results.get("models", [])
-    method = topic_results.get("method", "lda").upper()
-    n_topics = topic_results.get("n_topics", 3)
-
-    if len(models) < 2:
-        from analysis_runner import default_no_visualization
-        return default_no_visualization(analysis_results)
-
-    prompt_title_visible = True
-    prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
-
-    models_compared_visible = True
-    models_compared_value = f"### Topic Modeling Analysis ({method}, {n_topics} topics)"
-
-    # Initialize component visibility and values
-    model1_title_visible = False
-    model1_title_value = ""
-    model1_words_visible = False
-    model1_words_value = ""
-    model2_title_visible = False
-    model2_title_value = ""
-    model2_words_visible = False
-    model2_words_value = ""
-    similarity_title_visible = False
-    similarity_metrics_visible = False
-    similarity_metrics_value = ""
-
-    # Extract and format topic information
-    topics = topic_results.get("topics", [])
-
-    if topics:
-        # Format topic info for display
-        topic_info = []
-        for topic in topics[:5]:  # Show first 5 topics
-            topic_id = topic.get("id", 0)
-            words = topic.get("words", [])[:5]  # Top 5 words per topic
-
-            if words:
-                topic_info.append(f"**Topic {topic_id + 1}**: {', '.join(words)}")
-
-        if topic_info:
-            model1_title_visible = True
-            model1_title_value = "#### Discovered Topics"
-            model1_words_visible = True
-            model1_words_value = "\n".join(topic_info)
-
-    # Get topic distributions for models
-    model_topics = topic_results.get("model_topics", {})
-
-    if model_topics:
-        model1_name = models[0]
-        model2_name = models[1]
-
-        # Format topic distribution info
-        if model1_name in model_topics and model2_name in model_topics:
-            model2_title_visible = True
-            model2_title_value = "#### Topic Distribution"
-            model2_words_visible = True
-
-            # Simple distribution display
-            dist1 = model_topics[model1_name]
-            dist2 = model_topics[model2_name]
-
-            model2_words_value = f"""
-            **{model1_name}**: {', '.join([f"Topic {i + 1}: {v:.2f}" for i, v in enumerate(dist1[:5])])}
-
-            **{model2_name}**: {', '.join([f"Topic {i + 1}: {v:.2f}" for i, v in enumerate(dist2[:5])])}
-            """
-
-    # Add similarity metrics if available
-    comparisons = topic_results.get("comparisons", {})
-    if comparisons:
-        comparison_key = f"{model1_name} vs {model2_name}"
-
-        if comparison_key in comparisons:
-            metrics = comparisons[comparison_key]
-            js_div = metrics.get("js_divergence", 0)
-
-            # Add interpretation
-            similarity_text = ""
-            if js_div < 0.2:
-                similarity_text = "very similar"
-            elif js_div < 0.4:
-                similarity_text = "somewhat similar"
-            elif js_div < 0.6:
-                similarity_text = "moderately different"
-            else:
-                similarity_text = "very different"
-
-            similarity_title_visible = True
-            similarity_metrics_visible = True
-            similarity_metrics_value = f"""
-            - **Topic Distribution Divergence**: {js_div:.4f}
-            - The topic distributions between models are **{similarity_text}**
-            - *Lower divergence values indicate more similar topic distributions*
-            """
-
-    return (
-        analysis_results,  # analysis_results_state
-        False,  # analysis_output visibility
-        True,  # visualization_area_visible
-        gr.update(visible=True),  # analysis_title
-        gr.update(visible=prompt_title_visible, value=prompt_title_value),  # prompt_title
-        gr.update(visible=models_compared_visible, value=models_compared_value),  # models_compared
-        gr.update(visible=model1_title_visible, value=model1_title_value),  # model1_title
-        gr.update(visible=model1_words_visible, value=model1_words_value),  # model1_words
-        gr.update(visible=model2_title_visible, value=model2_title_value),  # model2_title
-        gr.update(visible=model2_words_visible, value=model2_words_value),  # model2_words
-        gr.update(visible=similarity_title_visible),  # similarity_metrics_title
-        gr.update(visible=similarity_metrics_visible, value=similarity_metrics_value),  # similarity_metrics
-        False,  # status_message_visible
-        gr.update(visible=False),  # status_message
-        gr.update(visible=False)  # bias_visualizations - Not visible for Topic Modeling
-    )

ui/analysis_screen.py

@@ -8,18 +8,13 @@ from processors.ngram_analysis import compare_ngrams
 from processors.bow_analysis import compare_bow
 from processors.text_classifiers import classify_formality, classify_sentiment, classify_complexity, compare_classifications
 from processors.bias_detection import compare_bias
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('analysis_screen')
 
 def create_analysis_screen():
     """
     Create the analysis options screen
     
     Returns:
-        tuple: (analysis_options, analysis_params, run_analysis_btn, analysis_output, ngram_n, topic_count)
+        tuple: (analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count)
     """
     with gr.Column() as analysis_screen:
         gr.Markdown("## Analysis Options")
@@ -40,14 +35,25 @@ def create_analysis_screen():
                 label="Select Analysis Type"
             )
         
+        # Create slider directly here for easier access
+        gr.Markdown("### Bag of Words Parameters")
+        bow_top_slider = gr.Slider(
+            minimum=10, maximum=100, value=25, step=5, 
+            label="Top Words to Compare", 
+            elem_id="bow_top_slider"
+        )
+        
         # Create N-gram parameters accessible at top level
         ngram_n = gr.Radio(
             choices=["1", "2", "3"], value="2", 
             label="N-gram Size",
             visible=False
         )
-        
-        # Removed ngram_top slider
+        ngram_top = gr.Slider(
+            minimum=5, maximum=30, value=10, step=1, 
+            label="Top N-grams to Display",
+            visible=False
+        )
         
         # Create topic modeling parameter accessible at top level
         topic_count = gr.Slider(
@@ -55,6 +61,15 @@ def create_analysis_screen():
             label="Number of Topics",
             visible=False
         )
+
+        bias_methods = gr.CheckboxGroup(
+            choices=["sentiment", "partisan", "framing"],
+            label="Bias Detection Methods",
+            value=["sentiment", "partisan"],
+            visible=False,  # Initially hidden, will be shown when Bias Detection is selected
+            interactive=True
+    )
+    
         
         # Parameters for each analysis type
         with gr.Group() as analysis_params:
@@ -63,16 +78,20 @@ def create_analysis_screen():
                 gr.Markdown("### Topic Modeling Parameters")
                 # We'll use the topic_count defined above
             
-            # N-gram parameters group (using external ngram_n, removed ngram_top)
+            # N-gram parameters group (using external ngram_n and ngram_top)
             with gr.Group(visible=False) as ngram_params:
                 gr.Markdown("### N-gram Parameters")
-                # We're already using ngram_n defined above
+                # We're already using ngram_n and ngram_top defined above
                 
-            # Bias detection parameters - simplified with no checkboxes
+            # Bias detection parameters
             with gr.Group(visible=False) as bias_params:
                 gr.Markdown("### Bias Detection Parameters")
-                gr.Markdown("Using partisan leaning bias detection and sentiment analysis")
-                gr.Markdown("This analysis detects sentiment bias, partisan leaning, and issue framing patterns.")
+                bias_methods = gr.CheckboxGroup(
+                    choices=["Sentiment Analysis", "Partisan Leaning", "Framing Analysis"],
+                    value=["Sentiment Analysis", "Partisan Leaning"],
+                    label="Bias Detection Methods",
+                    interactive=True  # Ensure this is interactive
+                )
             
             # Classifier parameters
             with gr.Group(visible=False) as classifier_params:
@@ -87,7 +106,9 @@ def create_analysis_screen():
                     bias_params: gr.update(visible=selected == "Bias Detection"),
                     classifier_params: gr.update(visible=selected == "Classifier"),
                     ngram_n: gr.update(visible=selected == "N-gram Analysis"),
+                    ngram_top: gr.update(visible=selected == "N-gram Analysis"),
                     topic_count: gr.update(visible=selected == "Topic Modeling"),
+                    bow_top_slider: gr.update(visible=selected == "Bag of Words")
                 }
                 
             # Set up event handler for analysis selection
@@ -100,7 +121,9 @@ def create_analysis_screen():
                     bias_params, 
                     classifier_params,
                     ngram_n, 
+                    ngram_top, 
                     topic_count,
+                    bow_top_slider
                 ]
             )
         
@@ -110,8 +133,8 @@ def create_analysis_screen():
         # Analysis output area - hidden JSON component to store raw results
         analysis_output = gr.JSON(label="Analysis Results", visible=False)
     
-    # Return the components needed by app.py, with ngram_top removed
-    return analysis_options, analysis_params, run_analysis_btn, analysis_output, ngram_n, topic_count
+    # Return the components needed by app.py, now including bias_methods
+    return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count, bias_methods
 
 # Add the implementation of these helper functions
 def extract_important_words(text, top_n=20):
@@ -324,10 +347,7 @@ def process_analysis_request(dataset, selected_analysis, parameters):
     Returns:
         tuple: A tuple containing (analysis_results, visualization_data)
     """
-    logger.info(f"Processing analysis request: {selected_analysis}")
-    
     if not dataset or "entries" not in dataset or not dataset["entries"]:
-        logger.warning("No valid dataset provided for analysis")
         return {}, None
         
     # Initialize the results structure
@@ -336,7 +356,6 @@ def process_analysis_request(dataset, selected_analysis, parameters):
     # Get the prompt text from the first entry
     prompt_text = dataset["entries"][0].get("prompt", "")
     if not prompt_text:
-        logger.warning("No prompt found in dataset")
         return {"error": "No prompt found in dataset"}, None
         
     # Initialize the analysis container for this prompt
@@ -349,138 +368,132 @@ def process_analysis_request(dataset, selected_analysis, parameters):
     model1_response = dataset["entries"][0].get("response", "")
     model2_response = dataset["entries"][1].get("response", "")
     
-    logger.info(f"Comparing responses from {model1_name} and {model2_name}")
-    
-    try:
-        # Process based on the selected analysis type
-        if selected_analysis == "Bag of Words":
-            # Use fixed default value of 25 for top_n
-            top_n = 25
-            
-            logger.info(f"Running Bag of Words analysis with top_n={top_n}")
-            
-            # Perform Bag of Words analysis using the processor
-            bow_results = compare_bow(
-                [model1_response, model2_response],
-                [model1_name, model2_name],
-                top_n=top_n
-            )
-            results["analyses"][prompt_text]["bag_of_words"] = bow_results
-            
-        elif selected_analysis == "N-gram Analysis":
-            # Perform N-gram analysis
-            ngram_size = parameters.get("ngram_n", 2)
-            if isinstance(ngram_size, str):
-                ngram_size = int(ngram_size)
-                
-            top_n = parameters.get("ngram_top", 15)
-            if isinstance(top_n, str):
-                top_n = int(top_n)
-            
-            logger.info(f"Running N-gram analysis with n={ngram_size}, top_n={top_n}")
-            
-            # Use the processor from the dedicated ngram_analysis module
-            from processors.ngram_analysis import compare_ngrams as ngram_processor
-            ngram_results = ngram_processor(
-                [model1_response, model2_response],
-                [model1_name, model2_name],
-                n=ngram_size,
-                top_n=top_n
-            )
-            results["analyses"][prompt_text]["ngram_analysis"] = ngram_results
-            
-        elif selected_analysis == "Topic Modeling":
-            # Perform topic modeling analysis
-            topic_count = parameters.get("topic_count", 3)
-            if isinstance(topic_count, str):
-                topic_count = int(topic_count)
-            
-            logger.info(f"Running Topic Modeling analysis with n_topics={topic_count}")
+    # Process based on the selected analysis type
+    if selected_analysis == "Bag of Words":
+        # Get the top_n parameter and ensure it's an integer
+        top_n = parameters.get("bow_top", 25)
+        if isinstance(top_n, str):
+            top_n = int(top_n)
+        
+        print(f"Using top_n value: {top_n}")  # Debug print
+        
+        # Perform Bag of Words analysis using the processor
+        bow_results = compare_bow(
+            [model1_response, model2_response],
+            [model1_name, model2_name],
+            top_n=top_n
+        )
+        results["analyses"][prompt_text]["bag_of_words"] = bow_results
+        
+    elif selected_analysis == "N-gram Analysis":
+        # Perform N-gram analysis
+        ngram_size = parameters.get("ngram_n", 2)
+        if isinstance(ngram_size, str):
+            ngram_size = int(ngram_size)
             
-            try:
-                topic_results = compare_topics(
-                    texts_set_1=[model1_response], 
-                    texts_set_2=[model2_response], 
-                    n_topics=topic_count,
-                    model_names=[model1_name, model2_name])
-                
-                results["analyses"][prompt_text]["topic_modeling"] = topic_results
-            except Exception as e:
-                import traceback
-                error_msg = f"Topic modeling error: {str(e)}\n{traceback.format_exc()}"
-                logger.error(error_msg)
-                results["analyses"][prompt_text]["topic_modeling"] = {
-                    "models": [model1_name, model2_name],
-                    "error": str(e),
-                    "message": "Topic modeling failed. Try with longer text or different parameters."
-                }
+        top_n = parameters.get("ngram_top", 15)
+        if isinstance(top_n, str):
+            top_n = int(top_n)
+        
+        # Use the processor from the dedicated ngram_analysis module
+        from processors.ngram_analysis import compare_ngrams as ngram_processor
+        ngram_results = ngram_processor(
+            [model1_response, model2_response],
+            [model1_name, model2_name],
+            n=ngram_size,
+            top_n=top_n
+        )
+        results["analyses"][prompt_text]["ngram_analysis"] = ngram_results
+        
+    elif selected_analysis == "Topic Modeling":
+        # Perform topic modeling analysis
+        topic_count = parameters.get("topic_count", 3)
+        if isinstance(topic_count, str):
+            topic_count = int(topic_count)
         
-        elif selected_analysis == "Classifier":
-            # Perform classifier analysis
-            logger.info("Running Classifier analysis")
+        try:
+            topic_results = compare_topics(
+                texts_set_1=[model1_response], 
+                texts_set_2=[model2_response], 
+                n_topics=topic_count,
+                model_names=[model1_name, model2_name])
             
-            results["analyses"][prompt_text]["classifier"] = {
+            results["analyses"][prompt_text]["topic_modeling"] = topic_results
+        except Exception as e:
+            import traceback
+            print(f"Topic modeling error: {str(e)}\n{traceback.format_exc()}")
+            results["analyses"][prompt_text]["topic_modeling"] = {
                 "models": [model1_name, model2_name],
-                "classifications": {
-                    model1_name: {
-                        "formality": classify_formality(model1_response),
-                        "sentiment": classify_sentiment(model1_response),
-                        "complexity": classify_complexity(model1_response)
-                    },
-                    model2_name: {
-                        "formality": classify_formality(model2_response),
-                        "sentiment": classify_sentiment(model2_response),
-                        "complexity": classify_complexity(model2_response)
-                    }
-                },
-                "differences": compare_classifications(model1_response, model2_response)
+                "error": str(e),
+                "message": "Topic modeling failed. Try with longer text or different parameters."
             }
+    
+    elif selected_analysis == "Classifier":
+        # Perform classifier analysis
+        results["analyses"][prompt_text]["classifier"] = {
+            "models": [model1_name, model2_name],
+            "classifications": {
+                model1_name: {
+                    "formality": classify_formality(model1_response),
+                    "sentiment": classify_sentiment(model1_response),
+                    "complexity": classify_complexity(model1_response)
+                },
+                model2_name: {
+                    "formality": classify_formality(model2_response),
+                    "sentiment": classify_sentiment(model2_response),
+                    "complexity": classify_complexity(model2_response)
+                }
+            },
+            "differences": compare_classifications(model1_response, model2_response)
+        }
 
-        elif selected_analysis == "Bias Detection":
-            # Use partisan leaning bias detection by default
-            logger.info("Running Bias Detection analysis")
+    elif selected_analysis == "Bias Detection":
+        # Get the bias detection methods from parameters
+        bias_methods = parameters.get("bias_methods", 
+                                   ["Sentiment Analysis", "Partisan Leaning", "Framing Analysis"])
+        
+        try:
+            # Perform bias detection analysis
+            bias_results = compare_bias(
+                model1_response, 
+                model2_response,
+                model_names=[model1_name, model2_name]
+            )
+            
+            # Filter results based on selected methods
+            filtered_results = {"models": [model1_name, model2_name]}
+            
+            # Always include comparative data
+            if "comparative" in bias_results:
+                filtered_results["comparative"] = bias_results["comparative"]
             
-            try:
-                # Perform bias detection analysis
-                logger.info(f"Calling compare_bias with model names: {model1_name}, {model2_name}")
-                logger.info(f"Text lengths - Text1: {len(model1_response)}, Text2: {len(model2_response)}")
+            # Include individual model results based on selected methods
+            for model in [model1_name, model2_name]:
+                filtered_results[model] = {}
                 
-                bias_results = compare_bias(
-                    model1_response, 
-                    model2_response,
-                    model_names=[model1_name, model2_name]
-                )
+                if "Sentiment Analysis" in bias_methods and model in bias_results:
+                    filtered_results[model]["sentiment"] = bias_results[model]["sentiment"]
                 
-                logger.info(f"Bias detection complete. Result has keys: {bias_results.keys() if bias_results else 'None'}")
-                results["analyses"][prompt_text]["bias_detection"] = bias_results
+                if "Partisan Leaning" in bias_methods and model in bias_results:
+                    filtered_results[model]["partisan"] = bias_results[model]["partisan"]
                 
-            except Exception as e:
-                import traceback
-                error_msg = f"Bias detection error: {str(e)}\n{traceback.format_exc()}"
-                logger.error(error_msg)
-                results["analyses"][prompt_text]["bias_detection"] = {
-                    "models": [model1_name, model2_name],
-                    "error": str(e),
-                    "message": "Bias detection failed. Try with different parameters."
-                }
-        
-        else:
-            # Unknown analysis type
-            logger.warning(f"Unknown analysis type: {selected_analysis}")
-            results["analyses"][prompt_text]["message"] = "Please select a valid analysis type."
-    
-    except Exception as e:
-        import traceback
-        error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_msg)
-        results = {
-            "error": error_msg,
-            "analyses": {
-                prompt_text: {
-                    "message": f"Analysis failed: {str(e)}"
-                }
+                if "Framing Analysis" in bias_methods and model in bias_results:
+                    filtered_results[model]["framing"] = bias_results[model]["framing"]
+            
+            results["analyses"][prompt_text]["bias_detection"] = filtered_results
+            
+        except Exception as e:
+            import traceback
+            print(f"Bias detection error: {str(e)}\n{traceback.format_exc()}")
+            results["analyses"][prompt_text]["bias_detection"] = {
+                "models": [model1_name, model2_name],
+                "error": str(e),
+                "message": "Bias detection failed. Try with different parameters."
             }
-        }
+    
+    else:
+        # Unknown analysis type
+        results["analyses"][prompt_text]["message"] = "Please select a valid analysis type."
     
     # Return both the analysis results and a placeholder for visualization data
-    return results, None
+    return results, None

visualization/bias_visualizer.py

@@ -1,169 +1,233 @@
 import gradio as gr
-import logging
-import plotly.express as px
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
+import plotly.express as px
 import pandas as pd
 
-# Set up logging
-logger = logging.getLogger('gradio_app.bias_visualizer')
-
-def process_and_visualize_bias_analysis(analysis_results):
+def create_bias_visualization(analysis_results):
     """
-    Process and visualize bias analysis results.
+    Create visualizations for bias detection analysis results
     
     Args:
-        analysis_results (dict): The analysis results containing bias detection data.
+        analysis_results (dict): Analysis results from the bias detection
         
     Returns:
-        list: Components for Gradio UI to display bias visualizations.
+        list: List of gradio components with visualizations
     """
-    logger.info("Processing bias visualization")
-    
-    # Default empty visualization components
-    from visualization_handler import create_empty_visualization_response
-    default_response = create_empty_visualization_response()
-    
-    try:
-        # Extract the first prompt (assuming there's only one)
-        if not analysis_results or "analyses" not in analysis_results:
-            logger.warning("No analyses found in results")
-            return default_response
-        
-        prompt_text = list(analysis_results["analyses"].keys())[0]
-        analyses = analysis_results["analyses"][prompt_text]
-        
-        if "bias_detection" not in analyses:
-            logger.warning("No bias detection results found")
-            return default_response
-        
-        bias_results = analyses["bias_detection"]
-        
-        # Get model names
-        model_names = bias_results.get("models", ["Model 1", "Model 2"])
-        model1_name, model2_name = model_names[0], model_names[1]
-        
-        # Create visualization components
-        prompt_title_value = f"### Prompt: {prompt_text}"
-        models_compared_value = f"### Comparing {model1_name} vs {model2_name}"
-        
-        # Model 1 details
-        model1_results = bias_results.get(model1_name, {})
-        model1_title_value = f"#### {model1_name} Bias Analysis"
-        model1_words_value = create_model_bias_summary(model1_results, model1_name)
-        
-        # Model 2 details
-        model2_results = bias_results.get(model2_name, {})
-        model2_title_value = f"#### {model2_name} Bias Analysis"
-        model2_words_value = create_model_bias_summary(model2_results, model2_name)
-        
-        # Comparative analysis
-        comparative = bias_results.get("comparative", {})
-        similarity_metrics_value = create_comparative_summary(comparative, model1_name, model2_name)
-        
-        # Create bias visualization HTML
-        bias_html_value = create_bias_visualizations_html(bias_results, model1_name, model2_name)
-        
-        # Bias visualizations should be visible
-        bias_visualizations_visible = True
-        
-        # Return all components
-        return [
-            analysis_results,  # analysis_results_state
-            False,  # analysis_output visibility
-            True,  # visualization_area_visible
-            gr.update(visible=True),  # analysis_title
-            gr.update(visible=True, value=prompt_title_value),  # prompt_title
-            gr.update(visible=True, value=models_compared_value),  # models_compared
-            gr.update(visible=True, value=model1_title_value),  # model1_title
-            gr.update(visible=True, value=model1_words_value),  # model1_words
-            gr.update(visible=True, value=model2_title_value),  # model2_title
-            gr.update(visible=True, value=model2_words_value),  # model2_words
-            gr.update(visible=True),  # similarity_metrics_title
-            gr.update(visible=True, value=similarity_metrics_value),  # similarity_metrics
-            False,  # status_message_visible
-            gr.update(visible=False),  # status_message
-            gr.update(visible=bias_visualizations_visible)  # bias_visualizations
-        ]
-        
-    except Exception as e:
-        import traceback
-        logger.error(f"Error in bias visualization: {str(e)}\n{traceback.format_exc()}")
-        default_response[12] = True  # Set status_message_visible to True
-        default_response[13] = gr.update(visible=True, value=f"Error creating bias visualization: {str(e)}")  # Set error message
-        return default_response
-
-def create_model_bias_summary(model_results, model_name):
-    """Create a text summary of bias results for a given model"""
-    if not model_results:
-        return "No bias results available"
+    output_components = []
     
-    sentiment = model_results.get("sentiment", {})
-    partisan = model_results.get("partisan", {})
-    framing = model_results.get("framing", {})
+    # Check if we have valid results
+    if not analysis_results or "analyses" not in analysis_results:
+        return [gr.Markdown("No analysis results found.")]
     
-    summary = f"""
-    **Sentiment Analysis:**
-    - Direction: {sentiment.get('bias_direction', 'neutral')}
-    - Strength: {sentiment.get('bias_strength', 0):.2f}/1.0
+    # Process each prompt
+    for prompt, analyses in analysis_results["analyses"].items():
+        # Process Bias Detection analysis if available
+        if "bias_detection" in analyses:
+            bias_results = analyses["bias_detection"]
+            
+            # Show models being compared
+            models = bias_results.get("models", [])
+            if len(models) >= 2:
+                output_components.append(gr.Markdown(f"### Bias Analysis: Comparing responses from {models[0]} and {models[1]}"))
+                
+                # Check if there's an error
+                if "error" in bias_results:
+                    output_components.append(gr.Markdown(f"**Error in bias detection:** {bias_results['error']}"))
+                    continue
+                
+                model1_name, model2_name = models[0], models[1]
+                
+                # Comparative results
+                if "comparative" in bias_results:
+                    comparative = bias_results["comparative"]
+                    
+                    output_components.append(gr.Markdown("#### Comparative Bias Analysis"))
+                    
+                    # Create summary table
+                    summary_html = f"""
+                    <table style="width:100%; border-collapse: collapse; margin-bottom: 20px;">
+                    <tr>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">Bias Category</th>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">{model1_name}</th>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">{model2_name}</th>
+                        <th style="border: 1px solid #ddd; padding: 8px; text-align: left; background-color: #f2f2f2;">Significant Difference?</th>
+                    </tr>
+                    """
+                    
+                    # Sentiment row
+                    if "sentiment" in comparative:
+                        sent_sig = comparative["sentiment"].get("significant", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px;">Sentiment Bias</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["sentiment"].get(model1_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["sentiment"].get(model2_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if sent_sig else 'green'}">{"Yes" if sent_sig else "No"}</td>
+                        </tr>
+                        """
+                    
+                    # Partisan row
+                    if "partisan" in comparative:
+                        part_sig = comparative["partisan"].get("significant", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px;">Partisan Leaning</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["partisan"].get(model1_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["partisan"].get(model2_name, "N/A").title()}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if part_sig else 'green'}">{"Yes" if part_sig else "No"}</td>
+                        </tr>
+                        """
+                    
+                    # Framing row
+                    if "framing" in comparative:
+                        frame_diff = comparative["framing"].get("different_frames", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px;">Dominant Frame</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["framing"].get(model1_name, "N/A").title().replace('_', ' ')}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px;">{comparative["framing"].get(model2_name, "N/A").title().replace('_', ' ')}</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if frame_diff else 'green'}">{"Yes" if frame_diff else "No"}</td>
+                        </tr>
+                        """
+                    
+                    # Overall row
+                    if "overall" in comparative:
+                        overall_sig = comparative["overall"].get("significant_bias_difference", False)
+                        summary_html += f"""
+                        <tr>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold;">Overall Bias Difference</td>
+                            <td colspan="2" style="border: 1px solid #ddd; padding: 8px; text-align: center;">{comparative["overall"].get("difference", 0):.2f} / 1.0</td>
+                            <td style="border: 1px solid #ddd; padding: 8px; font-weight: bold; color: {'red' if overall_sig else 'green'}">{"Yes" if overall_sig else "No"}</td>
+                        </tr>
+                        """
+                    
+                    summary_html += "</table>"
+                    
+                    # Add the HTML table to the components
+                    output_components.append(gr.HTML(summary_html))
+                
+                # Create detailed visualizations for each model if available
+                for model_name in [model1_name, model2_name]:
+                    if model_name in bias_results:
+                        model_data = bias_results[model_name]
+                        
+                        # Sentiment visualization
+                        if "sentiment" in model_data:
+                            sentiment = model_data["sentiment"]
+                            if "sentiment_scores" in sentiment:
+                                # Create sentiment score chart
+                                sentiment_df = pd.DataFrame({
+                                    'Score': [
+                                        sentiment["sentiment_scores"]["pos"],
+                                        sentiment["sentiment_scores"]["neg"],
+                                        sentiment["sentiment_scores"]["neu"]
+                                    ],
+                                    'Category': ['Positive', 'Negative', 'Neutral']
+                                })
+                                
+                                fig = px.bar(
+                                    sentiment_df,
+                                    x='Category',
+                                    y='Score',
+                                    title=f"Sentiment Analysis for {model_name}",
+                                    height=300
+                                )
+                                
+                                output_components.append(gr.Plot(value=fig))
+                        
+                        # Partisan leaning visualization
+                        if "partisan" in model_data:
+                            partisan = model_data["partisan"]
+                            if "liberal_count" in partisan and "conservative_count" in partisan:
+                                # Create partisan terms chart
+                                partisan_df = pd.DataFrame({
+                                    'Count': [partisan["liberal_count"], partisan["conservative_count"]],
+                                    'Category': ['Liberal Terms', 'Conservative Terms']
+                                })
+                                
+                                fig = px.bar(
+                                    partisan_df,
+                                    x='Category',
+                                    y='Count',
+                                    title=f"Partisan Term Usage for {model_name}",
+                                    color='Category',
+                                    color_discrete_map={
+                                        'Liberal Terms': 'blue',
+                                        'Conservative Terms': 'red'
+                                    },
+                                    height=300
+                                )
+                                
+                                output_components.append(gr.Plot(value=fig))
+                            
+                            # Show example partisan terms
+                            if "liberal_terms" in partisan or "conservative_terms" in partisan:
+                                lib_terms = ", ".join(partisan.get("liberal_terms", []))
+                                con_terms = ", ".join(partisan.get("conservative_terms", []))
+                                
+                                if lib_terms or con_terms:
+                                    terms_md = f"**Partisan Terms Used by {model_name}**\n\n"
+                                    if lib_terms:
+                                        terms_md += f"- Liberal terms: {lib_terms}\n"
+                                    if con_terms:
+                                        terms_md += f"- Conservative terms: {con_terms}\n"
+                                    
+                                    output_components.append(gr.Markdown(terms_md))
+                        
+                        # Framing visualization
+                        if "framing" in model_data:
+                            framing = model_data["framing"]
+                            if "framing_distribution" in framing:
+                                # Create framing distribution chart
+                                frame_items = []
+                                for frame, value in framing["framing_distribution"].items():
+                                    frame_items.append({
+                                        'Frame': frame.replace('_', ' ').title(),
+                                        'Proportion': value
+                                    })
+                                
+                                frame_df = pd.DataFrame(frame_items)
+                                
+                                fig = px.pie(
+                                    frame_df,
+                                    values='Proportion',
+                                    names='Frame',
+                                    title=f"Issue Framing Distribution for {model_name}",
+                                    height=400
+                                )
+                                
+                                output_components.append(gr.Plot(value=fig))
+                            
+                            # Show example framing terms
+                            if "framing_examples" in framing:
+                                examples_md = f"**Example Framing Terms Used by {model_name}**\n\n"
+                                for frame, examples in framing["framing_examples"].items():
+                                    if examples:
+                                        examples_md += f"- {frame.replace('_', ' ').title()}: {', '.join(examples)}\n"
+                                
+                                output_components.append(gr.Markdown(examples_md))
     
-    **Partisan Leaning:**
-    - Leaning: {partisan.get('leaning', 'balanced')}
-    - Strength: {partisan.get('strength', 0):.2f}/1.0
-    - Liberal terms: {', '.join(set(partisan.get('liberal_terms', [])))[:100]}
-    - Conservative terms: {', '.join(set(partisan.get('conservative_terms', [])))[:100]}
+    # If no components were added, show a message
+    if len(output_components) <= 1:
+        output_components.append(gr.Markdown("No detailed bias detection analysis found in results."))
     
-    **Framing Analysis:**
-    - Dominant frame: {framing.get('dominant_frame', 'none')}
-    - Frame strength: {framing.get('frame_bias_strength', 0):.2f}/1.0
-    """
-    
-    return summary
+    return output_components
 
-def create_comparative_summary(comparative, model1_name, model2_name):
-    """Create a text summary of the comparative bias analysis"""
-    if not comparative:
-        return "No comparative analysis available"
-    
-    sentiment = comparative.get("sentiment", {})
-    partisan = comparative.get("partisan", {})
-    framing = comparative.get("framing", {})
-    overall = comparative.get("overall", {})
-    
-    summary = f"""
-    **Overall Bias Difference:** {overall.get('difference', 0):.2f}
-    ({overall.get('significant_bias_difference', False) and 'Significant' or 'Not significant'})
-    
-    **Sentiment Comparison:**
-    - {model1_name}: {sentiment.get(model1_name, 'neutral')}
-    - {model2_name}: {sentiment.get(model2_name, 'neutral')}
-    - Difference: {sentiment.get('difference', 0):.2f} ({sentiment.get('significant', False) and 'Significant' or 'Not significant'})
-    
-    **Partisan Leaning Comparison:**
-    - {model1_name}: {partisan.get(model1_name, 'balanced')}
-    - {model2_name}: {partisan.get(model2_name, 'balanced')}
-    - Difference: {partisan.get('difference', 0):.2f} ({partisan.get('significant', False) and 'Significant' or 'Not significant'})
-    
-    **Framing Comparison:**
-    - {model1_name}: {framing.get(model1_name, 'none')}
-    - {model2_name}: {framing.get(model2_name, 'none')}
-    - Different frames: {framing.get('different_frames', False) and 'Yes' or 'No'}
+def process_and_visualize_bias_analysis(analysis_results):
     """
+    Process the bias detection analysis results and create visualization components
     
-    return summary
-
-def create_bias_visualizations_html(bias_results, model1_name, model2_name):
-    """Create HTML visualizations for bias analysis"""
+    Args:
+        analysis_results (dict): The analysis results
+        
+    Returns:
+        list: List of gradio components for visualization
+    """
     try:
-        # Placeholder for visualizations - you can extend this with actual plotly charts
-        html = f"""
-        <div style="padding: 20px;">
-            <h3>Bias Visualization</h3>
-            <p>Bias analysis visualization for {model1_name} and {model2_name}</p>
-            <div id="bias-charts"></div>
-        </div>
-        """
-        return html
+        print(f"Starting visualization of bias detection analysis results")
+        return create_bias_visualization(analysis_results)
     except Exception as e:
-        logger.error(f"Error creating bias HTML: {str(e)}")
-        return "<div>Error creating bias visualizations</div>"
+        import traceback
+        error_msg = f"Bias detection visualization error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return [gr.Markdown(f"**Error during bias detection visualization:**\n\n```\n{error_msg}\n```")]

visualization/topic_visualizer.py

@@ -1,6 +1,7 @@
 """
-Improved visualization for topic modeling analysis results
+Visualization for topic modeling analysis results
 """
+from visualization.ngram_visualizer import create_ngram_visualization
 import gradio as gr
 import json
 import numpy as np
@@ -8,11 +9,6 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
-import logging
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger('topic_visualizer')
 
 def create_topic_visualization(analysis_results):
     """
@@ -29,137 +25,124 @@ def create_topic_visualization(analysis_results):
     
     # Check if we have valid results
     if not analysis_results or "analyses" not in analysis_results:
-        logger.warning("No valid analysis results found")
         return [gr.Markdown("No analysis results found.")]
     
-    try:
-        # Process each prompt
-        for prompt, analyses in analysis_results["analyses"].items():
-            # Process Topic Modeling analysis if available
-            if "topic_modeling" in analyses:
-                topic_results = analyses["topic_modeling"]
-                
-                # Check for errors in the analysis
-                if "error" in topic_results:
-                    error_msg = topic_results.get("error", "Unknown error in topic modeling")
-                    logger.warning(f"Topic modeling error: {error_msg}")
-                    output_components.append(gr.Markdown(f"**Error in topic modeling analysis:** {error_msg}"))
-                    continue
-                
-                # Show method and number of topics
-                method = topic_results.get("method", "lda").upper()
-                n_topics = topic_results.get("n_topics", 3)
-                logger.info(f"Creating visualization for {method} with {n_topics} topics")
-                
-                # Get models being compared
-                models = topic_results.get("models", [])
-                if not models or len(models) < 2:
-                    logger.warning("Not enough models found in results")
-                    output_components.append(gr.Markdown("Topic modeling requires at least two models to compare."))
-                    continue
-                
-                output_components.append(gr.Markdown(f"### Topic Modeling Analysis ({method}, {n_topics} topics)"))
-                output_components.append(gr.Markdown(f"Comparing responses from **{models[0]}** and **{models[1]}**"))
+    # Process each prompt
+    for prompt, analyses in analysis_results["analyses"].items():
+        # Process Topic Modeling analysis if available
+        if "topic_modeling" in analyses:
+            topic_results = analyses["topic_modeling"]
+            
+            # Show method and number of topics
+            method = topic_results.get("method", "lda").upper()
+            n_topics = topic_results.get("n_topics", 3)
+            output_components.append(gr.Markdown(f"## Topic Modeling Analysis ({method}, {n_topics} topics)"))
+            
+            # Show models being compared
+            models = topic_results.get("models", [])
+            if len(models) >= 2:
+                output_components.append(gr.Markdown(f"### Comparing responses from {models[0]} and {models[1]}"))
                 
-                # Visualize discovered topics
+                # Visualize topics
                 topics = topic_results.get("topics", [])
                 if topics:
-                    output_components.append(gr.Markdown("#### Discovered Topics"))
+                    output_components.append(gr.Markdown("### Discovered Topics"))
                     
-                    # Display topics in a more readable format
-                    for i, topic in enumerate(topics):
-                        topic_id = topic.get("id", i)
+                    for topic in topics:
+                        topic_id = topic.get("id", 0)
                         words = topic.get("words", [])
-                        if words:
-                            topic_words = ", ".join(words[:5])  # Show top 5 words
-                            output_components.append(gr.Markdown(f"**Topic {topic_id+1}**: {topic_words}"))
+                        weights = topic.get("weights", [])
+                        
+                        # Create topic word bar chart
+                        if words and weights and len(words) == len(weights):
+                            # Create dataframe for plotting
+                            df = pd.DataFrame({
+                                'word': words,
+                                'weight': weights
+                            })
+                            
+                            # Sort by weight
+                            df = df.sort_values('weight', ascending=False)
+                            
+                            # Create bar chart
+                            fig = px.bar(
+                                df, x='word', y='weight',
+                                title=f"Topic {topic_id+1} Top Words",
+                                labels={'word': 'Word', 'weight': 'Weight'},
+                                height=300
+                            )
+                            
+                            output_components.append(gr.Plot(value=fig))
                 
                 # Visualize topic distributions for each model
                 model_topics = topic_results.get("model_topics", {})
                 if model_topics and all(model in model_topics for model in models):
-                    output_components.append(gr.Markdown("#### Topic Distribution by Model"))
+                    output_components.append(gr.Markdown("### Topic Distribution by Model"))
                     
-                    # Display topic distributions in a readable format
+                    # Create multi-model topic distribution comparison
+                    fig = go.Figure()
                     for model in models:
                         if model in model_topics:
-                            dist = model_topics[model]
-                            # Format the distribution
-                            dist_str = ", ".join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist[:n_topics])])
-                            output_components.append(gr.Markdown(f"**{model}**: {dist_str}"))
+                            distribution = model_topics[model]
+                            fig.add_trace(go.Bar(
+                                x=[f"Topic {i+1}" for i in range(len(distribution))],
+                                y=distribution,
+                                name=model
+                            ))
                     
-                    # Create multi-model topic distribution visualization
-                    try:
-                        # Prepare data for visualization
-                        model_data = []
-                        for model in models:
-                            if model in model_topics:
-                                dist = model_topics[model]
-                                for i, weight in enumerate(dist[:n_topics]):
-                                    model_data.append({
-                                        "Model": model,
-                                        "Topic": f"Topic {i+1}",
-                                        "Weight": weight
-                                    })
-                        
-                        if model_data:
-                            df = pd.DataFrame(model_data)
-                            
-                            # Create grouped bar chart
-                            fig = px.bar(
-                                df, 
-                                x="Topic", 
-                                y="Weight", 
-                                color="Model",
-                                title="Topic Distribution Comparison",
-                                barmode="group",
-                                height=400
-                            )
-                            
-                            fig.update_layout(
-                                xaxis_title="Topic",
-                                yaxis_title="Weight",
-                                legend_title="Model"
-                            )
-                            
-                            output_components.append(gr.Plot(value=fig))
-                    except Exception as e:
-                        logger.error(f"Error creating topic distribution plot: {str(e)}")
-                        output_components.append(gr.Markdown(f"*Error creating visualization: {str(e)}*"))
+                    fig.update_layout(
+                        title="Topic Distributions Comparison",
+                        xaxis_title="Topic",
+                        yaxis_title="Weight",
+                        barmode='group',
+                        height=400
+                    )
+                    
+                    output_components.append(gr.Plot(value=fig))
                 
-                # Display similarity metrics
+                # Visualize topic differences
                 comparisons = topic_results.get("comparisons", {})
                 if comparisons:
-                    output_components.append(gr.Markdown("#### Similarity Metrics"))
+                    output_components.append(gr.Markdown("### Topic Distribution Differences"))
                     
                     for comparison_key, comparison_data in comparisons.items():
-                        js_div = comparison_data.get("js_divergence", 0)
-                        
-                        # Jensen-Shannon divergence interpretation
-                        similarity_text = ""
-                        if js_div < 0.2:
-                            similarity_text = "very similar"
-                        elif js_div < 0.4:
-                            similarity_text = "somewhat similar"
-                        elif js_div < 0.6:
-                            similarity_text = "moderately different"
-                        else:
-                            similarity_text = "very different"
+                        js_divergence = comparison_data.get("js_divergence", 0)
+                        topic_differences = comparison_data.get("topic_differences", [])
                         
                         output_components.append(gr.Markdown(
-                            f"**Topic Distribution Divergence**: {js_div:.4f} - Topic distributions are {similarity_text}"
+                            f"**{comparison_key}** - Jensen-Shannon Divergence: {js_divergence:.4f}"
                         ))
                         
-                        # Explain what the metric means
-                        output_components.append(gr.Markdown(
-                            "*Lower divergence values indicate more similar topic distributions between models*"
-                        ))
-    
-    except Exception as e:
-        logger.error(f"Error in create_topic_visualization: {str(e)}")
-        output_components.append(gr.Markdown(f"**Error creating topic visualization:** {str(e)}"))
+                        if topic_differences:
+                            # Create DataFrame for plotting
+                            model1, model2 = comparison_key.split(" vs ")
+                            df_diff = pd.DataFrame(topic_differences)
+                            
+                            # Create bar chart for topic differences
+                            fig = go.Figure()
+                            fig.add_trace(go.Bar(
+                                x=[f"Topic {d['topic_id']+1}" for d in topic_differences],
+                                y=[d["model1_weight"] for d in topic_differences],
+                                name=model1
+                            ))
+                            fig.add_trace(go.Bar(
+                                x=[f"Topic {d['topic_id']+1}" for d in topic_differences],
+                                y=[d["model2_weight"] for d in topic_differences],
+                                name=model2
+                            ))
+                            
+                            fig.update_layout(
+                                title="Topic Weight Comparison",
+                                xaxis_title="Topic",
+                                yaxis_title="Weight",
+                                barmode='group',
+                                height=400
+                            )
+                            
+                            output_components.append(gr.Plot(value=fig))
     
     # If no components were added, show a message
-    if len(output_components) == 0:
+    if len(output_components) <= 1:
         output_components.append(gr.Markdown("No detailed Topic Modeling analysis found in results."))
     
     return output_components
@@ -176,23 +159,10 @@ def process_and_visualize_topic_analysis(analysis_results):
         list: List of gradio components for visualization
     """
     try:
-        logger.info(f"Starting visualization of topic modeling analysis results")
-        # Debug output - print the structure of analysis_results
-        if "analyses" in analysis_results:
-            for prompt, analyses in analysis_results["analyses"].items():
-                if "topic_modeling" in analyses:
-                    topic_results = analyses["topic_modeling"]
-                    logger.info(f"Found topic_modeling results with keys: {topic_results.keys()}")
-                    if "models" in topic_results:
-                        logger.info(f"Models: {topic_results['models']}")
-                    if "topics" in topic_results:
-                        logger.info(f"Found {len(topic_results['topics'])} topics")
-                    if "model_topics" in topic_results:
-                        logger.info(f"Model_topics keys: {topic_results['model_topics'].keys()}")
-        
+        print(f"Starting visualization of topic modeling analysis results")
         return create_topic_visualization(analysis_results)
     except Exception as e:
         import traceback
         error_msg = f"Topic modeling visualization error: {str(e)}\n{traceback.format_exc()}"
-        logger.error(error_msg)
+        print(error_msg)
         return [gr.Markdown(f"**Error during topic modeling visualization:**\n\n```\n{error_msg}\n```")]

visualization_handler.py

@@ -1,130 +0,0 @@
-import gradio as gr
-import logging
-
-# Set up logging
-logger = logging.getLogger('gradio_app.visualization_handler')
-
-
-def create_visualization_components():
-    """
-    Creates all the visualization components used in the analysis tab
-
-    Returns:
-        list: A list of all gradio components for visualization
-    """
-    # Pre-create visualization components (initially hidden)
-    visualization_area_visible = gr.Checkbox(value=False, visible=False, label="Visualization Visible")
-    analysis_title = gr.Markdown("## Analysis Results", visible=False)
-    prompt_title = gr.Markdown(visible=False)
-    models_compared = gr.Markdown(visible=False)
-
-    # Container for model 1 words
-    model1_title = gr.Markdown(visible=False)
-    model1_words = gr.Markdown(visible=False)
-
-    # Container for model 2 words
-    model2_title = gr.Markdown(visible=False)
-    model2_words = gr.Markdown(visible=False)
-
-    # Similarity metrics
-    similarity_metrics_title = gr.Markdown("### Similarity Metrics", visible=False)
-    similarity_metrics = gr.Markdown(visible=False)
-
-    # Status or error message area
-    status_message_visible = gr.Checkbox(value=False, visible=False, label="Status Message Visible")
-    status_message = gr.Markdown(visible=False)
-
-    # Create bias visualization container (initially hidden)
-    with gr.Column(visible=False) as bias_visualizations:
-        gr.Markdown("### Bias Analysis Visualizations")
-        bias_html = gr.HTML(visible=True)  # Add this line for bias HTML content
-
-    # Return all components as a list
-    return [
-        analysis_results_state := gr.State({}),
-        analysis_output := gr.JSON(visible=False),
-        visualization_area_visible,
-        analysis_title,
-        prompt_title,
-        models_compared,
-        model1_title,
-        model1_words,
-        model2_title,
-        model2_words,
-        similarity_metrics_title,
-        similarity_metrics,
-        status_message_visible,
-        status_message,
-        bias_visualizations,
-        bias_html  # Add this line to include in the returned components
-    ]
-
-
-def create_empty_visualization_response():
-    """
-    Creates an empty visualization response with the correct structure.
-    This is useful for error handling and default responses.
-    
-    Returns:
-        list: A list with empty values for all visualization components
-    """
-    return [
-        {},                      # analysis_results_state
-        {},                      # analysis_output
-        False,                   # visualization_area_visible
-        "",                      # analysis_title
-        "",                      # prompt_title
-        "",                      # models_compared
-        "",                      # model1_title
-        "",                      # model1_words
-        "",                      # model2_title
-        "",                      # model2_words
-        "",                      # similarity_metrics_title
-        "",                      # similarity_metrics
-        False,                   # status_message_visible
-        "",                      # status_message
-        gr.update(visible=False), # bias_visualizations
-        ""                       # bias_html - Add this line
-    ]
-
-
-def process_and_visualize_bias_analysis(analysis_results):
-    """
-    Wrapper for bias visualization function from visualization.bias_visualizer
-
-    Args:
-        analysis_results (dict): The analysis results
-
-    Returns:
-        list: Components for bias visualization
-    """
-    from visualization.bias_visualizer import process_and_visualize_bias_analysis
-    return process_and_visualize_bias_analysis(analysis_results)
-
-
-def process_and_visualize_ngram_analysis(analysis_results):
-    """
-    Wrapper for n-gram visualization function from visualization.ngram_visualizer
-
-    Args:
-        analysis_results (dict): The analysis results
-
-    Returns:
-        list: Components for n-gram visualization
-    """
-    from visualization.ngram_visualizer import process_and_visualize_ngram_analysis
-    return process_and_visualize_ngram_analysis(analysis_results)
-
-
-def process_and_visualize_topic_analysis(analysis_results):
-    """
-    Wrapper for topic modeling visualization function from visualization.topic_visualizer
-
-    Args:
-        analysis_results (dict): The analysis results
-
-    Returns:
-        list: Components for topic visualization
-    """
-    from visualization.topic_visualizer import process_and_visualize_topic_analysis
-    return process_and_visualize_topic_analysis(analysis_results)