update

_archive/app copy.py

@@ -1,355 +0,0 @@
-import gradio as gr
-from ui.dataset_input import create_dataset_input, load_example_dataset
-from ui.analysis_screen import create_analysis_screen, process_analysis_request
-from visualization.bow_visualizer import process_and_visualize_analysis
-import nltk
-import os
-import json
-
-# Download necessary NLTK resources function remains unchanged
-def download_nltk_resources():
-    """Download required NLTK resources if not already downloaded"""
-    try:
-        # Create nltk_data directory in the user's home directory if it doesn't exist
-        nltk_data_path = os.path.expanduser("~/nltk_data")
-        os.makedirs(nltk_data_path, exist_ok=True)
-        
-        # Add this path to NLTK's data path
-        nltk.data.path.append(nltk_data_path)
-        
-        # Download required resources
-        resources = ['punkt', 'wordnet', 'stopwords', 'punkt_tab']
-        for resource in resources:
-            try:
-                # Different resources can be in different directories in NLTK
-                locations = [
-                    f'tokenizers/{resource}',
-                    f'corpora/{resource}',
-                    f'taggers/{resource}',
-                    f'{resource}'
-                ]
-                
-                found = False
-                for location in locations:
-                    try:
-                        nltk.data.find(location)
-                        print(f"Resource {resource} already downloaded")
-                        found = True
-                        break
-                    except LookupError:
-                        continue
-                
-                if not found:
-                    print(f"Downloading {resource}...")
-                    nltk.download(resource, quiet=True)
-            except Exception as e:
-                print(f"Error with resource {resource}: {e}")
-        
-        print("NLTK resources check completed")
-    except Exception as e:
-        print(f"Error downloading NLTK resources: {e}")
-
-def create_app():
-    """
-    Create a streamlined Gradio app for dataset input and Bag of Words analysis. 
-    
-    Returns:
-        gr.Blocks: The Gradio application
-    """
-    with gr.Blocks(title="LLM Response Comparator") as app:
-        # Application state to share data between tabs
-        dataset_state = gr.State({})
-        analysis_results_state = gr.State({})
-        
-        # Dataset Input Tab
-        with gr.Tab("Dataset Input"):
-            dataset_inputs, example_dropdown, load_example_btn, create_btn, prompt, response1, model1, response2, model2 = create_dataset_input()
-            
-            # Add status indicator to show when dataset is created
-            dataset_status = gr.Markdown("*No dataset loaded*")
-            
-            # Load example dataset
-            load_example_btn.click(
-                fn=load_example_dataset,
-                inputs=[example_dropdown],
-                outputs=[prompt, response1, model1, response2, model2]  # Update all field values
-            )
-
-            # Save dataset to state and update status
-            def create_dataset(p, r1, m1, r2, m2):
-                if not p or not r1 or not r2:
-                    return {}, "❌ **Error:** Please fill in at least the prompt and both responses"
-                
-                dataset = {
-                    "entries": [
-                        {"prompt": p, "response": r1, "model": m1 or "Model 1"},
-                        {"prompt": p, "response": r2, "model": m2 or "Model 2"}
-                    ]
-                }
-                return dataset, "✅ **Dataset created successfully!** You can now go to the Analysis tab"
-                
-            create_btn.click(
-                fn=create_dataset,
-                inputs=[prompt, response1, model1, response2, model2],
-                outputs=[dataset_state, dataset_status]
-            )
-        
-        # Analysis Tab
-        with gr.Tab("Analysis"):
-            # Use create_analysis_screen to get UI components including visualization container
-            analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider = create_analysis_screen()
-            
-            # Pre-create visualization components (initially hidden)
-            visualization_area_visible = gr.Checkbox(value=False, visible=False, label="Visualization Visible")
-            analysis_title = gr.Markdown("## Analysis Results", visible=False)
-            prompt_title = gr.Markdown(visible=False)
-            models_compared = gr.Markdown(visible=False)
-            
-            # Container for model 1 words
-            model1_title = gr.Markdown(visible=False)
-            model1_words = gr.Markdown(visible=False)
-            
-            # Container for model 2 words
-            model2_title = gr.Markdown(visible=False)
-            model2_words = gr.Markdown(visible=False)
-            
-            # Similarity metrics
-            similarity_metrics_title = gr.Markdown("### Similarity Metrics", visible=False)
-            similarity_metrics = gr.Markdown(visible=False)
-            
-            # Status or error message area
-            status_message_visible = gr.Checkbox(value=False, visible=False, label="Status Message Visible")
-            status_message = gr.Markdown(visible=False)
-            
-            # Define a helper function to extract parameter values and run the analysis
-            def run_analysis(dataset, selected_analyses, bow_top, ngram_n, ngram_top):
-                try:
-                    if not dataset or "entries" not in dataset or not dataset["entries"]:
-                        return (
-                            {},  # analysis_results_state
-                            False,  # analysis_output visibility
-                            False,  # visualization_area_visible
-                            gr.update(visible=False),  # analysis_title
-                            gr.update(visible=False),  # prompt_title
-                            gr.update(visible=False),  # models_compared
-                            gr.update(visible=False),  # model1_title
-                            gr.update(visible=False),  # model1_words
-                            gr.update(visible=False),  # model2_title
-                            gr.update(visible=False),  # model2_words
-                            gr.update(visible=False),  # similarity_metrics_title
-                            gr.update(visible=False),  # similarity_metrics
-                            True,  # status_message_visible
-                            gr.update(visible=True, value="❌ **Error:** No dataset loaded. Please create or load a dataset first.")  # status_message
-                        )
-                    
-                    parameters = {
-                        "bow_top": bow_top,
-                        "ngram_n": ngram_n,
-                        "ngram_top": ngram_top
-                    }
-                    print("Running analysis with parameters:", 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"]:
-                        return (
-                            analysis_results,
-                            False,
-                            False,
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            gr.update(visible=False),
-                            True,
-                            gr.update(visible=True, value="❌ **No results found.** Try different analysis options.")
-                        )
-                    
-                    # Extract information to display in components
-                    prompt = list(analysis_results["analyses"].keys())[0]
-                    analyses = analysis_results["analyses"][prompt]
-                    
-                    if "bag_of_words" not 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="❌ **No Bag of Words analysis found.** Make sure to select it in the options.")
-                        )
-                    
-                    bow_results = analyses["bag_of_words"]
-                    models = bow_results.get("models", [])
-                    
-                    if len(models) < 2:
-                        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="❌ **Not enough models to compare.** Please ensure you have two model responses.")
-                        )
-                    
-                    # Extract and format information for display
-                    model1_name = models[0]
-                    model2_name = models[1]
-                    
-                    # Format important words for each model
-                    important_words = bow_results.get("important_words", {})
-                    model1_words_text = "No important words found"
-                    model2_words_text = "No important words found"
-                    
-                    if model1_name in important_words:
-                        word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model1_name][:10]]
-                        model1_words_text = ", ".join(word_list)
-                    
-                    if model2_name in important_words:
-                        word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model2_name][:10]]
-                        model2_words_text = ", ".join(word_list)
-                    
-                    # Format similarity metrics
-                    similarity_text = "No similarity metrics found"
-                    comparisons = bow_results.get("comparisons", {})
-                    comparison_key = f"{model1_name} vs {model2_name}"
-
-                    if comparison_key in comparisons:
-                        metrics = comparisons[comparison_key]
-                        cosine = metrics.get("cosine_similarity", 0)
-                        jaccard = metrics.get("jaccard_similarity", 0)
-                        semantic = metrics.get("semantic_similarity", 0)  # Add semantic similarity
-                        common_words = metrics.get("common_word_count", 0)
-                        
-                        similarity_text = f"""
-                        - **Cosine Similarity**: {cosine:.2f} (higher means more similar word frequency patterns)
-                        - **Jaccard Similarity**: {jaccard:.2f} (higher means more word overlap)
-                        - **Semantic Similarity**: {semantic:.2f} (higher means more similar meaning)
-                        - **Common Words**: {common_words} words appear in both responses
-                        """
-                        
-                    # Return all updated component values
-                    return (
-                        analysis_results,  # analysis_results_state
-                        False,  # analysis_output visibility
-                        True,   # visualization_area_visible
-                        gr.update(visible=True),  # analysis_title
-                        gr.update(visible=True, value=f"## Analysis of Prompt: \"{prompt[:100]}...\""),  # prompt_title
-                        gr.update(visible=True, value=f"### Comparing responses from {model1_name} and {model2_name}"),  # models_compared
-                        gr.update(visible=True, value=f"#### Top Words Used by {model1_name}"),  # model1_title
-                        gr.update(visible=True, value=model1_words_text),  # model1_words
-                        gr.update(visible=True, value=f"#### Top Words Used by {model2_name}"),  # model2_title
-                        gr.update(visible=True, value=model2_words_text),  # model2_words
-                        gr.update(visible=True),  # similarity_metrics_title
-                        gr.update(visible=True, value=similarity_text),  # similarity_metrics
-                        False,  # status_message_visible
-                        gr.update(visible=False)  # status_message
-                    )
-                
-                except Exception as e:
-                    import traceback
-                    error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
-                    print(error_msg)
-                    
-                    return (
-                        {"error": error_msg},  # analysis_results_state
-                        True,  # analysis_output visibility (show raw JSON for debugging)
-                        False,  # visualization_area_visible
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        gr.update(visible=False),
-                        True,  # status_message_visible
-                        gr.update(visible=True, value=f"❌ **Error during analysis:**\n\n```\n{str(e)}\n```")  # status_message
-                    )
-
-            # 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],
-                outputs=[
-                    analysis_results_state,
-                    analysis_output,
-                    visualization_area_visible,
-                    analysis_title,
-                    prompt_title,
-                    models_compared,
-                    model1_title,
-                    model1_words,
-                    model2_title,
-                    model2_words,
-                    similarity_metrics_title,
-                    similarity_metrics,
-                    status_message_visible,
-                    status_message
-                ]
-            )
-    
-    return app
-
-if __name__ == "__main__":
-    # Download required NLTK resources before launching the app
-    download_nltk_resources()
-    
-    app = create_app()
-    app.launch()

_archive/app.py

@@ -1,63 +0,0 @@
-import gradio as gr
-import os
-from ui.dataset_input import create_dataset_input, load_example_dataset
-from ui.analysis_screen import process_analysis_request
-
-def create_app():
-    """
-    Create a streamlined Gradio app for dataset input and Bag of Words analysis.
-    
-    Returns:
-        gr.Blocks: The Gradio application
-    """
-    with gr.Blocks(title="LLM Response Comparator") as app:
-        # Application state to share data between tabs
-        dataset_state = gr.State({})
-        analysis_results_state = gr.State({})
-        
-        # Dataset Input Tab
-        with gr.Tab("Dataset Input"):
-            dataset_inputs, example_dropdown, load_example_btn, create_btn, prompt, response1, model1, response2, model2 = create_dataset_input()
-            
-            # Load example dataset
-            load_example_btn.click(
-                fn=load_example_dataset,
-                inputs=[example_dropdown],
-                outputs=[dataset_inputs]  # Ensure `load_example_dataset` returns compatible data
-            )
-
-            # Save dataset to state
-            create_btn.click(
-                fn=lambda p, r1, m1, r2, m2: {
-                    "entries": [
-                        {"prompt": p, "response": r1, "model": m1},
-                        {"prompt": p, "response": r2, "model": m2}
-                    ]
-                },
-                inputs=[prompt, response1, model1, response2, model2],  # Ensure these are valid Gradio components
-                outputs=[dataset_state]  # Ensure `dataset_state` is correctly defined
-            )
-        
-        # Analysis Tab
-        with gr.Tab("Analysis"):
-            analysis_options = gr.CheckboxGroup(
-                choices=["Bag of Words"],
-                value=["Bag of Words"],
-                label="Select Analyses to Run"
-            )
-            run_analysis_btn = gr.Button("Run Analysis", variant="primary")
-            analysis_output = gr.JSON(label="Analysis Results", visible=False)
-            
-            # Run analysis
-            run_analysis_btn.click(
-                fn=process_analysis_request,
-                inputs=[dataset_state, analysis_options],  # Removed None
-                outputs=[analysis_results_state, analysis_output]
-            )
-    
-    return app
-
-if __name__ == "__main__":
-    # Create and launch the app
-    app = create_app()
-    app.launch()

app.bak.py

@@ -1,7 +0,0 @@
-import gradio as gr
-
-def greet(name):
-    return "Hello " + name + "!!"
-
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()

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 - note we're now passing selected_analysis as a string, not a list
+                    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,6 +198,25 @@ 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']}**")
+                        )
+                    
                     # Check for Bag of Words analysis
                     if "bag_of_words" in analyses:
                         visualization_area_visible = True
@@ -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
+                    if "ngram_analysis" in analyses:
                         visualization_area_visible = True
                         ngram_results = analyses["ngram_analysis"]
                         models = ngram_results.get("models", [])
@@ -304,6 +325,78 @@ def create_app():
                                     - **Common {size_name}**: {common_count} {size_name.lower()} appear in both responses
                                     """
                     
+                    # Check for Topic Modeling analysis
+                    if "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)
+                                    """
+                    
                     # If we don't have visualization data from any analysis
                     if not visualization_area_visible:
                         return (
@@ -320,7 +413,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
@@ -363,60 +456,59 @@ def create_app():
                         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
-                ]
+        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
-                ]
-            )
+        # 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],
-                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 - update to include topic_count
+        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 +517,4 @@ if __name__ == "__main__":
     download_nltk_resources()
     
     app = create_app()
-    app.launch()
+    app.launch()

ui/analysis_screen.py

@@ -3,8 +3,7 @@ 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  # Added import
 from processors.ngram_analysis import compare_ngrams
 # from processors.bias_detection import compare_bias
 from processors.bow_analysis import compare_bow
@@ -16,27 +15,25 @@ 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"
+                    "Classifier",  # New option for future development
+                    "LLM Analysis"  # New option for future development
                 ],
-                value=[
-                    "Bag of Words",
-                ],
-                label="Select Analyses to Run"
+                value="Bag of Words",  # Default selection
+                label="Select Analysis Type"
             )
         
         # Create slider directly here for easier access
@@ -59,13 +56,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 +84,45 @@ 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 for future development
+            with gr.Group(visible=False) as classifier_params:
+                gr.Markdown("### Classifier Parameters")
+                gr.Markdown("*Classifier options will be available in a future update*")
+            
+            # LLM Analysis parameters for future development
+            with gr.Group(visible=False) as llm_params:
+                gr.Markdown("### LLM Analysis Parameters")
+                gr.Markdown("*LLM Analysis options will be available in a future update*")
                 
-            # 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"),
+                    llm_params: gr.update(visible=selected == "LLM Analysis"),
+                    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,
+                    llm_params,
+                    ngram_n, 
+                    ngram_top, 
+                    topic_count,
+                    bow_top_slider
+                ]
             )
         
         # Run analysis button
@@ -116,15 +132,15 @@ 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):
+def process_analysis_request(dataset, selected_analysis, parameters):
     """
-    Process the analysis request and run selected analyses
+    Process the analysis request and run selected analysis
     """
     try:
-        print(f"Processing analysis request with: {selected_analyses}")
+        print(f"Processing analysis request with: {selected_analysis}")
         print(f"Parameters: {parameters}")
 
         if not dataset or "entries" not in dataset or not dataset["entries"]:
@@ -144,19 +160,36 @@ def process_analysis_request(dataset, selected_analyses, parameters):
         analysis_results["analyses"][prompt] = {}
 
         # Run Bag of Words analysis if selected
-        if "Bag of Words" in selected_analyses:
+        if selected_analysis == "Bag of Words":
             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:
+        elif selected_analysis == "N-gram Analysis":
             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
+            
+        # Run Topic Modeling analysis if selected
+        elif selected_analysis == "Topic Modeling":
+            topic_count = int(parameters.get("topic_count", 3))
+            print(f"Running Topic Modeling analysis with topic_count={topic_count}")
+            topic_results = compare_topics(response_texts, model_names, n_topics=topic_count)
+            analysis_results["analyses"][prompt]["topic_modeling"] = topic_results
+            
+        # Add placeholder for future analysis types
+        elif selected_analysis == "Bias Detection":
+            analysis_results["analyses"][prompt]["message"] = "Bias Detection will be available in a future update"
+            
+        elif selected_analysis == "Classifier":
+            analysis_results["analyses"][prompt]["message"] = "Classifier will be available in a future update"
+            
+        elif selected_analysis == "LLM Analysis":
+            analysis_results["analyses"][prompt]["message"] = "LLM Analysis will be available in a future update"
 
         print("Analysis complete - results:", analysis_results)
 

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."))