update

.idea/525GradioApp.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="GOOGLE" />
+    <option name="myDocStringFormat" value="Google" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/525GradioApp.iml" filepath="$PROJECT_DIR$/.idea/525GradioApp.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="8e67814c-7f04-433c-ab7a-2b65a1106d4c" name="Changes" comment="">
+      <change beforePath="$PROJECT_DIR$/processors/bias_detection.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/processors/diff_highlighter.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/processors/metrics.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/processors/ngram_analysis.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/processors/topic_modeling.py" beforeDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectColorInfo"><![CDATA[{
+  "associatedIndex": 6
+}]]></component>
+  <component name="ProjectId" id="2w0Fnz09BnFZ6wle8bfjI0kAU9r" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "RunOnceActivity.git.unshallow": "true",
+    "git-widget-placeholder": "main",
+    "last_opened_file_path": "/Users/ryan/GitHub/525GradioApp/525GradioApp",
+    "nodejs_package_manager_path": "npm",
+    "settings.editor.selected.configurable": "preferences.pluginManager",
+    "vue.rearranger.settings.migration": "true"
+  }
+}]]></component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-d6986cc7102b-f27c65a3e318-JavaScript-PY-251.23774.444" />
+        <option value="bundled-python-sdk-890ed5b35930-d9c5bdb153f4-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-251.23774.444" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="8e67814c-7f04-433c-ab7a-2b65a1106d4c" name="Changes" comment="" />
+      <created>1745170754325</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1745170754325</updated>
+      <workItem from="1745170755404" duration="245000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>

_archive/app.py

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

app.py

@@ -1,5 +1,4 @@
 import gradio as gr
-import os
 from ui.dataset_input import create_dataset_input, load_example_dataset
 from ui.analysis_screen import process_analysis_request
 
@@ -23,7 +22,7 @@ def create_app():
             load_example_btn.click(
                 fn=load_example_dataset,
                 inputs=[example_dropdown],
-                outputs=[dataset_inputs]  # Ensure `load_example_dataset` returns compatible data
+                outputs=[dataset_inputs]
             )
 
             # Save dataset to state
@@ -34,30 +33,23 @@ def create_app():
                         {"prompt": p, "response": r2, "model": m2}
                     ]
                 },
-                inputs=[prompt, response1, model1, response2, model2],  # Ensure these are valid Gradio components
-                outputs=[dataset_state]  # Ensure `dataset_state` is correctly defined
+                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)
+            analysis_options, analysis_params, run_analysis_btn, analysis_output = process_analysis_request()
             
             # Run analysis
             run_analysis_btn.click(
                 fn=process_analysis_request,
-                inputs=[dataset_state, analysis_options],  # Removed None
+                inputs=[dataset_state, analysis_options],
                 outputs=[analysis_results_state, analysis_output]
             )
     
     return app
 
 if __name__ == "__main__":
-    # Create and launch the app
     app = create_app()
     app.launch()

processors/bias_detection.py

@@ -1,241 +0,0 @@
-import nltk
-from nltk.sentiment import SentimentIntensityAnalyzer
-import re
-import numpy as np
-from collections import Counter
-
-# Download necessary NLTK data
-try:
-    nltk.data.find('sentiment/vader_lexicon.zip')
-except LookupError:
-    nltk.download('vader_lexicon')
-
-# Political leaning lexicons (simplified for demonstration)
-# In a real implementation, these would be much more comprehensive and nuanced
-LIBERAL_TERMS = {
-    'progressive', 'equity', 'climate change', 'social justice', 'regulation', 'equality',
-    'diversity', 'inclusion', 'workers rights', 'universal healthcare', 'welfare', 'public',
-    'government program', 'marginalized', 'underrepresented', 'systemic', 'racism',
-    'discrimination', 'gun control', 'green new deal', 'carbon tax', 'reproductive rights',
-    'pro-choice', 'labor union', 'living wage', 'wealth tax', 'police reform'
-}
-
-CONSERVATIVE_TERMS = {
-    'traditional', 'free market', 'deregulation', 'individual responsibility', 'liberty',
-    'freedom', 'private sector', 'family values', 'law and order', 'tax cuts', 'limited government',
-    'fiscal responsibility', 'national security', 'defense spending', 'second amendment',
-    'religious freedom', 'pro-life', 'states rights', 'border security', 'merit-based',
-    'job creators', 'free enterprise', 'strong military', 'patriotism', 'constitutional'
-}
-
-# Framing lexicons
-ECONOMIC_FRAMING = {
-    'economy', 'economic', 'cost', 'money', 'financial', 'revenue', 'tax', 'budget',
-    'fiscal', 'deficit', 'inflation', 'growth', 'investment', 'market', 'trade', 'profit',
-    'wage', 'income', 'gdp', 'business', 'corporation', 'industry', 'job', 'unemployment'
-}
-
-MORAL_FRAMING = {
-    'moral', 'ethical', 'right', 'wrong', 'good', 'bad', 'value', 'principle', 'fair',
-    'unfair', 'justice', 'dignity', 'integrity', 'honest', 'corrupt', 'compassion', 
-    'respect', 'responsibility', 'duty', 'virtue', 'vice', 'sin', 'sacred', 'character'
-}
-
-SECURITY_FRAMING = {
-    'security', 'safety', 'threat', 'danger', 'risk', 'fear', 'protect', 'defend',
-    'attack', 'crisis', 'emergency', 'invasion', 'violence', 'crime', 'terrorism',
-    'defense', 'military', 'police', 'law', 'order', 'stability', 'chaos', 'conflict'
-}
-
-def detect_sentiment(text):
-    """
-    Detect overall sentiment of text
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        dict: Sentiment analysis results
-    """
-    # Use VADER for sentiment analysis
-    sid = SentimentIntensityAnalyzer()
-    sentiment_scores = sid.polarity_scores(text)
-    
-    # Classify based on compound score
-    if sentiment_scores['compound'] >= 0.05:
-        classification = "Positive"
-    elif sentiment_scores['compound'] <= -0.05:
-        classification = "Negative"
-    else:
-        classification = "Neutral"
-    
-    return {
-        "compound": sentiment_scores['compound'],
-        "positive": sentiment_scores['pos'],
-        "neutral": sentiment_scores['neu'],
-        "negative": sentiment_scores['neg'],
-        "classification": classification
-    }
-
-def detect_partisan_lean(text):
-    """
-    Detect political leaning of text
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        dict: Political leaning analysis
-    """
-    # Normalize text
-    text_lower = text.lower()
-    
-    # Count occurrences of politically-charged terms
-    liberal_count = 0
-    conservative_count = 0
-    
-    for term in LIBERAL_TERMS:
-        liberal_count += len(re.findall(r'\b' + term + r'\b', text_lower))
-    
-    for term in CONSERVATIVE_TERMS:
-        conservative_count += len(re.findall(r'\b' + term + r'\b', text_lower))
-    
-    # Calculate total and political lean
-    total_partisan_terms = liberal_count + conservative_count
-    
-    if total_partisan_terms > 0:
-        # Scale from -1 (liberal) to 1 (conservative)
-        lean_score = (conservative_count - liberal_count) / total_partisan_terms
-    else:
-        lean_score = 0  # Neutral if no partisan terms found
-    
-    # Classify based on score
-    if lean_score < -0.2:
-        classification = "Liberal Leaning"
-    elif lean_score > 0.2:
-        classification = "Conservative Leaning"
-    else:
-        classification = "Politically Balanced"
-    
-    return {
-        "lean_score": lean_score,
-        "liberal_terms": liberal_count,
-        "conservative_terms": conservative_count,
-        "total_partisan_terms": total_partisan_terms,
-        "classification": classification
-    }
-
-def detect_framing_bias(text):
-    """
-    Detect framing bias in political context
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        dict: Framing analysis
-    """
-    # Normalize text
-    text_lower = text.lower()
-    
-    # Count framing terms
-    economic_count = 0
-    moral_count = 0
-    security_count = 0
-    
-    for term in ECONOMIC_FRAMING:
-        economic_count += len(re.findall(r'\b' + term + r'\b', text_lower))
-    
-    for term in MORAL_FRAMING:
-        moral_count += len(re.findall(r'\b' + term + r'\b', text_lower))
-    
-    for term in SECURITY_FRAMING:
-        security_count += len(re.findall(r'\b' + term + r'\b', text_lower))
-    
-    # Calculate total framing terms
-    total_framing_terms = economic_count + moral_count + security_count
-    
-    # Calculate percentages
-    if total_framing_terms > 0:
-        economic_pct = economic_count / total_framing_terms
-        moral_pct = moral_count / total_framing_terms
-        security_pct = security_count / total_framing_terms
-    else:
-        economic_pct = moral_pct = security_pct = 0
-    
-    # Determine primary framing
-    if total_framing_terms > 0:
-        max_count = max(economic_count, moral_count, security_count)
-        if max_count == economic_count:
-            primary_frame = "Economic"
-        elif max_count == moral_count:
-            primary_frame = "Moral/Ethical"
-        else:
-            primary_frame = "Security/Safety"
-    else:
-        primary_frame = "No clear framing"
-    
-    return {
-        "economic_framing": economic_pct,
-        "moral_framing": moral_pct,
-        "security_framing": security_pct,
-        "total_framing_terms": total_framing_terms,
-        "primary_frame": primary_frame
-    }
-
-def compare_bias(texts, model_names, bias_methods=None):
-    """
-    Compare bias metrics across texts
-    
-    Args:
-        texts (list): List of text responses
-        model_names (list): Names of models corresponding to responses
-        bias_methods (list): List of bias detection methods to apply
-        
-    Returns:
-        dict: Comparative bias analysis
-    """
-    if bias_methods is None:
-        bias_methods = ["Sentiment Analysis", "Partisan Leaning", "Framing Analysis"]
-    
-    results = {
-        "models": model_names
-    }
-    
-    # Run selected bias analyses
-    if "Sentiment Analysis" in bias_methods:
-        sentiment_results = {}
-        for i, (text, model) in enumerate(zip(texts, model_names)):
-            sentiment_results[model] = detect_sentiment(text)
-        results["sentiment"] = sentiment_results
-    
-    if "Partisan Leaning" in bias_methods:
-        partisan_results = {}
-        for i, (text, model) in enumerate(zip(texts, model_names)):
-            partisan_results[model] = detect_partisan_lean(text)
-        results["partisan_leaning"] = partisan_results
-    
-    if "Framing Analysis" in bias_methods:
-        framing_results = {}
-        for i, (text, model) in enumerate(zip(texts, model_names)):
-            framing_results[model] = detect_framing_bias(text)
-        results["framing"] = framing_results
-    
-    # Add summary statistics
-    if "Sentiment Analysis" in bias_methods:
-        avg_sentiment = np.mean([results["sentiment"][model]["compound"] for model in model_names])
-        sentiment_variance = np.var([results["sentiment"][model]["compound"] for model in model_names])
-        results["sentiment_summary"] = {
-            "average_compound": avg_sentiment,
-            "variance": sentiment_variance
-        }
-    
-    if "Partisan Leaning" in bias_methods:
-        avg_lean = np.mean([results["partisan_leaning"][model]["lean_score"] for model in model_names])
-        lean_variance = np.var([results["partisan_leaning"][model]["lean_score"] for model in model_names])
-        results["partisan_summary"] = {
-            "average_lean": avg_lean,
-            "variance": lean_variance
-        }
-    
-    return results

processors/diff_highlighter.py

@@ -1,298 +0,0 @@
-import difflib
-import nltk
-from nltk.tokenize import sent_tokenize, word_tokenize
-import re
-from sklearn.feature_extraction.text import TfidfVectorizer
-from scipy.spatial.distance import cosine
-import numpy as np
-import html
-
-# Download necessary NLTK data
-try:
-    nltk.data.find('tokenizers/punkt')
-except LookupError:
-    nltk.download('punkt')
-
-def highlight_differences(text1, text2):
-    """
-    Find and highlight textual differences
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        
-    Returns:
-        dict: Differences analysis
-    """
-    # Tokenize into sentences
-    sentences1 = sent_tokenize(text1)
-    sentences2 = sent_tokenize(text2)
-    
-    # Compare sentence by sentence
-    matcher = difflib.SequenceMatcher(None, sentences1, sentences2)
-    
-    # Track different and similar content
-    unique_to_1 = []
-    unique_to_2 = []
-    similar_content = []
-    
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-        if tag == 'equal':
-            for i in range(i1, i2):
-                similar_content.append(sentences1[i])
-        elif tag == 'delete':
-            for i in range(i1, i2):
-                unique_to_1.append(sentences1[i])
-        elif tag == 'insert':
-            for j in range(j1, j2):
-                unique_to_2.append(sentences2[j])
-        elif tag == 'replace':
-            for i in range(i1, i2):
-                unique_to_1.append(sentences1[i])
-            for j in range(j1, j2):
-                unique_to_2.append(sentences2[j])
-    
-    # Calculate percentage of unique content
-    total_sentences1 = len(sentences1)
-    total_sentences2 = len(sentences2)
-    
-    pct_unique_1 = len(unique_to_1) / total_sentences1 if total_sentences1 > 0 else 0
-    pct_unique_2 = len(unique_to_2) / total_sentences2 if total_sentences2 > 0 else 0
-    
-    # Calculate content overlap
-    if total_sentences1 + total_sentences2 > 0:
-        overlap = 2 * len(similar_content) / (total_sentences1 + total_sentences2)
-    else:
-        overlap = 0
-    
-    # Analyze word-level differences
-    # First, get common sentences
-    vectorizer = TfidfVectorizer(min_df=1)
-    
-    # Extract significant words unique to each text
-    significant_words_1 = []
-    significant_words_2 = []
-    
-    if unique_to_1 and unique_to_2:
-        # Combine unique sentences for each text
-        combined_1 = ' '.join(unique_to_1)
-        combined_2 = ' '.join(unique_to_2)
-        
-        # Create TF-IDF vectors
-        try:
-            tfidf_matrix = vectorizer.fit_transform([combined_1, combined_2])
-            feature_names = vectorizer.get_feature_names_out()
-            
-            # Extract weights for each document
-            weights_1 = tfidf_matrix[0].toarray()[0]
-            weights_2 = tfidf_matrix[1].toarray()[0]
-            
-            # Get top 10 words unique to each text
-            for i in range(len(feature_names)):
-                if weights_1[i] > weights_2[i] * 2:  # Significantly higher in text 1
-                    significant_words_1.append((feature_names[i], weights_1[i]))
-                elif weights_2[i] > weights_1[i] * 2:  # Significantly higher in text 2
-                    significant_words_2.append((feature_names[i], weights_2[i]))
-            
-            # Sort by weight and take top 10
-            significant_words_1 = sorted(significant_words_1, key=lambda x: x[1], reverse=True)[:10]
-            significant_words_2 = sorted(significant_words_2, key=lambda x: x[1], reverse=True)[:10]
-            
-            # Convert to list of words only
-            significant_words_1 = [word for word, _ in significant_words_1]
-            significant_words_2 = [word for word, _ in significant_words_2]
-        except:
-            # Fallback if TF-IDF fails
-            significant_words_1 = []
-            significant_words_2 = []
-    
-    return {
-        "unique_to_first": unique_to_1,
-        "unique_to_second": unique_to_2,
-        "similar_content": similar_content,
-        "pct_unique_first": pct_unique_1,
-        "pct_unique_second": pct_unique_2,
-        "content_overlap": overlap,
-        "significant_words_first": significant_words_1,
-        "significant_words_second": significant_words_2
-    }
-
-def extract_unique_content(texts):
-    """
-    Extract content unique to each text
-    
-    Args:
-        texts (list): List of texts
-        
-    Returns:
-        dict: Unique content for each text
-    """
-    n = len(texts)
-    unique_content = [[] for _ in range(n)]
-    
-    # Compare each text with all others
-    for i in range(n):
-        sentences_i = sent_tokenize(texts[i])
-        
-        # For each sentence in this text
-        for sentence in sentences_i:
-            # Check if it appears in any other text
-            is_unique = True
-            for j in range(n):
-                if i != j and sentence in texts[j]:
-                    is_unique = False
-                    break
-            
-            if is_unique:
-                unique_content[i].append(sentence)
-    
-    return {f"text_{i+1}_unique": content for i, content in enumerate(unique_content)}
-
-def generate_html_diff(text1, text2):
-    """
-    Generate HTML with highlighted differences
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        
-    Returns:
-        str: HTML with highlighted differences
-    """
-    # Split into sentences
-    sentences1 = sent_tokenize(text1)
-    sentences2 = sent_tokenize(text2)
-    
-    # Compare sentence by sentence
-    matcher = difflib.SequenceMatcher(None, sentences1, sentences2)
-    
-    # Create HTML with highlighted differences
-    html_output = []
-    
-    html_output.append('<div style="display: flex; width: 100%;">')
-    
-    # First text column
-    html_output.append('<div style="flex: 1; padding: 10px; border-right: 1px solid #ccc;">')
-    html_output.append(f'<h3>Text 1</h3>')
-    
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-        if tag in ('delete', 'replace'):
-            # Unique to text 1 - highlight in red
-            for i in range(i1, i2):
-                html_output.append(f'<p style="background-color: #ffdddd;">{html.escape(sentences1[i])}</p>')
-        else:
-            # Common or not in text 1
-            for i in range(i1, i2):
-                html_output.append(f'<p>{html.escape(sentences1[i])}</p>')
-    
-    html_output.append('</div>')
-    
-    # Second text column
-    html_output.append('<div style="flex: 1; padding: 10px;">')
-    html_output.append(f'<h3>Text 2</h3>')
-    
-    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
-        if tag in ('insert', 'replace'):
-            # Unique to text 2 - highlight in green
-            for j in range(j1, j2):
-                html_output.append(f'<p style="background-color: #ddffdd;">{html.escape(sentences2[j])}</p>')
-        else:
-            # Common or not in text 2
-            for j in range(j1, j2):
-                html_output.append(f'<p>{html.escape(sentences2[j])}</p>')
-    
-    html_output.append('</div>')
-    html_output.append('</div>')
-    
-    return ''.join(html_output)
-
-def highlight_text_differences(diff_results, model_pair=None):
-    """
-    Generate HTML with highlighted differences based on analysis results
-    
-    Args:
-        diff_results (dict): Results from highlight_differences
-        model_pair (str): Model pair to compare (e.g., "GPT-4 vs Claude-3")
-        
-    Returns:
-        str: HTML with highlighted differences
-    """
-    if model_pair and model_pair in diff_results:
-        analysis = diff_results[model_pair]
-    elif model_pair:
-        # If specific pair not found, return error
-        return f"<p>Model pair '{model_pair}' not found in difference analysis.</p>"
-    else:
-        # If no pair specified, use first available
-        if not diff_results:
-            return "<p>No difference analysis available.</p>"
-        analysis = diff_results[list(diff_results.keys())[0]]
-    
-    # Extract model names from pair
-    if model_pair:
-        model1, model2 = model_pair.split(" vs ")
-    else:
-        model1 = "Text 1"
-        model2 = "Text 2"
-    
-    html_output = []
-    
-    # Overall statistics
-    html_output.append('<div style="margin-bottom: 20px;">')
-    html_output.append('<h3>Difference Analysis</h3>')
-    html_output.append(f'<p><b>Content Overlap:</b> {analysis["content_overlap"]*100:.1f}%</p>')
-    html_output.append(f'<p><b>Unique to {model1}:</b> {analysis["pct_unique_first"]*100:.1f}%</p>')
-    html_output.append(f'<p><b>Unique to {model2}:</b> {analysis["pct_unique_second"]*100:.1f}%</p>')
-    html_output.append('</div>')
-    
-    # Significant words
-    html_output.append('<div style="display: flex; margin-bottom: 20px;">')
-    
-    html_output.append('<div style="flex: 1; padding: 10px;">')
-    html_output.append(f'<h4>Key terms unique to {model1}:</h4>')
-    if analysis["significant_words_first"]:
-        html_output.append('<ul>')
-        for word in analysis["significant_words_first"]:
-            html_output.append(f'<li>{html.escape(word)}</li>')
-        html_output.append('</ul>')
-    else:
-        html_output.append('<p>No significant unique terms found.</p>')
-    html_output.append('</div>')
-    
-    html_output.append('<div style="flex: 1; padding: 10px;">')
-    html_output.append(f'<h4>Key terms unique to {model2}:</h4>')
-    if analysis["significant_words_second"]:
-        html_output.append('<ul>')
-        for word in analysis["significant_words_second"]:
-            html_output.append(f'<li>{html.escape(word)}</li>')
-        html_output.append('</ul>')
-    else:
-        html_output.append('<p>No significant unique terms found.</p>')
-    html_output.append('</div>')
-    
-    html_output.append('</div>')
-    
-    # Unique content sections
-    html_output.append('<div style="display: flex;">')
-    
-    html_output.append('<div style="flex: 1; padding: 10px; border-right: 1px solid #ccc;">')
-    html_output.append(f'<h4>Content unique to {model1}:</h4>')
-    if analysis["unique_to_first"]:
-        for sentence in analysis["unique_to_first"]:
-            html_output.append(f'<p style="background-color: #ffdddd;">{html.escape(sentence)}</p>')
-    else:
-        html_output.append('<p>No unique content found.</p>')
-    html_output.append('</div>')
-    
-    html_output.append('<div style="flex: 1; padding: 10px;">')
-    html_output.append(f'<h4>Content unique to {model2}:</h4>')
-    if analysis["unique_to_second"]:
-        for sentence in analysis["unique_to_second"]:
-            html_output.append(f'<p style="background-color: #ddffdd;">{html.escape(sentence)}</p>')
-    else:
-        html_output.append('<p>No unique content found.</p>')
-    html_output.append('</div>')
-    
-    html_output.append('</div>')
-    
-    return ''.join(html_output)

processors/metrics.py

@@ -1,258 +0,0 @@
-import nltk
-from nltk.tokenize import word_tokenize
-from nltk.util import ngrams
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-import numpy as np
-import re
-from collections import Counter
-
-# Download necessary NLTK data
-try:
-    nltk.data.find('tokenizers/punkt')
-except LookupError:
-    nltk.download('punkt')
-
-def preprocess_text(text):
-    """
-    Preprocess text for similarity calculations
-    
-    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)
-    
-    # Replace multiple spaces with single space
-    text = re.sub(r'\s+', ' ', text).strip()
-    
-    return text
-
-def calculate_cosine_similarity(text1, text2):
-    """
-    Calculate cosine similarity between two texts
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        
-    Returns:
-        float: Cosine similarity score
-    """
-    # Preprocess texts
-    preprocessed_text1 = preprocess_text(text1)
-    preprocessed_text2 = preprocess_text(text2)
-    
-    # Create TF-IDF vectors
-    vectorizer = TfidfVectorizer()
-    tfidf_matrix = vectorizer.fit_transform([preprocessed_text1, preprocessed_text2])
-    
-    # Calculate cosine similarity
-    cosine_sim = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])[0][0]
-    
-    return float(cosine_sim)
-
-def calculate_jaccard_similarity(text1, text2):
-    """
-    Calculate Jaccard similarity between two texts
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        
-    Returns:
-        float: Jaccard similarity score
-    """
-    # Preprocess texts
-    preprocessed_text1 = preprocess_text(text1)
-    preprocessed_text2 = preprocess_text(text2)
-    
-    # Tokenize
-    tokens1 = set(word_tokenize(preprocessed_text1))
-    tokens2 = set(word_tokenize(preprocessed_text2))
-    
-    # Calculate Jaccard similarity
-    intersection = tokens1.intersection(tokens2)
-    union = tokens1.union(tokens2)
-    
-    if len(union) == 0:
-        return 0.0
-    
-    return len(intersection) / len(union)
-
-def calculate_ngram_overlap(text1, text2, n=2):
-    """
-    Calculate n-gram overlap between two texts
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        n (int): Size of n-grams
-        
-    Returns:
-        float: N-gram overlap score
-    """
-    # Preprocess texts
-    preprocessed_text1 = preprocess_text(text1)
-    preprocessed_text2 = preprocess_text(text2)
-    
-    # Tokenize
-    tokens1 = word_tokenize(preprocessed_text1)
-    tokens2 = word_tokenize(preprocessed_text2)
-    
-    # Generate n-grams
-    ngrams1 = set(' '.join(gram) for gram in ngrams(tokens1, n))
-    ngrams2 = set(' '.join(gram) for gram in ngrams(tokens2, n))
-    
-    # Calculate overlap
-    intersection = ngrams1.intersection(ngrams2)
-    union = ngrams1.union(ngrams2)
-    
-    if len(union) == 0:
-        return 0.0
-    
-    return len(intersection) / len(union)
-
-def calculate_semantic_similarity(text1, text2):
-    """
-    Calculate semantic similarity between two texts
-    
-    Note: In a real implementation, this would use a pretrained language model.
-    This is a simplified version for demonstration purposes.
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        
-    Returns:
-        float: Semantic similarity score
-    """
-    # For demonstration, use a weighted combination of other similarities
-    cosine_sim = calculate_cosine_similarity(text1, text2)
-    jaccard_sim = calculate_jaccard_similarity(text1, text2)
-    ngram_sim = calculate_ngram_overlap(text1, text2, 2)
-    
-    # Weighted average (would be replaced with actual embedding-based similarity)
-    semantic_sim = (0.5 * cosine_sim) + (0.3 * jaccard_sim) + (0.2 * ngram_sim)
-    
-    return float(semantic_sim)
-
-def calculate_lexical_diversity(text):
-    """
-    Calculate lexical diversity (type-token ratio)
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        float: Lexical diversity score
-    """
-    # Preprocess text
-    preprocessed_text = preprocess_text(text)
-    
-    # Tokenize
-    tokens = word_tokenize(preprocessed_text)
-    
-    # Calculate type-token ratio
-    if len(tokens) == 0:
-        return 0.0
-    
-    return len(set(tokens)) / len(tokens)
-
-def calculate_complexity(text):
-    """
-    Calculate linguistic complexity metrics
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        dict: Complexity metrics
-    """
-    # Preprocess minimally to keep sentence structure
-    text_lower = text.lower()
-    
-    # Tokenize into sentences and words
-    sentences = nltk.sent_tokenize(text_lower)
-    words = word_tokenize(text_lower)
-    
-    # Calculate average sentence length
-    avg_sentence_length = len(words) / len(sentences) if len(sentences) > 0 else 0
-    
-    # Calculate average word length
-    avg_word_length = sum(len(word) for word in words) / len(words) if len(words) > 0 else 0
-    
-    # Calculate lexical diversity
-    lexical_diversity = calculate_lexical_diversity(text)
-    
-    return {
-        "avg_sentence_length": float(avg_sentence_length),
-        "avg_word_length": float(avg_word_length),
-        "lexical_diversity": float(lexical_diversity)
-    }
-
-def calculate_similarity(text1, text2, methods=None):
-    """
-    Calculate similarity between texts using various methods
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        methods (list): List of similarity methods to apply
-        
-    Returns:
-        dict: Similarity metrics
-    """
-    if methods is None:
-        methods = ["Cosine Similarity"]
-    
-    results = {}
-    
-    if "Cosine Similarity" in methods:
-        results["cosine_similarity"] = calculate_cosine_similarity(text1, text2)
-    
-    if "Jaccard Similarity" in methods:
-        results["jaccard_similarity"] = calculate_jaccard_similarity(text1, text2)
-    
-    if "N-gram Overlap" in methods:
-        for n in range(1, 4):
-            results[f"{n}-gram_overlap"] = calculate_ngram_overlap(text1, text2, n)
-    
-    if "Semantic Similarity" in methods:
-        results["semantic_similarity"] = calculate_semantic_similarity(text1, text2)
-    
-    # Add complexity comparison
-    if "Complexity Comparison" in methods:
-        complexity1 = calculate_complexity(text1)
-        complexity2 = calculate_complexity(text2)
-        
-        results["complexity_comparison"] = {
-            "text1_complexity": complexity1,
-            "text2_complexity": complexity2,
-            "complexity_difference": {
-                "avg_sentence_length": complexity1["avg_sentence_length"] - complexity2["avg_sentence_length"],
-                "avg_word_length": complexity1["avg_word_length"] - complexity2["avg_word_length"],
-                "lexical_diversity": complexity1["lexical_diversity"] - complexity2["lexical_diversity"]
-            }
-        }
-    
-    return results
-
-def calculate_diversity(text):
-    """
-    Calculate lexical diversity and other metrics
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        dict: Diversity metrics
-    """
-    return calculate_complexity(text)
-    vector

processors/ngram_analysis.py

@@ -1,208 +0,0 @@
-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.util import ngrams
-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')
-
-def preprocess_text(text):
-    """
-    Preprocess text for n-gram analysis
-    
-    Args:
-        text (str): Input text
-        
-    Returns:
-        list: List of preprocessed tokens
-    """
-    # Convert to lowercase
-    text = text.lower()
-    
-    # Remove special characters and digits (but keep spaces and punctuation for n-grams)
-    text = re.sub(r'[^a-zA-Z\s.,!?]', '', text)
-    
-    # Tokenize
-    tokens = word_tokenize(text)
-    
-    # Remove stopwords for unigrams, but keep for n-grams (important for context)
-    # stop_words = set(stopwords.words('english'))
-    # tokens = [token for token in tokens if token not in stop_words]
-    
-    return tokens
-
-def extract_ngrams(text, n=2):
-    """
-    Extract n-grams from text
-    
-    Args:
-        text (str): Input text
-        n (int): Size of n-grams to extract
-        
-    Returns:
-        dict: N-grams with counts
-    """
-    # Preprocess text
-    tokens = preprocess_text(text)
-    
-    # Generate n-grams
-    n_grams = list(ngrams(tokens, n))
-    
-    # Convert n-grams to strings for easier handling
-    n_gram_strings = [' '.join(gram) for gram in n_grams]
-    
-    # Count occurrences
-    gram_counts = Counter(n_gram_strings)
-    
-    return dict(gram_counts)
-
-def compare_ngrams(texts, model_names, n=2, top_n=10):
-    """
-    Compare n-grams across different texts
-    
-    Args:
-        texts (list): List of text responses
-        model_names (list): Names of models corresponding to responses
-        n (int): Size of n-grams to extract
-        top_n (int): Number of top n-grams to consider
-        
-    Returns:
-        dict: Comparative analysis
-    """
-    # Extract n-grams for each text
-    model_ngrams = {}
-    for i, (text, model) in enumerate(zip(texts, model_names)):
-        model_ngrams[model] = extract_ngrams(text, n)
-    
-    # Get top n-grams for each model
-    top_ngrams = {}
-    for model, ngrams_dict in model_ngrams.items():
-        sorted_ngrams = sorted(ngrams_dict.items(), key=lambda x: x[1], reverse=True)
-        top_ngrams[model] = [{"ngram": ngram, "count": count} for ngram, count in sorted_ngrams[:top_n]]
-    
-    # Find unique n-grams for each model
-    unique_ngrams = {}
-    for i, model1 in enumerate(model_names):
-        # Get all n-grams from other models
-        other_ngrams = set()
-        for j, model2 in enumerate(model_names):
-            if i != j:
-                other_ngrams.update(model_ngrams[model2].keys())
-        
-        # Find n-grams unique to this model
-        unique_to_model = set(model_ngrams[model1].keys()) - other_ngrams
-        
-        # Sort by count
-        sorted_unique = sorted(
-            [(ngram, model_ngrams[model1][ngram]) for ngram in unique_to_model],
-            key=lambda x: x[1],
-            reverse=True
-        )
-        
-        unique_ngrams[model1] = [{"ngram": ngram, "count": count} for ngram, count in sorted_unique[:top_n]]
-    
-    # Calculate pairwise similarity between models
-    similarities = {}
-    for i, model1 in enumerate(model_names):
-        for j, model2 in enumerate(model_names):
-            if j <= i:  # Avoid duplicate comparisons
-                continue
-            
-            # Get sets of n-grams
-            ngrams1 = set(model_ngrams[model1].keys())
-            ngrams2 = set(model_ngrams[model2].keys())
-            
-            # Calculate Jaccard similarity
-            intersection = ngrams1.intersection(ngrams2)
-            union = ngrams1.union(ngrams2)
-            
-            jaccard = len(intersection) / len(union) if len(union) > 0 else 0
-            
-            similarities[f"{model1} vs {model2}"] = {
-                "jaccard_similarity": jaccard,
-                "common_ngrams": list(intersection)[:top_n]
-            }
-    
-    # Create n-gram frequency matrix for comparison
-    all_ngrams = set()
-    for model_dict in model_ngrams.values():
-        all_ngrams.update(model_dict.keys())
-    
-    # Calculate ngram variances to find most differential ngrams
-    ngram_variances = {}
-    for ngram in all_ngrams:
-        counts = [model_dict.get(ngram, 0) for model_dict in model_ngrams.values()]
-        if len(counts) > 1:
-            ngram_variances[ngram] = np.var(counts)
-    
-    # Get top differential ngrams
-    top_diff_ngrams = sorted(ngram_variances.items(), key=lambda x: x[1], reverse=True)[:top_n]
-    differential_ngrams = [ngram for ngram, _ in top_diff_ngrams]
-    
-    # Create matrix of counts for top differential ngrams
-    ngram_matrix = {}
-    for ngram in differential_ngrams:
-        ngram_matrix[ngram] = {model: model_dict.get(ngram, 0) for model, model_dict in model_ngrams.items()}
-    
-    # Format results
-    result = {
-        "n": n,
-        "top_ngrams": top_ngrams,
-        "unique_ngrams": unique_ngrams,
-        "similarities": similarities,
-        "differential_ngrams": differential_ngrams,
-        "ngram_matrix": ngram_matrix,
-        "models": model_names
-    }
-    
-    return result
-
-def unique_ngrams(text1, text2, n=2):
-    """
-    Find unique n-grams in one text vs another
-    
-    Args:
-        text1 (str): First text
-        text2 (str): Second text
-        n (int): Size of n-grams
-        
-    Returns:
-        dict: N-grams unique to each text
-    """
-    # Extract n-grams
-    ngrams1 = extract_ngrams(text1, n)
-    ngrams2 = extract_ngrams(text2, n)
-    
-    # Find unique n-grams
-    unique_to_1 = set(ngrams1.keys()) - set(ngrams2.keys())
-    unique_to_2 = set(ngrams2.keys()) - set(ngrams1.keys())
-    
-    # Sort by frequency
-    sorted_unique_1 = sorted(
-        [(ngram, ngrams1[ngram]) for ngram in unique_to_1],
-        key=lambda x: x[1],
-        reverse=True
-    )
-    
-    sorted_unique_2 = sorted(
-        [(ngram, ngrams2[ngram]) for ngram in unique_to_2],
-        key=lambda x: x[1],
-        reverse=True
-    )
-    
-    return {
-        "unique_to_first": [{"ngram": ngram, "count": count} for ngram, count in sorted_unique_1[:10]],
-        "unique_to_second": [{"ngram": ngram, "count": count} for ngram, count in sorted_unique_2[:10]]
-    }

processors/topic_modeling.py

@@ -1,183 +0,0 @@
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.decomposition import LatentDirichletAllocation, NMF
-import numpy as np
-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 topic modeling
-    
-    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]
-    
-    # Join back to string
-    return ' '.join(tokens)
-
-def extract_topics(texts, num_topics=3, method='lda'):
-    """
-    Extract main topics using topic modeling
-    
-    Args:
-        texts (list): List of text documents
-        num_topics (int): Number of topics to extract
-        method (str): Method to use ('lda' or 'nmf')
-        
-    Returns:
-        dict: Extracted topics and their keywords
-    """
-    # Preprocess texts
-    preprocessed_texts = [preprocess_text(text) for text in texts]
-    
-    # Create TF-IDF vectorizer
-    vectorizer = TfidfVectorizer(max_features=1000, min_df=2, max_df=0.8)
-    tfidf_matrix = vectorizer.fit_transform(preprocessed_texts)
-    feature_names = vectorizer.get_feature_names_out()
-    
-    # Run topic modeling
-    if method == 'nmf':
-        # Non-negative Matrix Factorization (often works better for short texts)
-        model = NMF(n_components=num_topics, random_state=42)
-    else:
-        # Latent Dirichlet Allocation
-        model = LatentDirichletAllocation(n_components=num_topics, random_state=42)
-    
-    model.fit(tfidf_matrix)
-    
-    # Extract topics and keywords
-    topics = {}
-    for topic_idx, topic in enumerate(model.components_):
-        # Get top 10 keywords for this topic
-        top_keyword_indices = topic.argsort()[:-11:-1]
-        top_keywords = [feature_names[i] for i in top_keyword_indices]
-        
-        topics[f"Topic_{topic_idx+1}"] = {
-            "keywords": top_keywords,
-            "weight": float(topic.sum())  # Convert to float for JSON serialization
-        }
-    
-    # Get topic distribution for each document
-    if method == 'nmf':
-        doc_topic_dist = model.transform(tfidf_matrix)
-    else:
-        doc_topic_dist = model.transform(tfidf_matrix)
-    
-    # Convert to list of dictionaries for JSON serialization
-    doc_topics = []
-    for i, doc_dist in enumerate(doc_topic_dist):
-        # Normalize to sum to 1
-        doc_dist = doc_dist / doc_dist.sum() if doc_dist.sum() > 0 else doc_dist
-        
-        # Convert to dictionary of topic distributions
-        dist = {}
-        for topic_idx, weight in enumerate(doc_dist):
-            dist[f"Topic_{topic_idx+1}"] = float(weight)  # Convert to float for JSON serialization
-        
-        doc_topics.append(dist)
-    
-    return {
-        "topics": topics,
-        "document_topics": doc_topics
-    }
-
-def compare_topics(texts, model_names, num_topics=3):
-    """
-    Compare topics across different model responses
-    
-    Args:
-        texts (list): List of text responses
-        model_names (list): List of model names corresponding to responses
-        num_topics (int): Number of topics to extract
-        
-    Returns:
-        dict: Comparative topic analysis
-    """
-    # Extract topics
-    topic_results = extract_topics(texts, num_topics)
-    
-    # Map document topics to models
-    model_topics = {}
-    for i, model in enumerate(model_names):
-        model_topics[model] = topic_results["document_topics"][i]
-    
-    # Find primary topic for each model
-    model_primary_topics = {}
-    for model, topics in model_topics.items():
-        primary_topic = max(topics.items(), key=lambda x: x[1])
-        model_primary_topics[model] = {
-            "topic": primary_topic[0],
-            "weight": primary_topic[1]
-        }
-    
-    # Format for output
-    result = {
-        "topics": topic_results["topics"],
-        "model_topics": model_topics,
-        "primary_topics": model_primary_topics,
-        "models": model_names
-    }
-    
-    return result
-
-def topic_similarity(topic1, topic2):
-    """
-    Calculate similarity between topics
-    
-    Args:
-        topic1 (dict): First topic with keywords
-        topic2 (dict): Second topic with keywords
-        
-    Returns:
-        float: Similarity score
-    """
-    # Extract keywords
-    keywords1 = set(topic1["keywords"])
-    keywords2 = set(topic2["keywords"])
-    
-    # Calculate Jaccard similarity
-    intersection = keywords1.intersection(keywords2)
-    union = keywords1.union(keywords2)
-    
-    if len(union) == 0:
-        return 0.0
-    
-    return len(intersection) / len(union)

ui/analysis_screen.py

@@ -2,12 +2,12 @@ import gradio as gr
 import json
 
 # Import analysis modules
-from processors.topic_modeling import extract_topics, compare_topics
-from processors.ngram_analysis import compare_ngrams
-from processors.bias_detection import compare_bias
+#from processors.topic_modeling import extract_topics, compare_topics
+#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.metrics import calculate_similarity
+#from processors.diff_highlighter import highlight_differences
 
 def create_analysis_screen():
     """