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, topic_count = create_analysis_screen()
+            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top = 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_analysis, bow_top, ngram_n, ngram_top, topic_count):
+            def run_analysis(dataset, selected_analyses, bow_top, ngram_n, ngram_top):
                 try:
                     if not dataset or "entries" not in dataset or not dataset["entries"]:
                         return (
@@ -145,14 +145,12 @@ def create_app():
                     parameters = {
                         "bow_top": bow_top,
                         "ngram_n": ngram_n,
-                        "ngram_top": ngram_top,
-                        "topic_count": topic_count
+                        "ngram_top": ngram_top
                     }
-                    print(f"Running analysis with selected type: {selected_analysis}")
-                    print("Parameters:", parameters)
+                    print("Running analysis with parameters:", parameters)
                     
-                    # Process the analysis request - passing selected_analysis as a string
-                    analysis_results, _ = process_analysis_request(dataset, selected_analysis, parameters)
+                    # Process the analysis request
+                    analysis_results, _ = process_analysis_request(dataset, selected_analyses, parameters)
                     
                     # If there's an error or no results
                     if not analysis_results or "analyses" not in analysis_results or not analysis_results["analyses"]:
@@ -170,7 +168,7 @@ def create_app():
                             gr.update(visible=False),
                             gr.update(visible=False),
                             True,
-                            gr.update(visible=True, value="❌ **No results found.** Try a different analysis option.")
+                            gr.update(visible=True, value="❌ **No results found.** Try different analysis options.")
                         )
                     
                     # Extract information to display in components
@@ -198,27 +196,8 @@ def create_app():
                     similarity_metrics_visible = False
                     similarity_metrics_value = ""
                     
-                    # Check for messages from placeholder analyses
-                    if "message" in analyses:
-                        return (
-                            analysis_results,
-                            False,
-                            False,
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            True,
-                            gr.update(visible=True, value=f"ℹ️ **{analyses['message']}**")
-                        )
-                    
-                    # Process based on the selected analysis type
-                    if selected_analysis == "Bag of Words" and "bag_of_words" in analyses:
+                    # Check for Bag of Words analysis
+                    if "bag_of_words" in analyses:
                         visualization_area_visible = True
                         bow_results = analyses["bag_of_words"]
                         models = bow_results.get("models", [])
@@ -273,8 +252,8 @@ def create_app():
                                 - **Common Words**: {common_words} words appear in both responses
                                 """
                                 
-                    # Check for N-gram analysis
-                    elif selected_analysis == "N-gram Analysis" and "ngram_analysis" in analyses:
+                    # Check for N-gram analysis (if not found, we'll fallback to BOW)
+                    if "ngram_analysis" in analyses and not visualization_area_visible:
                         visualization_area_visible = True
                         ngram_results = analyses["ngram_analysis"]
                         models = ngram_results.get("models", [])
@@ -325,129 +304,6 @@ 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 (
@@ -464,7 +320,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 a valid analysis option.")
+                            gr.update(visible=True, value="❌ **No visualization data found.** Make sure to select at least one analysis type.")
                         )
 
                     # Return all updated component values
@@ -506,80 +362,61 @@ 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]
+
+            # 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
+                ]
             )
 
-        # 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
-            ]
-        )
+            # 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
+                ]
+            )
     
     return app
 
@@ -588,4 +425,4 @@ if __name__ == "__main__":
     download_nltk_resources()
     
     app = create_app()
-    app.launch()
+    app.launch()

processors/ngram_analysis.py

@@ -9,22 +9,6 @@ from nltk.util import ngrams
 from nltk.tokenize import word_tokenize
 from nltk.corpus import stopwords
 
-# Helper function to flatten nested lists
-def flatten_list(nested_list):
-    """
-    Recursively flattens a nested list.
-
-    Args:
-        nested_list (list): A potentially nested list.
-
-    Returns:
-        list: A flattened list.
-    """
-    for item in nested_list:
-        if isinstance(item, list):
-            yield from flatten_list(item)
-        else:
-            yield item
 
 def compare_ngrams(texts, model_names, n=2, top_n=25):
     """
@@ -67,11 +51,8 @@ def compare_ngrams(texts, model_names, n=2, top_n=25):
             max_features=1000,
             stop_words='english'
         )
-        
-        # Ensure each text is a string, without attempting complex preprocessing
-        processed_texts = [str(text) if not isinstance(text, str) else text for text in texts]
-        
-        X = vectorizer.fit_transform(processed_texts)
+
+        X = vectorizer.fit_transform(texts)
 
         # Get feature names (n-grams)
         feature_names = vectorizer.get_feature_names_out()

processors/text_classifiers.py

@@ -1,152 +0,0 @@
-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

processors/topic_modeling.py

@@ -83,12 +83,10 @@ def extract_topics(texts, n_topics=3, n_top_words=10, method="lda"):
     # 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)
+        vectorizer = TfidfVectorizer(max_features=1000, min_df=2, max_df=0.85)
     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)
+        vectorizer = CountVectorizer(max_features=1000, min_df=2, max_df=0.85)
     
     X = vectorizer.fit_transform(preprocessed_texts)
     feature_names = vectorizer.get_feature_names_out()
@@ -117,65 +115,94 @@ def extract_topics(texts, n_topics=3, n_top_words=10, method="lda"):
     
     return result
 
-def compare_topics(texts_set_1, texts_set_2, n_topics=3, n_top_words=10, method="lda", model_names=None):
+def compare_topics(response_texts, model_names, n_topics=3, n_top_words=10, method="lda"):
     """
-    Compare topics between two sets of texts
+    Compare topic distributions between different model responses
     
     Args:
-        texts_set_1 (list): First list of text documents
-        texts_set_2 (list): Second list of text documents
+        response_texts (list): List of response texts to compare
+        model_names (list): Names of models corresponding to responses
         n_topics (int): Number of topics to extract
         n_top_words (int): Number of top words per topic
         method (str): Topic modeling method ('lda' or 'nmf')
-        model_names (list, optional): Names of the models being compared
         
     Returns:
-        dict: Comparison results with topics from both sets and similarity metrics
+        dict: Comparative topic analysis
     """
-    # 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 results
     result = {
+        "models": model_names,
         "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
+        "topics": [],
+        "model_topics": {},
+        "comparisons": {}
     }
     
-    return result
+    # Extract topics
+    topic_model = extract_topics(response_texts, n_topics, n_top_words, method)
+    result["topics"] = topic_model["topics"]
+    
+    # Map topic distributions to models
+    for i, model_name in enumerate(model_names):
+        if i < len(topic_model["document_topics"]):
+            result["model_topics"][model_name] = topic_model["document_topics"][i]["distribution"]
+    
+    # Calculate topic distribution differences for pairs of models
+    if len(model_names) >= 2:
+        for i in range(len(model_names)):
+            for j in range(i+1, len(model_names)):
+                model1, model2 = model_names[i], model_names[j]
+                
+                # Get topic distributions
+                dist1 = result["model_topics"].get(model1, [])
+                dist2 = result["model_topics"].get(model2, [])
+                
+                # Skip if distributions are not available
+                if not dist1 or not dist2 or len(dist1) != len(dist2):
+                    continue
+                
+                # Calculate Jensen-Shannon divergence (approximation using average of KL divergences)
+                dist1 = np.array(dist1)
+                dist2 = np.array(dist2)
+                
+                # Add small epsilon to avoid division by zero
+                epsilon = 1e-10
+                dist1 = dist1 + epsilon
+                dist2 = dist2 + epsilon
+                
+                # Normalize
+                dist1 = dist1 / np.sum(dist1)
+                dist2 = dist2 / np.sum(dist2)
+                
+                # Calculate average distribution
+                avg_dist = (dist1 + dist2) / 2
+                
+                # Calculate KL divergences
+                kl_div1 = np.sum(dist1 * np.log(dist1 / avg_dist))
+                kl_div2 = np.sum(dist2 * np.log(dist2 / avg_dist))
+                
+                # Jensen-Shannon divergence
+                js_div = (kl_div1 + kl_div2) / 2
+                
+                # Topic-wise differences
+                topic_diffs = []
+                for t in range(len(dist1)):
+                    topic_diffs.append({
+                        "topic_id": t,
+                        "model1_weight": float(dist1[t]),
+                        "model2_weight": float(dist2[t]),
+                        "diff": float(abs(dist1[t] - dist2[t]))
+                    })
+                
+                # Sort by difference
+                topic_diffs.sort(key=lambda x: x["diff"], reverse=True)
+                
+                # Store comparison
+                comparison_key = f"{model1} vs {model2}"
+                result["comparisons"][comparison_key] = {
+                    "js_divergence": float(js_div),
+                    "topic_differences": topic_diffs
+                }
+    
+    return result

ui/analysis_screen.py

@@ -3,35 +3,40 @@ import json
 from visualization.bow_visualizer import process_and_visualize_analysis
 
 # Import analysis modules
-from processors.topic_modeling import compare_topics
+# Uncomment these when implemented
+# from processors.topic_modeling import extract_topics, 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.text_classifiers import classify_formality, classify_sentiment, classify_complexity, compare_classifications
+# from processors.metrics import calculate_similarity
+# from processors.diff_highlighter import highlight_differences
 
 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, topic_count)
+        tuple: (analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top)
     """
     with gr.Column() as analysis_screen:
         gr.Markdown("## Analysis Options")
-        gr.Markdown("Select which analysis you want to run on the LLM responses.")
+        gr.Markdown("Select which analyses you want to run on the LLM responses.")
         
-        # Change from CheckboxGroup to Radio for analysis selection
+        # Analysis selection
         with gr.Group():
-            analysis_options = gr.Radio(
+            analysis_options = gr.CheckboxGroup(
                 choices=[
-                    "Bag of Words",
-                    "N-gram Analysis",
                     "Topic Modeling",
+                    "N-gram Analysis",
                     "Bias Detection",
-                    "Classifier"
-                    # Removed "LLM Analysis" as requested
+                    "Bag of Words",
+                    "Similarity Metrics",
+                    "Difference Highlighting"
                 ],
-                value="Bag of Words",  # Default selection
-                label="Select Analysis Type"
+                value=[
+                    "Bag of Words",
+                ],
+                label="Select Analyses to Run"
             )
         
         # Create slider directly here for easier access
@@ -54,19 +59,13 @@ 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")
-                # We'll use the topic_count defined above
+                topic_count = gr.Slider(minimum=2, maximum=10, value=3, step=1, 
+                                       label="Number of Topics")
             
             # N-gram parameters group (using external ngram_n and ngram_top)
             with gr.Group(visible=False) as ngram_params:
@@ -82,38 +81,32 @@ def create_analysis_screen():
                     label="Bias Detection Methods"
                 )
             
-            # Classifier parameters
-            with gr.Group(visible=False) as classifier_params:
-                gr.Markdown("### Classifier Parameters")
-                gr.Markdown("Classifies responses based on formality, sentiment, and complexity")
+            # 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"
+                )
                 
-            # Function to update parameter visibility based on selected analysis
+            # Function to update parameter visibility based on selected analyses
             def update_params_visibility(selected):
+                ngram_visible = "N-gram Analysis" in selected
                 return {
-                    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")
+                    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)
                 }
                 
             # Set up event handler for analysis selection
             analysis_options.change(
                 fn=update_params_visibility,
                 inputs=[analysis_options],
-                outputs=[
-                    topic_params, 
-                    ngram_params, 
-                    bias_params, 
-                    classifier_params,
-                    ngram_n, 
-                    ngram_top, 
-                    topic_count,
-                    bow_top_slider
-                ]
+                outputs=[topic_params, ngram_params, bias_params, similarity_params, ngram_n, ngram_top]
             )
         
         # Run analysis button
@@ -123,322 +116,54 @@ 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, topic_count
+    return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top
 
-# Add the implementation of these helper functions
-def extract_important_words(text, top_n=20):
+# Process analysis request function
+def process_analysis_request(dataset, selected_analyses, parameters):
     """
-    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
+    Process the analysis request and run selected analyses
     """
-    # 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:
-        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
+        print(f"Processing analysis request with: {selected_analyses}")
+        print(f"Parameters: {parameters}")
 
-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
+        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))
 
-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
+        analysis_results = {"analyses": {}}
 
-def compare_ngrams(text1, text2, n=2):
-    """
-    Compare n-grams between two texts.
-    
-    Args:
-        text1 (str or list): First text
-        text2 (str or list): 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)
-    
-    # Handle list inputs by converting to strings
-    if isinstance(text1, list):
-        text1 = ' '.join(str(item) for item in text1)
-    if isinstance(text2, list):
-        text2 = ' '.join(str(item) for item in text2)
-    
-    # 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)
-    }
+        # 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"]]
 
-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
+        print(f"Analyzing prompt: '{prompt[:50]}...'")
+        print(f"Models: {model_names}")
 
-# 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":
-        # Get the top_n parameter and ensure it's an integer
-        top_n = parameters.get("bow_top", 25)
-        if isinstance(top_n, str):
-            top_n = int(top_n)
-        
-        print(f"Using top_n value: {top_n}")  # Debug print
-        
-        # Perform Bag of Words analysis using the processor
-        bow_results = compare_bow(
-            [model1_response, model2_response],
-            [model1_name, model2_name],
-            top_n=top_n
-        )
-        results["analyses"][prompt_text]["bag_of_words"] = bow_results
-        
-    elif selected_analysis == "N-gram Analysis":
-        # Perform N-gram analysis
-        ngram_size = parameters.get("ngram_n", 2)
-        if isinstance(ngram_size, str):
-            ngram_size = int(ngram_size)
-            
-        top_n = parameters.get("ngram_top", 15)
-        if isinstance(top_n, str):
-            top_n = int(top_n)
-        
-        # Use the processor from the dedicated ngram_analysis module
-        from processors.ngram_analysis import compare_ngrams as ngram_processor
-        ngram_results = ngram_processor(
-            [model1_response, model2_response],
-            [model1_name, model2_name],
-            n=ngram_size,
-            top_n=top_n
-        )
-        results["analyses"][prompt_text]["ngram_analysis"] = ngram_results
-        
-    elif selected_analysis == "Topic Modeling":
-        # Perform topic modeling analysis
-        topic_count = parameters.get("topic_count", 3)
-        if isinstance(topic_count, str):
-            topic_count = int(topic_count)
-        
-        try:
-            topic_results = compare_topics(
-                texts_set_1=[model1_response], 
-                texts_set_2=[model2_response], 
-                n_topics=topic_count,
-                model_names=[model1_name, model2_name])
-            
-            results["analyses"][prompt_text]["topic_modeling"] = topic_results
-        except Exception as e:
-            import traceback
-            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
+        analysis_results["analyses"][prompt] = {}
+
+        # 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
+
+        # 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
+
+        print("Analysis complete - results:", analysis_results)
+
+        # Return results and update the output component
+        return analysis_results, gr.update(visible=False, value=analysis_results)  # Hide the raw JSON
+    except Exception as e:
+        import traceback
+        error_msg = f"Analysis error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return {}, gr.update(visible=True, value=json.dumps({"error": error_msg}, indent=2))

visualization/bow_visualizer.py

@@ -8,7 +8,6 @@ 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):
     """
@@ -204,14 +203,6 @@ 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."))