update

ui/dataset_input.py

@@ -0,0 +1,87 @@
+import gradio as gr
+import os
+from utils.text_dataset_parser import load_text_file, load_builtin_datasets
+
+def create_dataset_input():
+    """
+    Create the dataset input interface with prompt, response, and model fields.
+
+    Returns:
+        tuple: (dataset_inputs, example_dropdown, load_example_btn, create_btn)
+    """
+    # Get built-in text datasets
+    text_datasets_dir = os.path.join("dataset")
+    text_datasets = [file.name for file in os.scandir(text_datasets_dir) if file.is_file() and file.name.endswith(".txt")]
+
+    with gr.Column() as dataset_inputs:
+        gr.Markdown("## LLM Response Comparison Dataset")
+        gr.Markdown("""
+        Enter a prompt and responses from two different LLMs for comparison, 
+        or load one of the built-in datasets.
+        """)
+
+        # Example dataset selection
+        with gr.Row():
+            example_dropdown = gr.Dropdown(
+                choices=text_datasets,
+                value=text_datasets[0] if text_datasets else None,
+                label="Built-in Datasets",
+                info="Select a pre-made dataset to load"
+            )
+            load_example_btn = gr.Button("Load Dataset", variant="secondary")
+
+        # User input fields
+        gr.Markdown("### Create Your Own Dataset")
+        with gr.Row():
+            prompt = gr.Textbox(label="Prompt", lines=2, placeholder="Enter a prompt/question...")
+        with gr.Row():
+            response1 = gr.Textbox(label="Response 1", lines=4, placeholder="Enter the first model's response...")
+            model1 = gr.Textbox(label="Model 1", placeholder="Enter the first model's name...")
+        with gr.Row():
+            response2 = gr.Textbox(label="Response 2", lines=4, placeholder="Enter the second model's response...")
+            model2 = gr.Textbox(label="Model 2", placeholder="Enter the second model's name...")
+
+        create_btn = gr.Button("Create Dataset", variant="primary")
+
+    return dataset_inputs, example_dropdown, load_example_btn, create_btn, prompt, response1, model1, response2, model2
+
+
+def load_example_dataset(file_name):
+    """
+    Load a built-in dataset from a text file.
+
+    Args:
+        file_name (str): Name of the text file to load.
+
+    Returns:
+        dict: Dataset entry with prompt, response1, model1, response2, and model2.
+    """
+    file_path = os.path.join("dataset", file_name)
+    if os.path.exists(file_path):
+        return load_text_file(file_path)
+    else:
+        print(f"File not found: {file_path}")
+        return {"prompt": "", "response1": "", "model1": "", "response2": "", "model2": ""}
+
+
+def create_user_dataset(prompt, response1, model1, response2, model2):
+    """
+    Create a user-defined dataset entry.
+
+    Args:
+        prompt (str): The prompt text.
+        response1 (str): The first model's response.
+        model1 (str): The first model's name.
+        response2 (str): The second model's response.
+        model2 (str): The second model's name.
+
+    Returns:
+        dict: Dataset entry with prompt, response1, model1, response2, and model2.
+    """
+    return {
+        "prompt": prompt.strip(),
+        "response1": response1.strip(),
+        "model1": model1.strip(),
+        "response2": response2.strip(),
+        "model2": model2.strip()
+    }

ui/main_screen.py

@@ -0,0 +1,47 @@
+import gradio as gr
+
+def create_main_screen():
+    """
+    Create the main landing screen with app description and navigation
+    
+    Returns:
+        tuple: (welcome_msg, about_info, get_started_btn)
+    """
+    with gr.Column() as main_screen:
+        welcome_msg = gr.Markdown(
+            """
+            # LLM Response Comparator
+            
+            ## Analyze and Compare Responses from Different LLMs on Political Topics
+            """
+        )
+        
+        about_info = gr.Markdown(
+            """
+            ### About This Tool
+            
+            This application allows you to compare how different Large Language Models (LLMs) respond 
+            to the same political prompts or questions. Using various NLP techniques, the tool analyzes:
+            
+            - **Topic Modeling**: What key topics do different LLMs emphasize?
+            - **N-gram Analysis**: What phrases and word patterns are characteristic of each LLM?
+            - **Bias Detection**: Are there detectable biases in how LLMs approach political topics?
+            - **Text Classification**: How do responses cluster or differentiate?
+            - **Key Differences**: What specific content varies between models?
+            
+            ### How to Use
+            
+            1. Navigate to the **Dataset Input** tab
+            2. Enter prompts and corresponding LLM responses, or load an example dataset
+            3. Run various analyses to see how the responses compare
+            4. Explore visualizations of the differences
+            5. Generate a comprehensive report of findings
+            
+            This tool is for educational and research purposes to better understand how LLMs handle 
+            politically sensitive topics.
+            """
+        )
+        
+        get_started_btn = gr.Button("Get Started", variant="primary", size="large")
+    
+    return welcome_msg, about_info, get_started_btn

utils/text_dataset_parser.py

@@ -0,0 +1,66 @@
+"""
+Utility functions for parsing text-based dataset files for LLM response comparator.
+"""
+import re
+from pathlib import Path
+
+def parse_text_file(file_path):
+    """
+    Parse a text file to extract prompt, response1, model1, response2, and model2.
+    
+    Format:
+    - \prompt= followed by the prompt text
+    - \response1= followed by the first model's response
+    - \model1= followed by the first model's name
+    - \response2= followed by the second model's response
+    - \model2= followed by the second model's name
+    
+    Args:
+        file_path (str): Path to the text file.
+        
+    Returns:
+        dict: Dictionary with prompt, response1, model1, response2, and model2.
+    """
+    with open(file_path, 'r', encoding='utf-8') as file:
+        content = file.read()
+    
+    # Extract sections using regular expressions
+    prompt = re.search(r'\\prompt=(.*?)(?=\\response1=|$)', content, re.DOTALL)
+    response1 = re.search(r'\\response1=(.*?)(?=\\model1=|$)', content, re.DOTALL)
+    model1 = re.search(r'\\model1=(.*?)(?=\\response2=|$)', content, re.DOTALL)
+    response2 = re.search(r'\\response2=(.*?)(?=\\model2=|$)', content, re.DOTALL)
+    model2 = re.search(r'\\model2=(.*?)(?=$)', content, re.DOTALL)
+    
+    return {
+        "prompt": prompt.group(1).strip() if prompt else "",
+        "response1": response1.group(1).strip() if response1 else "",
+        "model1": model1.group(1).strip() if model1 else "",
+        "response2": response2.group(1).strip() if response2 else "",
+        "model2": model2.group(1).strip() if model2 else ""
+    }
+
+def load_text_file(file_path):
+    """
+    Load a single text file as a dataset entry.
+    
+    Args:
+        file_path (str): Path to the text file.
+        
+    Returns:
+        dict: Dataset entry with prompt, response1, model1, response2, and model2.
+    """
+    return parse_text_file(file_path)
+
+def load_builtin_datasets(directory_path):
+    """
+    Load all built-in datasets from a directory.
+    
+    Args:
+        directory_path (str): Path to the directory containing text files.
+        
+    Returns:
+        list: List of dataset entries.
+    """
+    path = Path(directory_path)
+    text_files = list(path.glob('*.txt'))
+    return [parse_text_file(str(file_path)) for file_path in text_files]