update

.idea/workspace.xml

@@ -5,12 +5,7 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="8e67814c-7f04-433c-ab7a-2b65a1106d4c" name="Changes" comment="">
-      <change afterPath="$PROJECT_DIR$/processors/ngram_analysis.py" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/visualization/ngram_visualizer.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/app.py" beforeDir="false" afterPath="$PROJECT_DIR$/app.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/ui/analysis_screen.py" beforeDir="false" afterPath="$PROJECT_DIR$/ui/analysis_screen.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/visualization/bow_visualizer.py" beforeDir="false" afterPath="$PROJECT_DIR$/visualization/bow_visualizer.py" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -60,7 +55,7 @@
       <option name="presentableId" value="Default" />
       <updated>1745170754325</updated>
       <workItem from="1745170755404" duration="245000" />
-      <workItem from="1745172030020" duration="7284000" />
+      <workItem from="1745172030020" duration="9539000" />
     </task>
     <servers />
   </component>

_archive/app copy.py

@@ -0,0 +1,355 @@
+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()

app.py

@@ -175,28 +175,137 @@ def create_app():
                     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.")
-                        )
+                    # Initialize visualization components visibilities and contents
+                    visualization_area_visible = False
+                    prompt_title_visible = False
+                    prompt_title_value = ""
+                    models_compared_visible = False
+                    models_compared_value = ""
+                    
+                    model1_title_visible = False
+                    model1_title_value = ""
+                    model1_words_visible = False
+                    model1_words_value = ""
+                    
+                    model2_title_visible = False
+                    model2_title_value = ""
+                    model2_words_visible = False
+                    model2_words_value = ""
+                    
+                    similarity_title_visible = False
+                    similarity_metrics_visible = False
+                    similarity_metrics_value = ""
                     
-                    bow_results = analyses["bag_of_words"]
-                    models = bow_results.get("models", [])
+                    # 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", [])
+                        
+                        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"### Comparing responses from {models[0]} and {models[1]}"
+                            
+                            # 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", {})
+                            
+                            if model1_name in important_words:
+                                model1_title_visible = True
+                                model1_title_value = f"#### Top Words Used by {model1_name}"
+                                
+                                word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model1_name][:10]]
+                                model1_words_visible = True
+                                model1_words_value = ", ".join(word_list)
+                            
+                            if model2_name in important_words:
+                                model2_title_visible = True
+                                model2_title_value = f"#### Top Words Used by {model2_name}"
+                                
+                                word_list = [f"**{item['word']}** ({item['count']})" for item in important_words[model2_name][:10]]
+                                model2_words_visible = True
+                                model2_words_value = ", ".join(word_list)
+                            
+                            # Format similarity metrics
+                            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)
+                                common_words = metrics.get("common_word_count", 0)
+                                
+                                similarity_title_visible = True
+                                similarity_metrics_visible = True
+                                similarity_metrics_value = 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
+                                """
+                                
+                    # 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", [])
+                        ngram_size = ngram_results.get("ngram_size", 2)
+                        size_name = "Unigrams" if ngram_size == 1 else f"{ngram_size}-grams"
+                        
+                        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"### {size_name} Analysis: Comparing responses from {models[0]} and {models[1]}"
+                            
+                            # Extract and format information for display
+                            model1_name = models[0]
+                            model2_name = models[1]
+                            
+                            # Format important n-grams for each model
+                            important_ngrams = ngram_results.get("important_ngrams", {})
+                            
+                            if model1_name in important_ngrams:
+                                model1_title_visible = True
+                                model1_title_value = f"#### Top {size_name} Used by {model1_name}"
+                                
+                                ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in important_ngrams[model1_name][:10]]
+                                model1_words_visible = True
+                                model1_words_value = ", ".join(ngram_list)
+                            
+                            if model2_name in important_ngrams:
+                                model2_title_visible = True
+                                model2_title_value = f"#### Top {size_name} Used by {model2_name}"
+                                
+                                ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in important_ngrams[model2_name][:10]]
+                                model2_words_visible = True
+                                model2_words_value = ", ".join(ngram_list)
+                            
+                            # Format similarity metrics if available
+                            if "comparisons" in ngram_results:
+                                comparison_key = f"{model1_name} vs {model2_name}"
+                                
+                                if comparison_key in ngram_results["comparisons"]:
+                                    metrics = ngram_results["comparisons"][comparison_key]
+                                    common_count = metrics.get("common_ngram_count", 0)
+                                    
+                                    similarity_title_visible = True
+                                    similarity_metrics_visible = True
+                                    similarity_metrics_value = f"""
+                                    - **Common {size_name}**: {common_count} {size_name.lower()} appear in both responses
+                                    """
                     
-                    if len(models) < 2:
+                    # If we don't have visualization data from any analysis
+                    if not visualization_area_visible:
                         return (
                             analysis_results,
                             False,
@@ -211,59 +320,23 @@ def create_app():
                             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.")
+                            gr.update(visible=True, value="❌ **No visualization data found.** Make sure to select at least one analysis type.")
                         )
-                    
-                    # 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
+                        gr.update(visible=prompt_title_visible, value=prompt_title_value),  # prompt_title
+                        gr.update(visible=models_compared_visible, value=models_compared_value),  # models_compared
+                        gr.update(visible=model1_title_visible, value=model1_title_value),  # model1_title
+                        gr.update(visible=model1_words_visible, value=model1_words_value),  # model1_words
+                        gr.update(visible=model2_title_visible, value=model2_title_value),  # model2_title
+                        gr.update(visible=model2_words_visible, value=model2_words_value),  # model2_words
+                        gr.update(visible=similarity_title_visible),  # similarity_metrics_title
+                        gr.update(visible=similarity_metrics_visible, value=similarity_metrics_value),  # similarity_metrics
                         False,  # status_message_visible
                         gr.update(visible=False)  # status_message
                     )
@@ -326,7 +399,7 @@ def create_app():
             # Run analysis with proper parameters
             run_analysis_btn.click(
                 fn=run_analysis,
-                inputs=[dataset_state, analysis_options, bow_top_slider, ngram_n, ngram_top],
+                inputs=[dataset_state, analysis_options, bow_top_slider],
                 outputs=[
                     analysis_results_state,
                     analysis_output,

processors/ngram_analysis.py

@@ -36,74 +36,93 @@ def compare_ngrams(texts, model_names, n=2, top_n=25):
     if not texts or len(texts) < 1:
         return result
 
-    # Create n-gram representations using CountVectorizer
-    vectorizer = CountVectorizer(
-        ngram_range=(n, n),  # Use the specified n-gram size
-        max_features=1000,
-        stop_words='english'
-    )
-
-    X = vectorizer.fit_transform(texts)
-
-    # Get feature names (n-grams)
-    feature_names = vectorizer.get_feature_names_out()
-
-    # Create n-gram count matrix
-    ngram_counts = {}
-    for i, model in enumerate(model_names):
-        counts = X[i].toarray()[0]
-        ngram_counts[model] = {}
-
-        # Store n-gram frequencies for this model
-        for j, ngram in enumerate(feature_names):
-            if counts[j] > 0:  # Only store n-grams that appear
-                ngram_counts[model][ngram] = int(counts[j])
-
-                # Add to n-gram count matrix
-                if ngram not in result["ngram_count_matrix"]:
-                    result["ngram_count_matrix"][ngram] = {}
-                result["ngram_count_matrix"][ngram][model] = int(counts[j])
-
-    # Find important n-grams for each model
-    for model, ngram_freq in ngram_counts.items():
-        # Sort by frequency
-        sorted_ngrams = sorted(ngram_freq.items(), key=lambda x: x[1], reverse=True)
-
-        # Store top N n-grams
-        result["important_ngrams"][model] = [
-            {"ngram": ngram, "count": count}
-            for ngram, count in sorted_ngrams[:top_n]
-        ]
-
-    # Calculate differential n-grams (n-grams with biggest frequency difference between models)
-    if len(model_names) >= 2:
-        model1, model2 = model_names[0], model_names[1]
-
-        # Calculate differences
-        diff_scores = {}
-        for ngram in result["ngram_count_matrix"]:
-            count1 = result["ngram_count_matrix"][ngram].get(model1, 0)
-            count2 = result["ngram_count_matrix"][ngram].get(model2, 0)
-
-            # Absolute difference
-            diff_scores[ngram] = abs(count1 - count2)
-
-        # Sort by difference
-        sorted_diffs = sorted(diff_scores.items(), key=lambda x: x[1], reverse=True)
-        result["differential_ngrams"] = [ngram for ngram, _ in sorted_diffs[:top_n]]
-
-        # Calculate overlap statistics
-        model1_ngrams = set(ngram_counts.get(model1, {}).keys())
-        model2_ngrams = set(ngram_counts.get(model2, {}).keys())
-        common_ngrams = model1_ngrams.intersection(model2_ngrams)
-
-        # Initialize comparisons if needed
-        if "comparisons" not in result:
-            result["comparisons"] = {}
-
-        comparison_key = f"{model1} vs {model2}"
-        result["comparisons"][comparison_key] = {
-            "common_ngram_count": len(common_ngrams)
-        }
+    # Convert n to integer if it's a string
+    if isinstance(n, str):
+        n = int(n)
+    
+    # Convert top_n to integer if necessary
+    if isinstance(top_n, str):
+        top_n = int(top_n)
+
+    try:
+        # Create n-gram representations using CountVectorizer
+        vectorizer = CountVectorizer(
+            ngram_range=(n, n),  # Use the specified n-gram size
+            max_features=1000,
+            stop_words='english'
+        )
+
+        X = vectorizer.fit_transform(texts)
+
+        # Get feature names (n-grams)
+        feature_names = vectorizer.get_feature_names_out()
+
+        # Create n-gram count matrix
+        ngram_counts = {}
+        for i, model in enumerate(model_names):
+            counts = X[i].toarray()[0]
+            ngram_counts[model] = {}
+
+            # Store n-gram frequencies for this model
+            for j, ngram in enumerate(feature_names):
+                if counts[j] > 0:  # Only store n-grams that appear
+                    ngram_counts[model][ngram] = int(counts[j])
+
+                    # Add to n-gram count matrix
+                    if ngram not in result["ngram_count_matrix"]:
+                        result["ngram_count_matrix"][ngram] = {}
+                    result["ngram_count_matrix"][ngram][model] = int(counts[j])
+
+        # Find important n-grams for each model
+        for model, ngram_freq in ngram_counts.items():
+            # Sort by frequency
+            sorted_ngrams = sorted(ngram_freq.items(), key=lambda x: x[1], reverse=True)
+
+            # Store top N n-grams
+            result["important_ngrams"][model] = [
+                {"ngram": ngram, "count": count}
+                for ngram, count in sorted_ngrams[:top_n]
+            ]
+
+        # Calculate differential n-grams (n-grams with biggest frequency difference between models)
+        if len(model_names) >= 2:
+            model1, model2 = model_names[0], model_names[1]
+
+            # Calculate differences
+            diff_scores = {}
+            for ngram in result["ngram_count_matrix"]:
+                count1 = result["ngram_count_matrix"][ngram].get(model1, 0)
+                count2 = result["ngram_count_matrix"][ngram].get(model2, 0)
+
+                # Absolute difference
+                diff_scores[ngram] = abs(count1 - count2)
+
+            # Sort by difference
+            sorted_diffs = sorted(diff_scores.items(), key=lambda x: x[1], reverse=True)
+            result["differential_ngrams"] = [ngram for ngram, _ in sorted_diffs[:top_n]]
+
+            # Calculate overlap statistics
+            model1_ngrams = set(ngram_counts.get(model1, {}).keys())
+            model2_ngrams = set(ngram_counts.get(model2, {}).keys())
+            common_ngrams = model1_ngrams.intersection(model2_ngrams)
+
+            # Initialize comparisons if needed
+            if "comparisons" not in result:
+                result["comparisons"] = {}
+
+            comparison_key = f"{model1} vs {model2}"
+            result["comparisons"][comparison_key] = {
+                "common_ngram_count": len(common_ngrams)
+            }
 
-    return result
+        return result
+    except Exception as e:
+        import traceback
+        error_msg = f"N-gram analysis error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        # Return basic structure with error
+        return {
+            "models": model_names,
+            "ngram_size": n,
+            "error": str(e)
+        }

ui/analysis_screen.py

@@ -5,19 +5,18 @@ 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.ngram_analysis import compare_ngrams
+from processors.ngram_analysis import compare_ngrams
 # from processors.bias_detection import compare_bias
 from processors.bow_analysis import compare_bow
 # from processors.metrics import calculate_similarity
 # from processors.diff_highlighter import highlight_differences
-from processors.ngram_analysis import compare_ngrams
 
 def create_analysis_screen():
     """
     Create the analysis options screen
     
     Returns:
-        tuple: (analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider)
+        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")
@@ -48,7 +47,19 @@ def create_analysis_screen():
             elem_id="bow_top_slider"
         )
         
-        # Parameters for each analysis type (these will be hidden/shown based on selections)
+        # Create N-gram parameters accessible at top level
+        ngram_n = gr.Radio(
+            choices=["1", "2", "3"], value="2", 
+            label="N-gram Size",
+            visible=False
+        )
+        ngram_top = gr.Slider(
+            minimum=5, maximum=30, value=10, step=1, 
+            label="Top N-grams to Display",
+            visible=False
+        )
+        
+        # Parameters for each analysis type
         with gr.Group() as analysis_params:
             # Topic modeling parameters
             with gr.Group(visible=False) as topic_params:
@@ -56,14 +67,11 @@ def create_analysis_screen():
                 topic_count = gr.Slider(minimum=2, maximum=10, value=3, step=1, 
                                        label="Number of Topics")
             
-            # N-gram parameters
+            # N-gram parameters group (using external ngram_n and ngram_top)
             with gr.Group(visible=False) as ngram_params:
                 gr.Markdown("### N-gram Parameters")
-                ngram_n = gr.Radio(choices=["1", "2", "3"], value="2", 
-                                  label="N-gram Size")
-                ngram_top = gr.Slider(minimum=5, maximum=30, value=10, step=1, 
-                                     label="Top N-grams to Display")
-            
+                # We're already using ngram_n and ngram_top defined above
+                
             # Bias detection parameters
             with gr.Group(visible=False) as bias_params:
                 gr.Markdown("### Bias Detection Parameters")
@@ -84,18 +92,21 @@ def create_analysis_screen():
                 
             # 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="Topic Modeling" in selected),
-                    ngram_params: gr.update(visible="N-gram Analysis" 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)
+                    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, similarity_params]
+                outputs=[topic_params, ngram_params, bias_params, similarity_params, ngram_n, ngram_top]
             )
         
         # Run analysis button
@@ -104,11 +115,10 @@ def create_analysis_screen():
         # Analysis output area - hidden JSON component to store raw results
         analysis_output = gr.JSON(label="Analysis Results", visible=False)
     
-    # Return the bow_top_slider directly so app.py can access it
-    # Note: Removed the visualization_container from return values since we'll pre-create it
+    # Return the components needed by app.py
     return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top
 
-# function
+# Process analysis request function
 def process_analysis_request(dataset, selected_analyses, parameters):
     """
     Process the analysis request and run selected analyses

visualization/ngram_visualizer.py

@@ -7,7 +7,31 @@ from plotly.subplots import make_subplots
 
 
 def create_ngram_visualization(analysis_results):
+    # If no components were added other than header, show a message
+    if len(output_components) <= 1:
+        output_components.append(gr.Markdown(f"No detailed N-gram analysis found in results."))
+
+    return output_components
+
+
+def process_and_visualize_ngram_analysis(analysis_results):
     """
+    Process the n-gram 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 n-gram analysis results")
+        return create_ngram_visualization(analysis_results)
+    except Exception as e:
+        import traceback
+        error_msg = f"N-gram visualization error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return [gr.Markdown(f"**Error during n-gram visualization:**\n\n```\n{error_msg}\n```")]"""
     Create visualizations for n-gram analysis results
 
     Args:
@@ -27,6 +51,11 @@ def create_ngram_visualization(analysis_results):
         # Process N-gram analysis if available
         if "ngram_analysis" in analyses:
             ngram_results = analyses["ngram_analysis"]
+            
+            # Check if there's an error in the analysis
+            if "error" in ngram_results:
+                output_components.append(gr.Markdown(f"**Error in N-gram analysis:** {ngram_results['error']}"))
+                continue
 
             # Show models being compared
             models = ngram_results.get("models", [])
@@ -40,25 +69,38 @@ def create_ngram_visualization(analysis_results):
                 # Get important n-grams for each model
                 important_ngrams = ngram_results.get("important_ngrams", {})
 
-                # Prepare data for plotting important n-grams
+                # Display important n-grams for each model
                 if important_ngrams:
                     for model_name, ngrams in important_ngrams.items():
-                        df = pd.DataFrame(ngrams)
-
-                        # Create bar chart for top n-grams
-                        fig = px.bar(df, x='ngram', y='count',
-                                     title=f"Top {size_name} Used by {model_name}",
-                                     labels={'ngram': 'N-gram', 'count': 'Frequency'},
-                                     height=400)
-
-                        # Improve layout
-                        fig.update_layout(
-                            xaxis_title="N-gram",
-                            yaxis_title="Frequency",
-                            xaxis={'categoryorder': 'total descending'}
-                        )
-
-                        output_components.append(gr.Plot(value=fig))
+                        output_components.append(gr.Markdown(f"#### Top {size_name} Used by {model_name}"))
+                        
+                        if ngrams:
+                            # Create a formatted list of n-grams for display
+                            ngram_list = [f"**{item['ngram']}** ({item['count']})" for item in ngrams[:10]]
+                            output_components.append(gr.Markdown(", ".join(ngram_list)))
+                        else:
+                            output_components.append(gr.Markdown("No significant n-grams found."))
+
+                        # Only if we have enough data, create a bar chart
+                        if len(ngrams) >= 3:
+                            try:
+                                df = pd.DataFrame(ngrams)
+                                # Create bar chart for top n-grams
+                                fig = px.bar(df[:10], x='ngram', y='count',
+                                             title=f"Top {size_name} Used by {model_name}",
+                                             labels={'ngram': 'N-gram', 'count': 'Frequency'},
+                                             height=400)
+
+                                # Improve layout
+                                fig.update_layout(
+                                    xaxis_title="N-gram",
+                                    yaxis_title="Frequency",
+                                    xaxis={'categoryorder': 'total descending'}
+                                )
+
+                                output_components.append(gr.Plot(value=fig))
+                            except Exception as e:
+                                output_components.append(gr.Markdown(f"Visualization error: {str(e)}"))
 
                 # Visualize differential n-grams (n-grams with biggest frequency difference)
                 diff_ngrams = ngram_results.get("differential_ngrams", [])
@@ -71,42 +113,17 @@ def create_ngram_visualization(analysis_results):
                     model1, model2 = models[0], models[1]
                     diff_data = []
 
-                    for ngram in diff_ngrams[:15]:  # Limit to top 15 for readability
+                    for ngram in diff_ngrams[:10]:  # Limit to top 10 for readability
                         if ngram in ngram_matrix:
                             counts = ngram_matrix[ngram]
-                            diff_data.append({
-                                "ngram": ngram,
-                                model1: counts.get(model1, 0),
-                                model2: counts.get(model2, 0)
-                            })
-
-                    if diff_data:
-                        diff_df = pd.DataFrame(diff_data)
-
-                        # Create grouped bar chart
-                        fig = go.Figure()
-                        fig.add_trace(go.Bar(
-                            x=diff_df['ngram'],
-                            y=diff_df[model1],
-                            name=model1,
-                            marker_color='indianred'
-                        ))
-                        fig.add_trace(go.Bar(
-                            x=diff_df['ngram'],
-                            y=diff_df[model2],
-                            name=model2,
-                            marker_color='lightsalmon'
-                        ))
-
-                        fig.update_layout(
-                            title=f"{size_name} Frequency Comparison",
-                            xaxis_title="N-gram",
-                            yaxis_title="Frequency",
-                            barmode='group',
-                            height=500
-                        )
-
-                        output_components.append(gr.Plot(value=fig))
+                            model1_count = counts.get(model1, 0)
+                            model2_count = counts.get(model2, 0)
+                            
+                            # Only include if there's a meaningful difference
+                            if abs(model1_count - model2_count) > 0:
+                                output_components.append(gr.Markdown(
+                                    f"- **{ngram}**: {model1}: {model1_count}, {model2}: {model2_count}"
+                                ))
 
                 # Add similarity comparison if available
                 if "comparisons" in ngram_results:
@@ -123,28 +140,4 @@ def create_ngram_visualization(analysis_results):
 
                         output_components.append(gr.Markdown(metrics_text))
 
-    # If no components were added other than header, show a message
-    if len(output_components) <= 1:
-        output_components.append(gr.Markdown(f"No detailed N-gram analysis found in results."))
-
-    return output_components
-
-
-def process_and_visualize_ngram_analysis(analysis_results):
-    """
-    Process the n-gram 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 n-gram analysis results")
-        return create_ngram_visualization(analysis_results)
-    except Exception as e:
-        import traceback
-        error_msg = f"N-gram visualization error: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return [gr.Markdown(f"**Error during n-gram visualization:**\n\n```\n{error_msg}\n```")]
+