update

app.py

@@ -1,138 +1,58 @@
 import gradio as gr
 import os
-import json
-
-# Import UI components
-from ui.main_screen import create_main_screen
-#from ui.dataset_input import create_dataset_input, process_dataset_submission, load_example_dataset
-#from ui.analysis_screen import create_analysis_screen, process_analysis_request
-#from ui.visualization_screen import create_visualization_screen, update_visualization
-#from ui.classification_screen import create_classification_screen, update_classification_results
-#from ui.report_screen import create_report_screen, update_report, update_with_llm_analysis
-
-# Import utility functions
-#from utils.llm_analyzer import run_llm_analysis
-#from utils.report_generator import create_report, export_report
-#from utils.text_dataset_parser import get_available_text_datasets
+from ui.dataset_input import create_dataset_input, load_example_dataset
+from ui.analysis_screen import process_analysis_request
 
 def create_app():
     """
-    Create the complete Gradio app with all tabs
+    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", theme=gr.themes.Soft()) as app:
-        # Application states to share data between tabs
+    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({})
-        visualization_state = gr.State({})
-        classification_results_state = gr.State({})
-        report_state = gr.State({})
-        
-        # Create tabs
-        with gr.Tabs() as tabs:
-            with gr.Tab("Home", id="home_tab"):
-                welcome_msg, about_info, get_started_btn = create_main_screen()
-                
-            with gr.Tab("Dataset Input", id="dataset_tab"):
-                dataset_inputs, example_dropdown, load_example_btn, analyze_btn = create_dataset_input()
-                
-            with gr.Tab("Analysis", id="analysis_tab"):
-                analysis_options, analysis_params, run_analysis_btn, analysis_output = create_analysis_screen()
-                
-            with gr.Tab("Visualization", id="viz_tab"):
-                viz_options, viz_params, viz_output = create_visualization_screen()
-                
-            with gr.Tab("Classification", id="classification_tab"):
-                classifier_options, classifier_params, run_classifier_btn, classifier_output = create_classification_screen()
-                
-            with gr.Tab("Report", id="report_tab"):
-                report_options, generate_report_btn, llm_analysis_btn, export_btn, report_output = create_report_screen()
-        
-        # Set up event handlers
-        
-        # Main screen navigation
-        get_started_btn.click(
-            fn=lambda: gr.Tabs.update(selected="dataset_tab"),
-            outputs=[tabs]
-        )
-        
-        # Dataset processing
-        analyze_btn.click(
-            fn=process_dataset_submission,
-            inputs=dataset_inputs,
-            outputs=[dataset_state, gr.Tabs.update(selected="analysis_tab")]
-        )
-        
-        # Load example dataset
-        load_example_btn.click(
-            fn=load_example_dataset,
-            inputs=[example_dropdown],
-            outputs=[dataset_inputs]
-        )
-        
-        # Analysis
-        run_analysis_btn.click(
-            fn=process_analysis_request,
-            inputs=[dataset_state, analysis_options, analysis_params],
-            outputs=[analysis_results_state, analysis_output]
-        )
-        
-        # Visualization updates based on analysis results
-        tabs.select(
-            fn=lambda tab, results: update_visualization(results, viz_options.value, viz_params.value) if tab == "viz_tab" and results else None,
-            inputs=["selected", analysis_results_state],
-            outputs=[viz_output]
-        )
-        
-        viz_options.change(
-            fn=update_visualization,
-            inputs=[analysis_results_state, viz_options, viz_params],
-            outputs=[viz_output]
-        )
-        
-        # Classification
-        run_classifier_btn.click(
-            fn=update_classification_results,
-            inputs=[dataset_state, classifier_options, classifier_params],
-            outputs=[classification_results_state, classifier_output]
-        )
         
-        # Report generation
-        generate_report_btn.click(
-            fn=lambda results, class_results, options: update_report(create_report(results, class_results), options),
-            inputs=[analysis_results_state, classification_results_state, report_options],
-            outputs=[report_state, report_output]
-        )
-        
-        # LLM meta-analysis
-        llm_analysis_btn.click(
-            fn=lambda report: update_with_llm_analysis(report, run_llm_analysis(report)),
-            inputs=[report_state],
-            outputs=[report_state, report_output]
-        )
-        
-        # Export report
-        export_btn.click(
-            fn=lambda report, format: export_report(report, format),
-            inputs=[report_state, gr.Dropdown(choices=["md", "html", "pdf"], value="md", label="Export Format")],
-            outputs=[]
-        )
-        
-    return app
-
-def main():
-    """
-    Main function to launch the Gradio app
-    """
-    # Create necessary directories
-    os.makedirs(os.path.join("dataset", "text_datasets"), exist_ok=True)
-    os.makedirs("reports", exist_ok=True)
+        # Dataset Input Tab
+        with gr.Tab("Dataset Input"):
+            dataset_inputs, example_dropdown, load_example_btn, create_btn, prompt, response1, model1, response2, model2 = create_dataset_input()
+            
+            # Load example dataset
+            load_example_btn.click(
+                fn=load_example_dataset,
+                inputs=[example_dropdown],
+                outputs=[dataset_inputs]
+            )
+            
+            # Save dataset to state
+            create_btn.click(
+                fn=lambda p, r1, m1, r2, m2: {"entries": [{"prompt": p, "response": r1, "model": m1}, {"prompt": p, "response": r2, "model": m2}]},
+                inputs=[prompt, response1, model1, response2, model2],
+                outputs=[dataset_state]
+            )
+        
+        # Analysis Tab
+        with gr.Tab("Analysis"):
+            analysis_options = gr.CheckboxGroup(
+                choices=["Bag of Words"],
+                value=["Bag of Words"],
+                label="Select Analyses to Run"
+            )
+            run_analysis_btn = gr.Button("Run Analysis", variant="primary")
+            analysis_output = gr.JSON(label="Analysis Results", visible=False)
+            
+            # Run analysis
+            run_analysis_btn.click(
+                fn=process_analysis_request,
+                inputs=[dataset_state, analysis_options, {}],
+                outputs=[analysis_results_state, analysis_output]
+            )
     
-    # Create and launch app
-    app = create_app()
-    app.launch(share=True)
+    return app
 
 if __name__ == "__main__":
-    main()
+    # Create and launch the app
+    app = create_app()
+    app.launch()

processors/bow_analysis.py

@@ -0,0 +1,225 @@
+from sklearn.feature_extraction.text import CountVectorizer
+import numpy as np
+from collections import Counter
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+from nltk.tokenize import word_tokenize
+
+# Download necessary NLTK data
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+    
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords')
+    
+try:
+    nltk.data.find('corpora/wordnet')
+except LookupError:
+    nltk.download('wordnet')
+
+def preprocess_text(text):
+    """
+    Preprocess text for bag of words analysis
+    
+    Args:
+        text (str): Input text
+        
+    Returns:
+        str: Preprocessed text
+    """
+    # Convert to lowercase
+    text = text.lower()
+    
+    # Remove special characters and digits
+    text = re.sub(r'[^a-zA-Z\s]', '', text)
+    
+    # Tokenize
+    tokens = word_tokenize(text)
+    
+    # Remove stopwords
+    stop_words = set(stopwords.words('english'))
+    tokens = [token for token in tokens if token not in stop_words]
+    
+    # Lemmatize
+    lemmatizer = WordNetLemmatizer()
+    tokens = [lemmatizer.lemmatize(token) for token in tokens]
+    
+    # Filter out short words (likely not meaningful)
+    tokens = [token for token in tokens if len(token) > 2]
+    
+    # Join back to string
+    return ' '.join(tokens)
+
+def create_bow(text):
+    """
+    Create bag of words representation
+    
+    Args:
+        text (str): Input text
+        
+    Returns:
+        dict: Bag of words representation with word counts
+    """
+    # Preprocess text
+    preprocessed_text = preprocess_text(text)
+    
+    # Tokenize
+    tokens = preprocessed_text.split()
+    
+    # Count occurrences
+    word_counts = Counter(tokens)
+    
+    return dict(word_counts)
+
+def compare_bow(bow1, bow2):
+    """
+    Compare two bag of words representations
+    
+    Args:
+        bow1 (dict): First bag of words
+        bow2 (dict): Second bag of words
+        
+    Returns:
+        dict: Comparison metrics
+    """
+    # Get all unique words
+    all_words = set(bow1.keys()).union(set(bow2.keys()))
+    
+    # Words in both
+    common_words = set(bow1.keys()).intersection(set(bow2.keys()))
+    
+    # Words unique to each
+    unique_to_1 = set(bow1.keys()) - set(bow2.keys())
+    unique_to_2 = set(bow2.keys()) - set(bow1.keys())
+    
+    # Calculate Jaccard similarity
+    jaccard = len(common_words) / len(all_words) if len(all_words) > 0 else 0
+    
+    # Calculate cosine similarity
+    vec1 = np.zeros(len(all_words))
+    vec2 = np.zeros(len(all_words))
+    
+    for i, word in enumerate(all_words):
+        vec1[i] = bow1.get(word, 0)
+        vec2[i] = bow2.get(word, 0)
+    
+    # Normalize vectors
+    norm1 = np.linalg.norm(vec1)
+    norm2 = np.linalg.norm(vec2)
+    
+    if norm1 == 0 or norm2 == 0:
+        cosine = 0
+    else:
+        cosine = np.dot(vec1, vec2) / (norm1 * norm2)
+    
+    return {
+        "jaccard_similarity": jaccard,
+        "cosine_similarity": cosine,
+        "common_word_count": len(common_words),
+        "unique_to_first": list(unique_to_1)[:20],  # Limit for readability
+        "unique_to_second": list(unique_to_2)[:20]  # Limit for readability
+    }
+
+def important_words(bow, top_n=10):
+    """
+    Extract most important/distinctive words
+    
+    Args:
+        bow (dict): Bag of words representation
+        top_n (int): Number of top words to return
+        
+    Returns:
+        list: Top words with counts
+    """
+    # Sort by count
+    sorted_words = sorted(bow.items(), key=lambda x: x[1], reverse=True)
+    
+    # Return top N
+    return [{"word": word, "count": count} for word, count in sorted_words[:top_n]]
+
+def compare_bow_across_texts(texts, model_names, top_n=25):
+    """
+    Compare bag of words across multiple texts
+    
+    Args:
+        texts (list): List of text responses
+        model_names (list): List of model names corresponding to responses
+        top_n (int): Number of top words to include
+        
+    Returns:
+        dict: Comparative bag of words analysis
+    """
+    # Create bag of words for each text
+    bows = [create_bow(text) for text in texts]
+    
+    # Map to models
+    model_bows = {model: bow for model, bow in zip(model_names, bows)}
+    
+    # Get important words for each model
+    model_important_words = {model: important_words(bow, top_n) for model, bow in model_bows.items()}
+    
+    # Compare pairwise
+    comparisons = {}
+    for i, model1 in enumerate(model_names):
+        for j, model2 in enumerate(model_names):
+            if j <= i:  # Avoid duplicate comparisons
+                continue
+            
+            comparison_key = f"{model1} vs {model2}"
+            comparisons[comparison_key] = compare_bow(model_bows[model1], model_bows[model2])
+    
+    # Create combined word list across all models
+    all_words = set()
+    for bow in bows:
+        all_words.update(bow.keys())
+    
+    # Create a matrix of word counts across models
+    word_count_matrix = {}
+    for word in sorted(list(all_words)):
+        word_counts = [bow.get(word, 0) for bow in bows]
+        # Only include words that show up in at least one model
+        if any(count > 0 for count in word_counts):
+            word_count_matrix[word] = {model: bow.get(word, 0) for model, bow in zip(model_names, bows)}
+    
+    # Sort matrix by most differential words (words with biggest variance across models)
+    word_variances = {}
+    for word, counts in word_count_matrix.items():
+        count_values = list(counts.values())
+        if len(count_values) > 1:
+            word_variances[word] = np.var(count_values)
+    
+    # Get top differential words
+    top_diff_words = sorted(word_variances.items(), key=lambda x: x[1], reverse=True)[:top_n]
+    differential_words = [word for word, _ in top_diff_words]
+    
+    # Format results
+    result = {
+        "model_word_counts": model_bows,
+        "important_words": model_important_words,
+        "comparisons": comparisons,
+        "differential_words": differential_words,
+        "word_count_matrix": {word: word_count_matrix[word] for word in differential_words},
+        "models": model_names
+    }
+    
+    return result
+
+def compare_bow(texts, model_names, top_n=25):
+    """
+    Compare bag of words between different texts
+    
+    Args:
+        texts (list): List of text responses to compare
+        model_names (list): Names of models corresponding to responses
+        top_n (int): Number of top words to consider
+        
+    Returns:
+        dict: Comparative analysis
+    """
+    return compare_bow_across_texts(texts, model_names, top_n)