update

processors/topic_modeling.py

@@ -0,0 +1,208 @@
+"""
+Topic modeling processor for comparing text responses
+"""
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+from sklearn.decomposition import LatentDirichletAllocation, NMF
+import numpy as np
+import nltk
+from nltk.corpus import stopwords
+import re
+
+def preprocess_text(text):
+    """
+    Preprocess text for topic modeling
+    
+    Args:
+        text (str): Text to preprocess
+        
+    Returns:
+        str: Preprocessed text
+    """
+    # Convert to lowercase
+    text = text.lower()
+    
+    # Remove special characters and digits
+    text = re.sub(r'[^a-zA-Z\s]', '', text)
+    
+    # Tokenize
+    tokens = nltk.word_tokenize(text)
+    
+    # Remove stopwords
+    stop_words = set(stopwords.words('english'))
+    tokens = [token for token in tokens if token not in stop_words and len(token) > 3]
+    
+    return ' '.join(tokens)
+
+def get_top_words_per_topic(model, feature_names, n_top_words=10):
+    """
+    Get the top words for each topic in the model
+    
+    Args:
+        model: Topic model (LDA or NMF)
+        feature_names (list): Feature names (words)
+        n_top_words (int): Number of top words to include per topic
+        
+    Returns:
+        list: List of topics with their top words
+    """
+    topics = []
+    for topic_idx, topic in enumerate(model.components_):
+        top_words_idx = topic.argsort()[:-n_top_words - 1:-1]
+        top_words = [feature_names[i] for i in top_words_idx]
+        topic_dict = {
+            "id": topic_idx,
+            "words": top_words,
+            "weights": topic[top_words_idx].tolist()
+        }
+        topics.append(topic_dict)
+    return topics
+
+def extract_topics(texts, n_topics=3, n_top_words=10, method="lda"):
+    """
+    Extract topics from a list of texts
+    
+    Args:
+        texts (list): List of text documents
+        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')
+        
+    Returns:
+        dict: Topic modeling results with topics and document-topic distributions
+    """
+    result = {
+        "method": method,
+        "n_topics": n_topics,
+        "topics": [],
+        "document_topics": []
+    }
+    
+    # Preprocess texts
+    preprocessed_texts = [preprocess_text(text) for text in texts]
+    
+    # Create document-term matrix
+    if method == "nmf":
+        # For NMF, use TF-IDF vectorization
+        vectorizer = TfidfVectorizer(max_features=1000, min_df=2, max_df=0.85)
+    else:
+        # For LDA, use CountVectorizer
+        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()
+    
+    # Apply topic modeling
+    if method == "nmf":
+        # Non-negative Matrix Factorization
+        model = NMF(n_components=n_topics, random_state=42, max_iter=1000)
+    else:
+        # Latent Dirichlet Allocation
+        model = LatentDirichletAllocation(n_components=n_topics, random_state=42, max_iter=20)
+    
+    topic_distribution = model.fit_transform(X)
+    
+    # Get top words for each topic
+    result["topics"] = get_top_words_per_topic(model, feature_names, n_top_words)
+    
+    # Get topic distribution for each document
+    for i, dist in enumerate(topic_distribution):
+        # Normalize for easier comparison
+        normalized_dist = dist / np.sum(dist) if np.sum(dist) > 0 else dist
+        result["document_topics"].append({
+            "document_id": i,
+            "distribution": normalized_dist.tolist()
+        })
+    
+    return result
+
+def compare_topics(response_texts, model_names, n_topics=3, n_top_words=10, method="lda"):
+    """
+    Compare topic distributions between different model responses
+    
+    Args:
+        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')
+        
+    Returns:
+        dict: Comparative topic analysis
+    """
+    # Initialize results
+    result = {
+        "models": model_names,
+        "method": method,
+        "n_topics": n_topics,
+        "topics": [],
+        "model_topics": {},
+        "comparisons": {}
+    }
+    
+    # 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

visualization/__init__.py

@@ -3,5 +3,11 @@ Visualization components for LLM Response Comparator
 """
 
 from .bow_visualizer import process_and_visualize_analysis
+from .topic_visualizer import process_and_visualize_topic_analysis
+from .ngram_visualizer import process_and_visualize_ngram_analysis
 
-__all__ = ['process_and_visualize_analysis']
+__all__ = [
+    'process_and_visualize_analysis',
+    'process_and_visualize_topic_analysis',
+    'process_and_visualize_ngram_analysis'
+]

visualization/topic_visualizer.py

@@ -0,0 +1,168 @@
+"""
+Visualization for topic modeling analysis results
+"""
+from visualization.ngram_visualizer import create_ngram_visualization
+import gradio as gr
+import json
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+def create_topic_visualization(analysis_results):
+    """
+    Create visualizations for topic modeling analysis results
+    
+    Args:
+        analysis_results (dict): Analysis results from the topic modeling analysis
+        
+    Returns:
+        list: List of gradio components with visualizations
+    """
+    # Initialize output components list
+    output_components = []
+    
+    # Check if we have valid results
+    if not analysis_results or "analyses" not in analysis_results:
+        return [gr.Markdown("No analysis results found.")]
+    
+    # Process each prompt
+    for prompt, analyses in analysis_results["analyses"].items():
+        # Process Topic Modeling analysis if available
+        if "topic_modeling" in analyses:
+            topic_results = analyses["topic_modeling"]
+            
+            # Show method and number of topics
+            method = topic_results.get("method", "lda").upper()
+            n_topics = topic_results.get("n_topics", 3)
+            output_components.append(gr.Markdown(f"## Topic Modeling Analysis ({method}, {n_topics} topics)"))
+            
+            # Show models being compared
+            models = topic_results.get("models", [])
+            if len(models) >= 2:
+                output_components.append(gr.Markdown(f"### Comparing responses from {models[0]} and {models[1]}"))
+                
+                # Visualize topics
+                topics = topic_results.get("topics", [])
+                if topics:
+                    output_components.append(gr.Markdown("### Discovered Topics"))
+                    
+                    for topic in topics:
+                        topic_id = topic.get("id", 0)
+                        words = topic.get("words", [])
+                        weights = topic.get("weights", [])
+                        
+                        # Create topic word bar chart
+                        if words and weights and len(words) == len(weights):
+                            # Create dataframe for plotting
+                            df = pd.DataFrame({
+                                'word': words,
+                                'weight': weights
+                            })
+                            
+                            # Sort by weight
+                            df = df.sort_values('weight', ascending=False)
+                            
+                            # Create bar chart
+                            fig = px.bar(
+                                df, x='word', y='weight',
+                                title=f"Topic {topic_id+1} Top Words",
+                                labels={'word': 'Word', 'weight': 'Weight'},
+                                height=300
+                            )
+                            
+                            output_components.append(gr.Plot(value=fig))
+                
+                # Visualize topic distributions for each model
+                model_topics = topic_results.get("model_topics", {})
+                if model_topics and all(model in model_topics for model in models):
+                    output_components.append(gr.Markdown("### Topic Distribution by Model"))
+                    
+                    # Create multi-model topic distribution comparison
+                    fig = go.Figure()
+                    for model in models:
+                        if model in model_topics:
+                            distribution = model_topics[model]
+                            fig.add_trace(go.Bar(
+                                x=[f"Topic {i+1}" for i in range(len(distribution))],
+                                y=distribution,
+                                name=model
+                            ))
+                    
+                    fig.update_layout(
+                        title="Topic Distributions Comparison",
+                        xaxis_title="Topic",
+                        yaxis_title="Weight",
+                        barmode='group',
+                        height=400
+                    )
+                    
+                    output_components.append(gr.Plot(value=fig))
+                
+                # Visualize topic differences
+                comparisons = topic_results.get("comparisons", {})
+                if comparisons:
+                    output_components.append(gr.Markdown("### Topic Distribution Differences"))
+                    
+                    for comparison_key, comparison_data in comparisons.items():
+                        js_divergence = comparison_data.get("js_divergence", 0)
+                        topic_differences = comparison_data.get("topic_differences", [])
+                        
+                        output_components.append(gr.Markdown(
+                            f"**{comparison_key}** - Jensen-Shannon Divergence: {js_divergence:.4f}"
+                        ))
+                        
+                        if topic_differences:
+                            # Create DataFrame for plotting
+                            model1, model2 = comparison_key.split(" vs ")
+                            df_diff = pd.DataFrame(topic_differences)
+                            
+                            # Create bar chart for topic differences
+                            fig = go.Figure()
+                            fig.add_trace(go.Bar(
+                                x=[f"Topic {d['topic_id']+1}" for d in topic_differences],
+                                y=[d["model1_weight"] for d in topic_differences],
+                                name=model1
+                            ))
+                            fig.add_trace(go.Bar(
+                                x=[f"Topic {d['topic_id']+1}" for d in topic_differences],
+                                y=[d["model2_weight"] for d in topic_differences],
+                                name=model2
+                            ))
+                            
+                            fig.update_layout(
+                                title="Topic Weight Comparison",
+                                xaxis_title="Topic",
+                                yaxis_title="Weight",
+                                barmode='group',
+                                height=400
+                            )
+                            
+                            output_components.append(gr.Plot(value=fig))
+    
+    # If no components were added, show a message
+    if len(output_components) <= 1:
+        output_components.append(gr.Markdown("No detailed Topic Modeling analysis found in results."))
+    
+    return output_components
+
+
+def process_and_visualize_topic_analysis(analysis_results):
+    """
+    Process the topic modeling analysis results and create visualization components
+    
+    Args:
+        analysis_results (dict): The analysis results
+        
+    Returns:
+        list: List of gradio components for visualization
+    """
+    try:
+        print(f"Starting visualization of topic modeling analysis results")
+        return create_topic_visualization(analysis_results)
+    except Exception as e:
+        import traceback
+        error_msg = f"Topic modeling visualization error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return [gr.Markdown(f"**Error during topic modeling visualization:**\n\n```\n{error_msg}\n```")]