update

app.py

@@ -97,7 +97,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 = 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 +122,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_analyses, bow_top, ngram_n, ngram_top):
+            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 (
@@ -145,12 +145,14 @@ def create_app():
                     parameters = {
                         "bow_top": bow_top,
                         "ngram_n": ngram_n,
-                        "ngram_top": ngram_top
+                        "ngram_top": ngram_top,
+                        "topic_count": topic_count
                     }
-                    print("Running analysis with parameters:", parameters)
+                    print(f"Running analysis with selected type: {selected_analysis}")
+                    print("Parameters:", parameters)
                     
-                    # Process the analysis request
-                    analysis_results, _ = process_analysis_request(dataset, selected_analyses, 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"]:
@@ -168,7 +170,7 @@ def create_app():
                             gr.update(visible=False),
                             gr.update(visible=False),
                             True,
-                            gr.update(visible=True, value="❌ **No results found.** Try different analysis options.")
+                            gr.update(visible=True, value="❌ **No results found.** Try a different analysis option.")
                         )
                     
                     # Extract information to display in components
@@ -196,8 +198,27 @@ def create_app():
                     similarity_metrics_visible = False
                     similarity_metrics_value = ""
                     
-                    # Check for Bag of Words analysis
-                    if "bag_of_words" in analyses:
+                    # 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", [])
@@ -252,8 +273,8 @@ def create_app():
                                 - **Common Words**: {common_words} words appear in both responses
                                 """
                                 
-                    # Check for N-gram analysis (if not found, we'll fallback to BOW)
-                    if "ngram_analysis" in analyses and not visualization_area_visible:
+                    # 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", [])
@@ -304,6 +325,129 @@ def create_app():
                                     - **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()
+                                ])
+                    
                     # If we don't have visualization data from any analysis
                     if not visualization_area_visible:
                         return (
@@ -320,7 +464,7 @@ def create_app():
                             gr.update(visible=False),
                             gr.update(visible=False),
                             True,
-                            gr.update(visible=True, value="❌ **No visualization data found.** Make sure to select at least one analysis type.")
+                            gr.update(visible=True, value="❌ **No visualization data found.** Make sure to select a valid analysis option.")
                         )
 
                     # Return all updated component values
@@ -362,61 +506,80 @@ def create_app():
                         True,  # status_message_visible
                         gr.update(visible=True, value=f"❌ **Error during analysis:**\n\n```\n{str(e)}\n```")  # status_message
                     )
-
-            # Function to update visibility based on checkbox state
-            def update_visibility(viz_visible, status_visible):
-                return [
-                    gr.update(visible=viz_visible),  # analysis_title
-                    gr.update(visible=viz_visible),  # prompt_title
-                    gr.update(visible=viz_visible),  # models_compared
-                    gr.update(visible=viz_visible),  # model1_title
-                    gr.update(visible=viz_visible),  # model1_words
-                    gr.update(visible=viz_visible),  # model2_title
-                    gr.update(visible=viz_visible),  # model2_words
-                    gr.update(visible=viz_visible),  # similarity_metrics_title
-                    gr.update(visible=viz_visible),  # similarity_metrics
-                    gr.update(visible=status_visible)  # status_message
-                ]
-
-            # Connect visibility checkboxes to update function
-            visualization_area_visible.change(
-                fn=update_visibility,
-                inputs=[visualization_area_visible, status_message_visible],
-                outputs=[
-                    analysis_title,
-                    prompt_title,
-                    models_compared,
-                    model1_title,
-                    model1_words,
-                    model2_title,
-                    model2_words,
-                    similarity_metrics_title,
-                    similarity_metrics,
-                    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 with proper parameters
-            run_analysis_btn.click(
-                fn=run_analysis,
-                inputs=[dataset_state, analysis_options, bow_top_slider, ngram_n, ngram_top],
-                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],
+            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
 
@@ -425,4 +588,4 @@ if __name__ == "__main__":
     download_nltk_resources()
     
     app = create_app()
-    app.launch()
+    app.launch()

processors/ngram_analysis.py

@@ -52,7 +52,18 @@ def compare_ngrams(texts, model_names, n=2, top_n=25):
             stop_words='english'
         )
 
-        X = vectorizer.fit_transform(texts)
+        # Make sure texts are strings before processing
+        processed_texts = []
+        for text in texts:
+            # If text is not a string (e.g., it's a list), convert it to a string
+            if not isinstance(text, str):
+                if isinstance(text, list):
+                    text = ' '.join(text)  # Join list elements if it's a list
+                else:
+                    text = str(text)  # Convert to string if it's another type
+            processed_texts.append(text)
+
+        X = vectorizer.fit_transform(processed_texts)
 
         # Get feature names (n-grams)
         feature_names = vectorizer.get_feature_names_out()

processors/text_classifiers.py

@@ -0,0 +1,152 @@
+import nltk
+from nltk.sentiment import SentimentIntensityAnalyzer
+import statistics
+import re
+
+def download_nltk_resources():
+    """Download required NLTK resources if not already downloaded"""
+    try:
+        nltk.download('vader_lexicon', quiet=True)
+    except:
+        pass
+
+# Ensure NLTK resources are available
+download_nltk_resources()
+
+def classify_formality(text):
+    """
+    Classify text formality based on simple heuristics
+    
+    Args:
+        text (str): Text to analyze
+        
+    Returns:
+        str: Formality level (Formal, Neutral, or Informal)
+    """
+    # Simple formality indicators
+    formal_indicators = [
+        r'\b(therefore|thus|consequently|furthermore|moreover|however)\b',
+        r'\b(in accordance with|with respect to|regarding|concerning)\b',
+        r'\b(shall|must|may|will be required to)\b',
+        r'\b(it is|there are|there is)\b',
+        r'\b(Mr\.|Ms\.|Dr\.|Prof\.)\b'
+    ]
+    
+    informal_indicators = [
+        r'\b(like|yeah|cool|awesome|gonna|wanna|gotta)\b',
+        r'(\!{2,}|\?{2,})',
+        r'\b(lol|haha|wow|omg|btw)\b',
+        r'\b(don\'t|can\'t|won\'t|shouldn\'t)\b',
+        r'(\.{3,})'
+    ]
+    
+    # Calculate scores
+    formal_score = sum([len(re.findall(pattern, text, re.IGNORECASE)) for pattern in formal_indicators])
+    informal_score = sum([len(re.findall(pattern, text, re.IGNORECASE)) for pattern in informal_indicators])
+    
+    # Normalize by text length
+    words = len(text.split())
+    if words > 0:
+        formal_score = formal_score / (words / 100)  # per 100 words
+        informal_score = informal_score / (words / 100)  # per 100 words
+    
+    # Determine formality
+    if formal_score > informal_score * 1.5:
+        return "Formal"
+    elif informal_score > formal_score * 1.5:
+        return "Informal"
+    else:
+        return "Neutral"
+
+def classify_sentiment(text):
+    """
+    Classify text sentiment using NLTK's VADER
+    
+    Args:
+        text (str): Text to analyze
+        
+    Returns:
+        str: Sentiment (Positive, Neutral, or Negative)
+    """
+    try:
+        sia = SentimentIntensityAnalyzer()
+        sentiment = sia.polarity_scores(text)
+        
+        if sentiment['compound'] >= 0.05:
+            return "Positive"
+        elif sentiment['compound'] <= -0.05:
+            return "Negative"
+        else:
+            return "Neutral"
+    except:
+        return "Neutral"
+
+def classify_complexity(text):
+    """
+    Classify text complexity based on sentence length and word length
+    
+    Args:
+        text (str): Text to analyze
+        
+    Returns:
+        str: Complexity level (Simple, Average, or Complex)
+    """
+    # Split into sentences
+    sentences = nltk.sent_tokenize(text)
+    
+    if not sentences:
+        return "Average"
+    
+    # Calculate average sentence length
+    sentence_lengths = [len(s.split()) for s in sentences]
+    avg_sentence_length = statistics.mean(sentence_lengths) if sentence_lengths else 0
+    
+    # Calculate average word length
+    words = [word for sentence in sentences for word in nltk.word_tokenize(sentence) 
+             if word.isalnum()]  # only consider alphanumeric tokens
+    
+    avg_word_length = statistics.mean([len(word) for word in words]) if words else 0
+    
+    # Determine complexity
+    if avg_sentence_length > 20 or avg_word_length > 6:
+        return "Complex"
+    elif avg_sentence_length < 12 or avg_word_length < 4:
+        return "Simple"
+    else:
+        return "Average"
+
+def compare_classifications(text1, text2):
+    """
+    Compare classifications between two texts
+    
+    Args:
+        text1 (str): First text
+        text2 (str): Second text
+        
+    Returns:
+        dict: Comparison results
+    """
+    formality1 = classify_formality(text1)
+    formality2 = classify_formality(text2)
+    
+    sentiment1 = classify_sentiment(text1)
+    sentiment2 = classify_sentiment(text2)
+    
+    complexity1 = classify_complexity(text1)
+    complexity2 = classify_complexity(text2)
+    
+    results = {}
+    
+    if formality1 != formality2:
+        results["Formality"] = f"Model 1 is {formality1.lower()}, while Model 2 is {formality2.lower()}"
+    
+    if sentiment1 != sentiment2:
+        results["Sentiment"] = f"Model 1 has a {sentiment1.lower()} tone, while Model 2 has a {sentiment2.lower()} tone"
+    
+    if complexity1 != complexity2:
+        results["Complexity"] = f"Model 1 uses {complexity1.lower()} language, while Model 2 uses {complexity2.lower()} language"
+    
+    if not results:
+        results["Summary"] = "Both responses have similar writing characteristics"
+    
+    return results

ui/analysis_screen.py

@@ -3,40 +3,35 @@ import json
 from visualization.bow_visualizer import process_and_visualize_analysis
 
 # Import analysis modules
-# Uncomment these when implemented
-# from processors.topic_modeling import extract_topics, compare_topics
+from processors.topic_modeling import compare_topics
 from processors.ngram_analysis import compare_ngrams
-# from processors.bias_detection import compare_bias
 from processors.bow_analysis import compare_bow
-# from processors.metrics import calculate_similarity
-# from processors.diff_highlighter import highlight_differences
+from processors.text_classifiers import classify_formality, classify_sentiment, classify_complexity, compare_classifications
 
 def create_analysis_screen():
     """
     Create the analysis options screen
     
     Returns:
-        tuple: (analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top)
+        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")
-        gr.Markdown("Select which analyses you want to run on the LLM responses.")
+        gr.Markdown("Select which analysis you want to run on the LLM responses.")
         
-        # Analysis selection
+        # Change from CheckboxGroup to Radio for analysis selection
         with gr.Group():
-            analysis_options = gr.CheckboxGroup(
+            analysis_options = gr.Radio(
                 choices=[
-                    "Topic Modeling",
+                    "Bag of Words",
                     "N-gram Analysis",
+                    "Topic Modeling",
                     "Bias Detection",
-                    "Bag of Words",
-                    "Similarity Metrics",
-                    "Difference Highlighting"
-                ],
-                value=[
-                    "Bag of Words",
+                    "Classifier"
+                    # Removed "LLM Analysis" as requested
                 ],
-                label="Select Analyses to Run"
+                value="Bag of Words",  # Default selection
+                label="Select Analysis Type"
             )
         
         # Create slider directly here for easier access
@@ -59,13 +54,19 @@ def create_analysis_screen():
             visible=False
         )
         
+        # Create topic modeling parameter accessible at top level
+        topic_count = gr.Slider(
+            minimum=2, maximum=10, value=3, step=1,
+            label="Number of Topics",
+            visible=False
+        )
+        
         # Parameters for each analysis type
         with gr.Group() as analysis_params:
             # Topic modeling parameters
             with gr.Group(visible=False) as topic_params:
                 gr.Markdown("### Topic Modeling Parameters")
-                topic_count = gr.Slider(minimum=2, maximum=10, value=3, step=1, 
-                                       label="Number of Topics")
+                # We'll use the topic_count defined above
             
             # N-gram parameters group (using external ngram_n and ngram_top)
             with gr.Group(visible=False) as ngram_params:
@@ -81,32 +82,38 @@ def create_analysis_screen():
                     label="Bias Detection Methods"
                 )
             
-            # Similarity metrics parameters
-            with gr.Group(visible=False) as similarity_params:
-                gr.Markdown("### Similarity Metrics Parameters")
-                similarity_metrics = gr.CheckboxGroup(
-                    choices=["Cosine Similarity", "Jaccard Similarity", "Semantic Similarity"],
-                    value=["Cosine Similarity", "Semantic Similarity"],
-                    label="Similarity Metrics to Calculate"
-                )
+            # Classifier parameters
+            with gr.Group(visible=False) as classifier_params:
+                gr.Markdown("### Classifier Parameters")
+                gr.Markdown("Classifies responses based on formality, sentiment, and complexity")
                 
-            # Function to update parameter visibility based on selected analyses
+            # Function to update parameter visibility based on selected analysis
             def update_params_visibility(selected):
-                ngram_visible = "N-gram Analysis" in selected
                 return {
-                    topic_params: gr.update(visible="Topic Modeling" in selected),
-                    ngram_params: gr.update(visible=ngram_visible),
-                    bias_params: gr.update(visible="Bias Detection" in selected),
-                    similarity_params: gr.update(visible="Similarity Metrics" in selected),
-                    ngram_n: gr.update(visible=ngram_visible),
-                    ngram_top: gr.update(visible=ngram_visible)
+                    topic_params: gr.update(visible=selected == "Topic Modeling"),
+                    ngram_params: gr.update(visible=selected == "N-gram Analysis"),
+                    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
             analysis_options.change(
                 fn=update_params_visibility,
                 inputs=[analysis_options],
-                outputs=[topic_params, ngram_params, bias_params, similarity_params, ngram_n, ngram_top]
+                outputs=[
+                    topic_params, 
+                    ngram_params, 
+                    bias_params, 
+                    classifier_params,
+                    ngram_n, 
+                    ngram_top, 
+                    topic_count,
+                    bow_top_slider
+                ]
             )
         
         # Run analysis button
@@ -116,54 +123,308 @@ def create_analysis_screen():
         analysis_output = gr.JSON(label="Analysis Results", visible=False)
     
     # Return the components needed by app.py
-    return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top
+    return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count
 
-# Process analysis request function
-def process_analysis_request(dataset, selected_analyses, parameters):
+# Add the implementation of these helper functions
+def extract_important_words(text, top_n=20):
     """
-    Process the analysis request and run selected analyses
+    Extract the most important words from a text.
+    
+    Args:
+        text (str): Input text
+        top_n (int): Number of top words to return
+        
+    Returns:
+        list: List of important words with their counts
     """
+    # Import necessary modules
+    from collections import Counter
+    import re
+    import nltk
+    from nltk.corpus import stopwords
+    from nltk.tokenize import word_tokenize
+    
+    # Make sure nltk resources are available
     try:
-        print(f"Processing analysis request with: {selected_analyses}")
-        print(f"Parameters: {parameters}")
-
-        if not dataset or "entries" not in dataset or not dataset["entries"]:
-            return {}, gr.update(visible=True,
-                                 value=json.dumps({"error": "No dataset provided or dataset is empty"}, indent=2))
-
-        analysis_results = {"analyses": {}}
-
-        # Extract prompt and responses
-        prompt = dataset["entries"][0]["prompt"]
-        response_texts = [entry["response"] for entry in dataset["entries"]]
-        model_names = [entry["model"] for entry in dataset["entries"]]
-
-        print(f"Analyzing prompt: '{prompt[:50]}...'")
-        print(f"Models: {model_names}")
+        stop_words = set(stopwords.words('english'))
+    except:
+        nltk.download('stopwords')
+        stop_words = set(stopwords.words('english'))
+    
+    try:
+        tokens = word_tokenize(text.lower())
+    except:
+        nltk.download('punkt')
+        tokens = word_tokenize(text.lower())
+    
+    # Remove stopwords and non-alphabetic tokens
+    filtered_tokens = [word for word in tokens if word.isalpha() and word not in stop_words and len(word) > 2]
+    
+    # Count word frequencies
+    word_counts = Counter(filtered_tokens)
+    
+    # Get the top N words
+    top_words = word_counts.most_common(top_n)
+    
+    # Format the result
+    result = [{"word": word, "count": count} for word, count in top_words]
+    
+    return result
 
-        analysis_results["analyses"][prompt] = {}
+def calculate_text_similarity(text1, text2):
+    """
+    Calculate similarity metrics between two texts.
+    
+    Args:
+        text1 (str): First text
+        text2 (str): Second text
+        
+    Returns:
+        dict: Similarity metrics
+    """
+    from processors.metrics import calculate_similarity
+    
+    # Calculate similarity using the metrics module
+    metrics = calculate_similarity(text1, text2)
+    
+    # Add common word count
+    from collections import Counter
+    import nltk
+    from nltk.corpus import stopwords
+    
+    # Make sure nltk resources are available
+    try:
+        stop_words = set(stopwords.words('english'))
+    except:
+        nltk.download('stopwords')
+        stop_words = set(stopwords.words('english'))
+    
+    # Simple tokenization and filtering
+    words1 = set([w.lower() for w in nltk.word_tokenize(text1) 
+                if w.isalpha() and w.lower() not in stop_words])
+    words2 = set([w.lower() for w in nltk.word_tokenize(text2) 
+                if w.isalpha() and w.lower() not in stop_words])
+    
+    # Calculate common words
+    common_words = words1.intersection(words2)
+    
+    # Add to metrics
+    metrics["common_word_count"] = len(common_words)
+    
+    return metrics
 
-        # Run Bag of Words analysis if selected
-        if "Bag of Words" in selected_analyses:
-            top_words = parameters.get("bow_top", 25)
-            print(f"Running BOW analysis with top_words={top_words}")
-            bow_results = compare_bow(response_texts, model_names, top_words)
-            analysis_results["analyses"][prompt]["bag_of_words"] = bow_results
+def extract_ngrams(text, n=2, top_n=10):
+    """
+    Extract the most common n-grams from text.
+    
+    Args:
+        text (str): Input text
+        n (int or str): Size of n-grams
+        top_n (int): Number of top n-grams to return
+        
+    Returns:
+        list: List of important n-grams with their counts
+    """
+    import nltk
+    from nltk.util import ngrams
+    from collections import Counter
+    
+    # Convert n to int if it's a string
+    if isinstance(n, str):
+        n = int(n)
+    
+    # Make sure nltk resources are available
+    try:
+        tokens = nltk.word_tokenize(text.lower())
+    except:
+        nltk.download('punkt')
+        tokens = nltk.word_tokenize(text.lower())
+    
+    # Generate n-grams
+    n_grams = list(ngrams(tokens, n))
+    
+    # Convert n-grams to strings for easier handling
+    n_gram_strings = [' '.join(gram) for gram in n_grams]
+    
+    # Count n-gram frequencies
+    n_gram_counts = Counter(n_gram_strings)
+    
+    # Get the top N n-grams
+    top_n_grams = n_gram_counts.most_common(top_n)
+    
+    # Format the result
+    result = [{"ngram": ngram, "count": count} for ngram, count in top_n_grams]
+    
+    return result
 
-        # Run N-gram analysis if selected
-        if "N-gram Analysis" in selected_analyses:
-            ngram_n = int(parameters.get("ngram_n", "2"))
-            ngram_top = parameters.get("ngram_top", 10)
-            print(f"Running N-gram analysis with n={ngram_n}, top_n={ngram_top}")
-            ngram_results = compare_ngrams(response_texts, model_names, ngram_n, ngram_top)
-            analysis_results["analyses"][prompt]["ngram_analysis"] = ngram_results
+def compare_ngrams(text1, text2, n=2):
+    """
+    Compare n-grams between two texts.
+    
+    Args:
+        text1 (str): First text
+        text2 (str): Second text
+        n (int or str): Size of n-grams
+        
+    Returns:
+        dict: Comparison metrics
+    """
+    import nltk
+    from nltk.util import ngrams
+    from collections import Counter
+    
+    # Convert n to int if it's a string
+    if isinstance(n, str):
+        n = int(n)
+    
+    # Make sure nltk resources are available
+    try:
+        tokens1 = nltk.word_tokenize(text1.lower())
+        tokens2 = nltk.word_tokenize(text2.lower())
+    except:
+        nltk.download('punkt')
+        tokens1 = nltk.word_tokenize(text1.lower())
+        tokens2 = nltk.word_tokenize(text2.lower())
+    
+    # Generate n-grams
+    n_grams1 = set([' '.join(gram) for gram in ngrams(tokens1, n)])
+    n_grams2 = set([' '.join(gram) for gram in ngrams(tokens2, n)])
+    
+    # Calculate common n-grams
+    common_n_grams = n_grams1.intersection(n_grams2)
+    
+    # Return comparison metrics
+    return {
+        "common_ngram_count": len(common_n_grams)
+    }
 
-        print("Analysis complete - results:", analysis_results)
+def perform_topic_modeling(texts, model_names, n_topics=3):
+    """
+    Perform topic modeling on a list of texts.
+    
+    Args:
+        texts (list): List of text documents
+        model_names (list): Names of the models
+        n_topics (int): Number of topics to extract
+        
+    Returns:
+        dict: Topic modeling results
+    """
+    from processors.topic_modeling import compare_topics
+    
+    # Use the topic modeling processor
+    result = compare_topics(texts, model_names, n_topics=n_topics)
+    
+    return result
 
-        # Return results and update the output component
-        return analysis_results, gr.update(visible=False, value=analysis_results)  # Hide the raw JSON
-    except Exception as e:
-        import traceback
-        error_msg = f"Analysis error: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return {}, gr.update(visible=True, value=json.dumps({"error": error_msg}, indent=2))
+# Process analysis request function
+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)
+    """
+    if not dataset or "entries" not in dataset or not dataset["entries"]:
+        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:
+        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", "")
+    
+    # Process based on the selected analysis type
+    if selected_analysis == "Bag of Words":
+        # Perform Bag of Words analysis using the processor
+        bow_results = compare_bow(
+            [model1_response, model2_response],
+            [model1_name, model2_name],
+            top_n=parameters.get("bow_top", 25)
+        )
+        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)
+        
+        # Use the processor
+        ngram_results = compare_ngrams(
+            [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)
+        
+        try:
+            topic_results = compare_topics(
+                [model1_response, model2_response], 
+                model_names=[model1_name, model2_name],
+                n_topics=topic_count
+            )
+            
+            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],
+                "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)
+        }
+    
+    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

visualization/bow_visualizer.py

@@ -8,6 +8,7 @@ import pandas as pd
 from difflib import SequenceMatcher
 
 from visualization.ngram_visualizer import create_ngram_visualization
+from visualization.topic_visualizer import process_and_visualize_topic_analysis  # Added import
 
 def create_bow_visualization(analysis_results):
     """
@@ -203,6 +204,14 @@ def process_and_visualize_analysis(analysis_results):
                 ngram_components = create_ngram_visualization(
                     {"analyses": {prompt: {"ngram_analysis": analyses["ngram_analysis"]}}})
                 components.extend(ngram_components)
+            
+            # Check for Topic Modeling analysis
+            if "topic_modeling" in analyses:
+                print("Processing Topic Modeling visualization")
+                # Use the dedicated topic visualization function
+                topic_components = process_and_visualize_topic_analysis(
+                    {"analyses": {prompt: {"topic_modeling": analyses["topic_modeling"]}}})
+                components.extend(topic_components)
 
         if not components:
             components.append(gr.Markdown("No visualization components could be created from the analysis results."))