update

app.py

@@ -63,346 +63,408 @@ def create_app():
         
         # 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"
+            # ...existing code...
+        
+            # Analysis Tab
+            with gr.Tab("Analysis"):
+                # Use create_analysis_screen to get UI components including visualization container
+                analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count = create_analysis_screen()
                 
-                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"
+                # 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)
                 
-            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, 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")
-            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_analysis, bow_top, ngram_n, ngram_top, topic_count):
-                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,
-                        "topic_count": topic_count
-                    }
-                    print(f"Running analysis with selected type: {selected_analysis}")
-                    print("Parameters:", 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"]:
-                        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 a different analysis option.")
-                        )
-                    
-                    # Extract information to display in components
-                    prompt = list(analysis_results["analyses"].keys())[0]
-                    analyses = analysis_results["analyses"][prompt]
-                    
-                    # 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 = ""
-                    
-                    # 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
-                        bow_results = analyses["bag_of_words"]
-                        models = bow_results.get("models", [])
+                # 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_analysis, bow_top, ngram_n, ngram_top, topic_count):
+                    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
+                            )
                         
-                        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", {})
+                        parameters = {
+                            "bow_top": bow_top,
+                            "ngram_n": ngram_n,
+                            "ngram_top": ngram_top,
+                            "topic_count": topic_count
+                        }
+                        print(f"Running analysis with selected type: {selected_analysis}")
+                        print("Parameters:", parameters)
+                        
+                        # Process the analysis request - passing selected_analysis as a string
+                        analysis_results, _ = process_analysis_request(dataset, selected_analysis, parameters)
+                        
+                        # If there's an error or no results
+                        if not analysis_results or "analyses" not in analysis_results or not analysis_results["analyses"]:
+                            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 a different analysis option.")
+                            )
+                        
+                        # Extract information to display in components
+                        prompt = list(analysis_results["analyses"].keys())[0]
+                        analyses = analysis_results["analyses"][prompt]
+                        
+                        # 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 = ""
+                        
+                        # Check for messages from placeholder analyses
+                        if "message" in analyses:
+                            return (
+                                analysis_results,
+                                False,
+                                False,
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                gr.update(visible=False),
+                                True,
+                                gr.update(visible=True, value=f"ℹ️ **{analyses['message']}**")
+                            )
+                        
+                        # Process based on the selected analysis type
+                        if selected_analysis == "Bag of Words" and "bag_of_words" in analyses:
+                            visualization_area_visible = True
+                            bow_results = analyses["bag_of_words"]
+                            models = bow_results.get("models", [])
                             
-                            if model1_name in important_words:
-                                model1_title_visible = True
-                                model1_title_value = f"#### Top Words Used by {model1_name}"
+                            if len(models) >= 2:
+                                prompt_title_visible = True
+                                prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
                                 
-                                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}"
+                                models_compared_visible = True
+                                models_compared_value = f"### Comparing responses from {models[0]} and {models[1]}"
                                 
-                                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)
+                                # Extract and format information for display
+                                model1_name = models[0]
+                                model2_name = models[1]
                                 
-                                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
-                                """
+                                # Format important words for each model
+                                important_words = bow_results.get("important_words", {})
                                 
-                    # Check for N-gram analysis
-                    if "ngram_analysis" in analyses:
-                        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}"
+                                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)
                                 
-                                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}"
+                                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)
                                 
-                                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:
+                                # Format similarity metrics
+                                comparisons = bow_results.get("comparisons", {})
                                 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)
+
+                                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"""
-                                    - **Common {size_name}**: {common_count} {size_name.lower()} appear in both responses
+                                    - **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 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)}")
+                        # Check for N-gram analysis
+                        elif selected_analysis == "N-gram Analysis" and "ngram_analysis" in analyses:
+                            visualization_area_visible = True
+                            ngram_results = analyses["ngram_analysis"]
+                            models = ngram_results.get("models", [])
+                            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]
                                 
-                                if topic_info:
+                                # 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 = "#### Discovered Topics"
+                                    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 = "\n".join(topic_info)
+                                    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
+                                        """
+                        
+                        # Check for Topic Modeling analysis
+                        elif selected_analysis == "Topic Modeling" and "topic_modeling" in analyses:
+                            visualization_area_visible = True
+                            topic_results = analyses["topic_modeling"]
+                            models = topic_results.get("models", [])
+                            method = topic_results.get("method", "lda").upper()
+                            n_topics = topic_results.get("n_topics", 3)
                             
-                            # Get topic distributions for models
-                            model_topics = topic_results.get("model_topics", {})
+                            if len(models) >= 2:
+                                prompt_title_visible = True
+                                prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                                
+                                models_compared_visible = True
+                                models_compared_value = f"### Topic Modeling Analysis ({method}, {n_topics} topics)"
+                                
+                                # Extract and format topic information
+                                topics = topic_results.get("topics", [])
+                                
+                                if topics:
+                                    # Format topic info for display
+                                    topic_info = []
+                                    for topic in topics[:3]:  # Show first 3 topics
+                                        topic_id = topic.get("id", 0)
+                                        words = topic.get("words", [])[:5]  # Top 5 words per topic
+                                        
+                                        if words:
+                                            topic_info.append(f"**Topic {topic_id+1}**: {', '.join(words)}")
+                                    
+                                    if topic_info:
+                                        model1_title_visible = True
+                                        model1_title_value = "#### Discovered Topics"
+                                        model1_words_visible = True
+                                        model1_words_value = "\n".join(topic_info)
+                                
+                                # Get topic distributions for models
+                                model_topics = topic_results.get("model_topics", {})
+                                
+                                if model_topics:
+                                    model1_name = models[0]
+                                    model2_name = models[1]
+                                    
+                                    # Format topic distribution info
+                                    if model1_name in model_topics and model2_name in model_topics:
+                                        model2_title_visible = True
+                                        model2_title_value = "#### Topic Distribution"
+                                        model2_words_visible = True
+                                        
+                                        # Simple distribution display
+                                        dist1 = model_topics[model1_name]
+                                        dist2 = model_topics[model2_name]
+                                        
+                                        model2_words_value = f"""
+                                        **{model1_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist1[:3])])}
+                                        
+                                        **{model2_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist2[:3])])}
+                                        """
+                                        
+                                # Add similarity metrics if available
+                                comparisons = topic_results.get("comparisons", {})
+                                if comparisons:
+                                    comparison_key = f"{model1_name} vs {model2_name}"
+                                    
+                                    if comparison_key in comparisons:
+                                        metrics = comparisons[comparison_key]
+                                        js_div = metrics.get("js_divergence", 0)
+                                        
+                                        similarity_title_visible = True
+                                        similarity_metrics_visible = True
+                                        similarity_metrics_value = f"""
+                                        - **Topic Distribution Divergence**: {js_div:.4f} (lower means more similar topic distributions)
+                                        """
+                        
+                        # Check for Classifier analysis
+                        elif selected_analysis == "Classifier" and "classifier" in analyses:
+                            visualization_area_visible = True
+                            classifier_results = analyses["classifier"]
+                            models = classifier_results.get("models", [])
                             
-                            if model_topics:
+                            if len(models) >= 2:
+                                prompt_title_visible = True
+                                prompt_title_value = f"## Analysis of Prompt: \"{prompt[:100]}...\""
+                                
+                                models_compared_visible = True
+                                models_compared_value = f"### Classifier Analysis for {models[0]} and {models[1]}"
+                                
+                                # Extract and format classifier information
                                 model1_name = models[0]
                                 model2_name = models[1]
                                 
-                                # 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
+                                # Display classifications for each model
+                                classifications = classifier_results.get("classifications", {})
+                                
+                                if classifications:
+                                    model1_title_visible = True
+                                    model1_title_value = f"#### Classification Results"
+                                    model1_words_visible = True
                                     
-                                    # Simple distribution display
-                                    dist1 = model_topics[model1_name]
-                                    dist2 = model_topics[model2_name]
+                                    model1_results = classifications.get(model1_name, {})
+                                    model2_results = classifications.get(model2_name, {})
                                     
-                                    model2_words_value = f"""
-                                    **{model1_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist1[:3])])}
+                                    model1_words_value = f"""
+                                    **{model1_name}**:
+                                    - Formality: {model1_results.get('formality', 'N/A')}
+                                    - Sentiment: {model1_results.get('sentiment', 'N/A')}
+                                    - Complexity: {model1_results.get('complexity', 'N/A')}
                                     
-                                    **{model2_name}**: {', '.join([f"Topic {i+1}: {v:.2f}" for i, v in enumerate(dist2[:3])])}
+                                    **{model2_name}**:
+                                    - Formality: {model2_results.get('formality', 'N/A')}
+                                    - Sentiment: {model2_results.get('sentiment', 'N/A')}
+                                    - Complexity: {model2_results.get('complexity', 'N/A')}
                                     """
                                     
-                            # 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)
+                                    # Show comparison
+                                    model2_title_visible = True
+                                    model2_title_value = f"#### Classification Comparison"
+                                    model2_words_visible = True
                                     
-                                    similarity_title_visible = True
-                                    similarity_metrics_visible = True
-                                    similarity_metrics_value = f"""
-                                    - **Topic Distribution Divergence**: {js_div:.4f} (lower means more similar topic distributions)
-                                    """
+                                    differences = classifier_results.get("differences", {})
+                                    model2_words_value = "\n".join([
+                                        f"- **{category}**: {diff}" 
+                                        for category, diff in differences.items()
+                                    ])
+                        
+                        # If we don't have visualization data from any analysis
+                        if not visualization_area_visible:
+                            return (
+                                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 visualization data found.** Make sure to select a valid analysis option.")
+                            )
+
+                        # 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=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
+                        )
                     
-                    # If we don't have visualization data from any analysis
-                    if not visualization_area_visible:
+                    except Exception as e:
+                        import traceback
+                        error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
+                        print(error_msg)
+                        
                         return (
-                            analysis_results,
-                            False,
-                            False,
+                            {"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),
@@ -412,103 +474,87 @@ def create_app():
                             gr.update(visible=False),
                             gr.update(visible=False),
                             gr.update(visible=False),
-                            True,
-                            gr.update(visible=True, value="❌ **No visualization data found.** Make sure to select a valid analysis option.")
+                            True,  # status_message_visible
+                            gr.update(visible=True, value=f"❌ **Error during analysis:**\n\n```\n{str(e)}\n```")  # status_message
                         )
-
-                    # 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=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
+                    
+        # Add a new LLM Analysis tab
+        with gr.Tab("LLM Analysis"):
+            gr.Markdown("## LLM-Based Response Analysis")
+            
+            with gr.Row():
+                with gr.Column():
+                    llm_analysis_type = gr.Radio(
+                        choices=["Response Quality", "Response Comparison", "Factual Accuracy"],
+                        label="Analysis Type",
+                        value="Response Comparison"
                     )
+                    
+                    llm_model = gr.Dropdown(
+                        choices=["OpenAI GPT-4", "Anthropic Claude", "Local LLM"],
+                        label="Analysis Model",
+                        value="OpenAI GPT-4"
+                    )
+                    
+                    run_llm_analysis_btn = gr.Button("Run LLM Analysis", variant="primary")
                 
-                except Exception as e:
-                    import traceback
-                    error_msg = f"Error in analysis: {str(e)}\n{traceback.format_exc()}"
-                    print(error_msg)
+                with gr.Column():
+                    llm_analysis_prompt = gr.Textbox(
+                        label="Custom Analysis Instructions (Optional)",
+                        placeholder="Enter any specific instructions for the analysis...",
+                        lines=3
+                    )
                     
+                    llm_analysis_status = gr.Markdown("*No analysis has been run*")
+            
+            llm_analysis_result = gr.Markdown(visible=False)
+            
+            # Placeholder function for LLM analysis
+            def run_llm_analysis(dataset, analysis_type, model, custom_prompt):
+                if not dataset or "entries" not in dataset or not dataset["entries"]:
                     return (
-                        {"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
+                        gr.update(visible=True, value="❌ **Error:** No dataset loaded. Please create or load a dataset first."),
+                        gr.update(visible=False)
                     )
+                
+                # Placeholder for actual implementation
+                return (
+                    gr.update(visible=True, value="⏳ **Implementation in progress**\n\nLLM-based analysis will be available in a future update."),
+                    gr.update(visible=False)
+                )
+            
+            # Connect the run button to the analysis function
+            run_llm_analysis_btn.click(
+                fn=run_llm_analysis,
+                inputs=[dataset_state, llm_analysis_type, llm_model, llm_analysis_prompt],
+                outputs=[llm_analysis_status, llm_analysis_result]
+            )
 
+        # Visibility update functions - unchanged
         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
-            ]
-        )
+            # ...existing code...
 
-        # 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
-            ]
-        )
+            # Run analysis with proper parameters
+            run_analysis_btn.click(
+                fn=run_analysis,
+                inputs=[dataset_state, analysis_options, bow_top_slider, ngram_n, ngram_top, topic_count],
+                outputs=[
+                    analysis_results_state,
+                    analysis_output,
+                    visualization_area_visible,
+                    analysis_title,
+                    prompt_title,
+                    models_compared,
+                    model1_title,
+                    model1_words,
+                    model2_title,
+                    model2_words,
+                    similarity_metrics_title,
+                    similarity_metrics,
+                    status_message_visible,
+                    status_message
+                ]
+            )
     
     return app
 

processors/text_classifiers.py

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

ui/analysis_screen.py

@@ -9,194 +9,156 @@ from processors.ngram_analysis import compare_ngrams
 from processors.bow_analysis import compare_bow
 # from processors.metrics import calculate_similarity
 # from processors.diff_highlighter import highlight_differences
+# Add this import at the top
+from analysis.text_classifiers import classify_formality, classify_sentiment, classify_complexity, compare_classifications
 
 def create_analysis_screen():
     """
-    Create the analysis options screen
+    Create the UI components for the analysis options screen.
     
     Returns:
-        tuple: (analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count)
+        tuple: The analysis UI components
     """
-    with gr.Column() as analysis_screen:
+    with gr.Column() as analysis_container:
         gr.Markdown("## Analysis Options")
-        gr.Markdown("Select which analysis you want to run on the LLM responses.")
         
-        # Change from CheckboxGroup to Radio for analysis selection
-        with gr.Group():
-            analysis_options = gr.Radio(
-                choices=[
-                    "Bag of Words",
-                    "N-gram Analysis",
-                    "Topic Modeling",
-                    "Bias Detection",
-                    "Classifier",  # New option for future development
-                    "LLM Analysis"  # New option for future development
-                ],
-                value="Bag of Words",  # Default selection
-                label="Select Analysis Type"
-            )
-        
-        # Create slider directly here for easier access
-        gr.Markdown("### Bag of Words Parameters")
-        bow_top_slider = gr.Slider(
-            minimum=10, maximum=100, value=25, step=5, 
-            label="Top Words to Compare", 
-            elem_id="bow_top_slider"
-        )
-        
-        # 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
+        # Change from checkboxes to radio buttons for analysis type
+        analysis_options = gr.Radio(
+            choices=["Bag of Words", "N-gram Analysis", "Topic Modeling", "Classifier"],
+            label="Analysis Type",
+            value="Bag of Words"
         )
         
-        # Create topic modeling parameter accessible at top level
-        topic_count = gr.Slider(
-            minimum=2, maximum=10, value=3, step=1,
-            label="Number of Topics",
-            visible=False
-        )
-        
-        # Parameters for each analysis type
-        with gr.Group() as analysis_params:
-            # Topic modeling parameters
-            with gr.Group(visible=False) as topic_params:
-                gr.Markdown("### Topic Modeling Parameters")
-                # We'll use the topic_count defined above
+        # Parameters for different analysis types
+        with gr.Column() as analysis_params:
+            bow_top_slider = gr.Slider(minimum=5, maximum=50, step=5, value=20, 
+                                      label="Number of top words to display (Bag of Words)")
             
-            # N-gram parameters group (using external ngram_n and ngram_top)
-            with gr.Group(visible=False) as ngram_params:
-                gr.Markdown("### N-gram Parameters")
-                # 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")
-                bias_methods = gr.CheckboxGroup(
-                    choices=["Sentiment Analysis", "Partisan Leaning", "Framing Analysis"],
-                    value=["Sentiment Analysis", "Partisan Leaning"],
-                    label="Bias Detection Methods"
-                )
+            ngram_n = gr.Slider(minimum=1, maximum=5, step=1, value=2, 
+                               label="N-gram size")
             
-            # 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*")
+            ngram_top = gr.Slider(minimum=5, maximum=50, step=5, value=15, 
+                                 label="Number of top n-grams to display")
             
-            # 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 analysis
-            def update_params_visibility(selected):
-                return {
-                    topic_params: gr.update(visible=selected == "Topic Modeling"),
-                    ngram_params: gr.update(visible=selected == "N-gram Analysis"),
-                    bias_params: gr.update(visible=selected == "Bias Detection"),
-                    classifier_params: gr.update(visible=selected == "Classifier"),
-                    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, 
-                    classifier_params,
-                    llm_params,
-                    ngram_n, 
-                    ngram_top, 
-                    topic_count,
-                    bow_top_slider
-                ]
-            )
+            topic_count = gr.Slider(minimum=2, maximum=10, step=1, value=3,
+                                   label="Number of topics (Topic Modeling)")
         
-        # Run analysis button
-        run_analysis_btn = gr.Button("Run Analysis", variant="primary", size="large")
+        run_analysis_btn = gr.Button("Run Analysis", size="lg", variant="primary")
+        
+        # Output area - JSON view for debugging or advanced users
+        analysis_output = gr.JSON(value={}, visible=False, label="Raw Analysis Results")
         
-        # Analysis output area - hidden JSON component to store raw results
-        analysis_output = gr.JSON(label="Analysis Results", visible=False)
-    
-    # Return the components needed by app.py
     return analysis_options, analysis_params, run_analysis_btn, analysis_output, bow_top_slider, ngram_n, ngram_top, topic_count
 
 # Process analysis request function
 def process_analysis_request(dataset, selected_analysis, parameters):
     """
-    Process the analysis request and run selected analysis
+    Process the analysis request based on the selected options.
+    
+    Args:
+        dataset (dict): The input dataset
+        selected_analysis (str): The selected analysis type
+        parameters (dict): Additional parameters for the analysis
+    
+    Returns:
+        tuple: A tuple containing (analysis_results, visualization_data)
     """
-    try:
-        print(f"Processing analysis request with: {selected_analysis}")
-        print(f"Parameters: {parameters}")
-
-        if not dataset or "entries" not in dataset or not dataset["entries"]:
-            return {}, gr.update(visible=True,
-                                 value=json.dumps({"error": "No dataset provided or dataset is empty"}, indent=2))
-
-        analysis_results = {"analyses": {}}
-
-        # Extract prompt and responses
-        prompt = dataset["entries"][0]["prompt"]
-        response_texts = [entry["response"] for entry in dataset["entries"]]
-        model_names = [entry["model"] for entry in dataset["entries"]]
-
-        print(f"Analyzing prompt: '{prompt[:50]}...'")
-        print(f"Models: {model_names}")
-
-        analysis_results["analyses"][prompt] = {}
-
-        # Run Bag of Words analysis if selected
-        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
-        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"
+    if not dataset or "entries" not in dataset or not dataset["entries"]:
+        return {}, None
+        
+    # Initialize the results structure
+    results = {"analyses": {}}
+    
+    # Get the prompt text from the first entry
+    prompt_text = dataset["entries"][0].get("prompt", "")
+    if not prompt_text:
+        return {"error": "No prompt found in dataset"}, None
+        
+    # Initialize the analysis container for this prompt
+    results["analyses"][prompt_text] = {}
+    
+    # Get model names and responses
+    model1_name = dataset["entries"][0].get("model", "Model 1")
+    model2_name = dataset["entries"][1].get("model", "Model 2")
+    
+    model1_response = dataset["entries"][0].get("response", "")
+    model2_response = dataset["entries"][1].get("response", "")
+    
+    # Process based on the selected analysis type
+    if selected_analysis == "Bag of Words":
+        # Perform Bag of Words analysis
+        results["analyses"][prompt_text]["bag_of_words"] = {
+            "models": [model1_name, model2_name],
+            "important_words": {
+                model1_name: extract_important_words(model1_response, top_n=parameters.get("bow_top", 20)),
+                model2_name: extract_important_words(model2_response, top_n=parameters.get("bow_top", 20))
+            },
+            "comparisons": {
+                f"{model1_name} vs {model2_name}": calculate_text_similarity(model1_response, model2_response)
+            }
+        }
+        
+    elif selected_analysis == "N-gram Analysis":
+        # Perform N-gram analysis
+        ngram_size = parameters.get("ngram_n", 2)
+        top_n = parameters.get("ngram_top", 15)
+        
+        results["analyses"][prompt_text]["ngram_analysis"] = {
+            "models": [model1_name, model2_name],
+            "ngram_size": ngram_size,
+            "important_ngrams": {
+                model1_name: extract_ngrams(model1_response, n=ngram_size, top_n=top_n),
+                model2_name: extract_ngrams(model2_response, n=ngram_size, top_n=top_n)
+            },
+            "comparisons": {
+                f"{model1_name} vs {model2_name}": compare_ngrams(model1_response, model2_response, n=ngram_size)
+            }
+        }
+        
+    elif selected_analysis == "Topic Modeling":
+        # Perform topic modeling analysis
+        topic_count = parameters.get("topic_count", 3)
+        
+        try:
+            topic_results = perform_topic_modeling(
+                [model1_response, model2_response], 
+                model_names=[model1_name, model2_name],
+                n_topics=topic_count
+            )
             
-        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)
+            results["analyses"][prompt_text]["topic_modeling"] = topic_results
+        except Exception as e:
+            import traceback
+            print(f"Topic modeling error: {str(e)}\n{traceback.format_exc()}")
+            results["analyses"][prompt_text]["topic_modeling"] = {
+                "models": [model1_name, model2_name],
+                "error": str(e),
+                "message": "Topic modeling failed. Try with longer text or different parameters."
+            }
+    
+    elif selected_analysis == "Classifier":
+        # Perform classifier analysis (placeholder implementation)
+        results["analyses"][prompt_text]["classifier"] = {
+            "models": [model1_name, model2_name],
+            "classifications": {
+                model1_name: {
+                    "formality": classify_formality(model1_response),
+                    "sentiment": classify_sentiment(model1_response),
+                    "complexity": classify_complexity(model1_response)
+                },
+                model2_name: {
+                    "formality": classify_formality(model2_response),
+                    "sentiment": classify_sentiment(model2_response),
+                    "complexity": classify_complexity(model2_response)
+                }
+            },
+            "differences": compare_classifications(model1_response, model2_response)
+        }
+    
+    else:
+        # Unknown analysis type
+        results["analyses"][prompt_text]["message"] = "Please select a valid analysis type."
+    
+    # Return both the analysis results and a placeholder for visualization data
+    return results, None
 
-        # Return results and update the output component
-        return analysis_results, gr.update(visible=False, value=analysis_results)  # Hide the raw JSON
-    except Exception as e:
-        import traceback
-        error_msg = f"Analysis error: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return {}, gr.update(visible=True, value=json.dumps({"error": error_msg}, indent=2))