update

app.py

@@ -1,12 +1,27 @@
 import gradio as gr
 from ui.dataset_input import create_dataset_input, load_example_dataset
-from ui.analysis_screen import create_analysis_screen, process_analysis_request
+from ui.analysis_screen import create_analysis_screen
 from visualization.bow_visualizer import process_and_visualize_analysis
 import nltk
 import os
-import json
+import logging
+import sys
+import traceback
 
-# Download necessary NLTK resources function remains unchanged
+# 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
+
+# Download necessary NLTK resources
 def download_nltk_resources():
     """Download required NLTK resources if not already downloaded"""
     try:
@@ -33,25 +48,25 @@ def download_nltk_resources():
                 for location in locations:
                     try:
                         nltk.data.find(location)
-                        print(f"Resource {resource} already downloaded")
+                        logger.info(f"Resource {resource} already downloaded")
                         found = True
                         break
                     except LookupError:
                         continue
                 
                 if not found:
-                    print(f"Downloading {resource}...")
+                    logger.info(f"Downloading {resource}...")
                     nltk.download(resource, quiet=True)
             except Exception as e:
-                print(f"Error with resource {resource}: {e}")
+                logger.error(f"Error with resource {resource}: {e}")
         
-        print("NLTK resources check completed")
+        logger.info("NLTK resources check completed")
     except Exception as e:
-        print(f"Error downloading NLTK resources: {e}")
+        logger.error(f"Error downloading NLTK resources: {e}")
 
 def create_app():
     """
-    Create a streamlined Gradio app for dataset input and Bag of Words analysis. 
+    Create a streamlined Gradio app for dataset input and analysis. 
     
     Returns:
         gr.Blocks: The Gradio application
@@ -97,7 +112,7 @@ def create_app():
         # Analysis Tab
         with gr.Tab("Analysis"):
             # Use create_analysis_screen to get UI components including visualization container
-            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count, bias_methods = create_analysis_screen()
+            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count = create_analysis_screen()
             
             # Pre-create visualization components (initially hidden)
             visualization_area_visible = gr.Checkbox(value=False, visible=False, label="Visualization Visible")
@@ -122,7 +137,7 @@ def create_app():
             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):
+            def run_analysis(dataset, selected_analysis, bow_top, ngram_n, ngram_top, topic_count):
                 try:
                     if not dataset or "entries" not in dataset or not dataset["entries"]:
                         return (
@@ -146,11 +161,10 @@ def create_app():
                         "bow_top": bow_top,
                         "ngram_n": ngram_n,
                         "ngram_top": ngram_top,
-                        "topic_count": topic_count,
-                        "bias_methods": bias_methods  # Add this parameter
+                        "topic_count": topic_count
                     }
-                    print(f"Running analysis with selected type: {selected_analysis}")
-                    print("Parameters:", parameters)
+                    logger.info(f"Running analysis with selected type: {selected_analysis}")
+                    logger.info(f"Parameters: {parameters}")
                     
                     # Process the analysis request - passing selected_analysis as a string
                     analysis_results, _ = process_analysis_request(dataset, selected_analysis, parameters)
@@ -326,10 +340,30 @@ def create_app():
                                     - **Common {size_name}**: {common_count} {size_name.lower()} appear in both responses
                                     """
                     
-                    # Check for Topic Modeling analysis
+                    # Check for Topic Modeling analysis - IMPROVED HANDLING
                     elif selected_analysis == "Topic Modeling" and "topic_modeling" in analyses:
                         visualization_area_visible = True
                         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']}")
+                            )
+                        
                         models = topic_results.get("models", [])
                         method = topic_results.get("method", "lda").upper()
                         n_topics = topic_results.get("n_topics", 3)
@@ -347,7 +381,7 @@ def create_app():
                             if topics:
                                 # Format topic info for display
                                 topic_info = []
-                                for topic in topics[:3]:  # Show first 3 topics
+                                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
                                     
@@ -378,9 +412,9 @@ def create_app():
                                     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])])}
+                                    **{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[:3])])}
+                                    **{model2_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist2[:5])])}
                                     """
                                     
                             # Add similarity metrics if available
@@ -392,10 +426,23 @@ def create_app():
                                     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} (lower means more similar topic distributions)
+                                    - **Topic Distribution Divergence**: {js_div:.4f}
+                                    - The topic distributions between models are **{similarity_text}**
+                                    - *Lower divergence values indicate more similar topic distributions*
                                     """
                     
                     # Check for Classifier analysis
@@ -448,101 +495,6 @@ def create_app():
                                     f"- **{category}**: {diff}" 
                                     for category, diff in differences.items()
                                 ])
-
-                    # 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:
@@ -584,7 +536,7 @@ def create_app():
                 except Exception as e:
                     import traceback
                     error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
-                    print(error_msg)
+                    logger.error(error_msg)
                     
                     return (
                         {"error": error_msg},  # analysis_results_state
@@ -602,80 +554,28 @@ def create_app():
                         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_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_btn.click(
+                fn=run_analysis,
+                inputs=[dataset_state, analysis_options, bow_top_slider, ngram_n, ngram_top, topic_count],
+                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
+                ]
             )
-
-        # 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
 
@@ -683,5 +583,9 @@ 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()

improved_analysis_handler.py

@@ -0,0 +1,186 @@
+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
+
+# 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)
+            }
+        
+        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/topic_modeling.py

@@ -1,5 +1,6 @@
 """
-Topic modeling processor for comparing text responses
+Enhanced topic modeling processor for comparing text responses with better error handling
+and more robust algorithm configuration
 """
 from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
 from sklearn.decomposition import LatentDirichletAllocation, NMF
@@ -7,6 +8,12 @@ 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):
     """
@@ -18,20 +25,25 @@ def preprocess_text(text):
     Returns:
         str: Preprocessed 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)
+    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
 
 def get_top_words_per_topic(model, feature_names, n_top_words=10):
     """
@@ -70,6 +82,14 @@ 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,
@@ -77,45 +97,102 @@ def extract_topics(texts, n_topics=3, n_top_words=10, method="lda"):
         "document_topics": []
     }
     
-    # Preprocess texts
-    preprocessed_texts = [preprocess_text(text) for text in texts]
-    
-    # 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)
-    
-    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)
+    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)}"
     
-    topic_distribution = model.fit_transform(X)
+    return result
+
+def calculate_jensen_shannon_divergence(p, q):
+    """
+    Calculate Jensen-Shannon divergence between two probability distributions
     
-    # Get top words for each topic
-    result["topics"] = get_top_words_per_topic(model, feature_names, n_top_words)
+    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)
     
-    # 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()
-        })
+    # 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
     
-    return result
+    # Calculate Jensen-Shannon divergence
+    m = 0.5 * (p + q)
+    return 0.5 * (distance.jensenshannon(p, m) + distance.jensenshannon(q, m))
 
 def compare_topics(texts_set_1, texts_set_2, n_topics=3, n_top_words=10, method="lda", model_names=None):
     """
@@ -132,50 +209,98 @@ 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"]
     
-    # 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
+    # Initialize the result structure
     result = {
         "method": method,
         "n_topics": n_topics,
-        "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
+        "models": model_names,
+        "model_topics": {},
+        "topics": [],
+        "comparisons": {}
     }
     
-    return 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

visualization/topic_visualizer.py

@@ -1,7 +1,6 @@
 """
-Visualization for topic modeling analysis results
+Improved visualization for topic modeling analysis results
 """
-from visualization.ngram_visualizer import create_ngram_visualization
 import gradio as gr
 import json
 import numpy as np
@@ -9,6 +8,11 @@ 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):
     """
@@ -25,124 +29,137 @@ 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.")]
     
-    # 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]}"))
+    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]}**"))
                 
-                # Visualize topics
+                # Visualize discovered topics
                 topics = topic_results.get("topics", [])
                 if topics:
-                    output_components.append(gr.Markdown("### Discovered Topics"))
+                    output_components.append(gr.Markdown("#### Discovered Topics"))
                     
-                    for topic in topics:
-                        topic_id = topic.get("id", 0)
+                    # Display topics in a more readable format
+                    for i, topic in enumerate(topics):
+                        topic_id = topic.get("id", i)
                         words = topic.get("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))
+                        if words:
+                            topic_words = ", ".join(words[:5])  # Show top 5 words
+                            output_components.append(gr.Markdown(f"**Topic {topic_id+1}**: {topic_words}"))
                 
                 # 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"))
                     
-                    # Create multi-model topic distribution comparison
-                    fig = go.Figure()
+                    # Display topic distributions in a readable format
                     for model in models:
                         if model in model_topics:
-                            distribution = model_topics[model]
-                            fig.add_trace(go.Bar(
-                                x=[f"Topic {i+1}" for i in range(len(distribution))],
-                                y=distribution,
-                                name=model
-                            ))
-                    
-                    fig.update_layout(
-                        title="Topic Distributions Comparison",
-                        xaxis_title="Topic",
-                        yaxis_title="Weight",
-                        barmode='group',
-                        height=400
-                    )
-                    
-                    output_components.append(gr.Plot(value=fig))
-                
-                # Visualize topic differences
-                comparisons = topic_results.get("comparisons", {})
-                if comparisons:
-                    output_components.append(gr.Markdown("### Topic Distribution Differences"))
+                            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}"))
                     
-                    for comparison_key, comparison_data in comparisons.items():
-                        js_divergence = comparison_data.get("js_divergence", 0)
-                        topic_differences = comparison_data.get("topic_differences", [])
+                    # 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
+                                    })
                         
-                        output_components.append(gr.Markdown(
-                            f"**{comparison_key}** - Jensen-Shannon Divergence: {js_divergence:.4f}"
-                        ))
-                        
-                        if topic_differences:
-                            # Create DataFrame for plotting
-                            model1, model2 = comparison_key.split(" vs ")
-                            df_diff = pd.DataFrame(topic_differences)
+                        if model_data:
+                            df = pd.DataFrame(model_data)
                             
-                            # 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
-                            ))
+                            # 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(
-                                title="Topic Weight Comparison",
                                 xaxis_title="Topic",
                                 yaxis_title="Weight",
-                                barmode='group',
-                                height=400
+                                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)}*"))
+                
+                # Display similarity metrics
+                comparisons = topic_results.get("comparisons", {})
+                if comparisons:
+                    output_components.append(gr.Markdown("#### Similarity Metrics"))
+                    
+                    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"
+                        
+                        output_components.append(gr.Markdown(
+                            f"**Topic Distribution Divergence**: {js_div:.4f} - Topic distributions are {similarity_text}"
+                        ))
+                        
+                        # 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 no components were added, show a message
-    if len(output_components) <= 1:
+    if len(output_components) == 0:
         output_components.append(gr.Markdown("No detailed Topic Modeling analysis found in results."))
     
     return output_components
@@ -159,10 +176,23 @@ def process_and_visualize_topic_analysis(analysis_results):
         list: List of gradio components for visualization
     """
     try:
-        print(f"Starting visualization of topic modeling analysis results")
+        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()}")
+        
         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()}"
-        print(error_msg)
+        logger.error(error_msg)
         return [gr.Markdown(f"**Error during topic modeling visualization:**\n\n```\n{error_msg}\n```")]