update

README.md

@@ -21,14 +21,39 @@ Here is a link to the video demo also:
 
 # Introduction
 
-This is a Gradio app that allows you to compare the responses of two different LLMs (Language Models) to the same input prompt. The app provides a simple interface where you can enter a prompt and select two different LLMs from a dropdown menu. Once you submit the prompt, the app will display the responses from both LLMs side by side for easy comparison.
-The app is built using the Gradio library, which provides a user-friendly interface for creating web applications with Python. The app uses the `gr.Interface` class to create the interface and the `gr.inputs.Textbox` and `gr.outputs.Textbox` classes to define the input and output components of the app.
-The app also includes a `gr.Button` component that allows you to submit the prompt and get the responses from the selected LLMs. The app uses the `gr.update` method to update the output components with the responses from the LLMs.
-The app is designed to be easy to use and provides a simple way to compare the responses of different LLMs to the same input prompt. It can be useful for researchers and developers who want to evaluate the performance of different LLMs on the same task.
+This is a Gradio app that allows you to compare the responses of two different LLMs (Language Models) to the same input prompt. The app provides a simple interface where you can enter a prompt and responses yourself, or select from the built-in dataset. The app is built using the Gradio library, which provides a user-friendly interface for creating web applications with Python. The app is designed to be easy to use and provides a simple way to compare the responses of different LLMs to the same input prompt. It can be useful for researchers and developers who want to evaluate the performance of different LLMs on the same task.
+
+There are three main tabs:
+
+- Dataset Input
+- Analysis
+- RoBERTa Sentiment
+- Summary
+
+
 
 # Usage
 
+## Dataset Input
+
+The dataset input tab allows you to select a dataset from the built-in dataset or enter your own prompt and responses. You can select a dataset from the dropdown menu, or enter your own prompt and responses in the text boxes.
+
+## Analysis
+
+Once you have loaded a dataset, you now have four options:
+
+- Bag of Words
+- N-grams
+- Bias Detection
+- Classifier
+
+## RoBERTa Sentiment
+
+
+
+## Summary
 
+The summary tab provides a summary of two of the prompts: the Trump and Harris prompts.  This is hard-coded in the app.  It is text files selectable from a dropdown menu.  The first part of the prompt is the summary from an LLM.  One is from Claude 3.7 and the other ChatGPT o4.  The second part of the text file, below the first, is the actual data given to the LLM, which is of the results from the various analysis options.  A user could copy and paste these in an LLM to get a similar response from their user entered datasets.
 
 # Documentation
 

app.py

@@ -7,6 +7,9 @@ from visualization.roberta_visualizer import process_and_visualize_sentiment_ana
 import nltk
 import os
 import json
+import matplotlib.pyplot as plt
+import io
+import base64
 
 # Download necessary NLTK resources function remains unchanged
 def download_nltk_resources():
@@ -760,6 +763,185 @@ def create_app():
                 inputs=[summary_dropdown],
                 outputs=[summary_content, summary_status]
             )
+                # Add a Visuals tab for plotting graphs
+        with gr.Tab("Visuals"):
+            gr.Markdown("## Visualization Graphs")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    # Dropdown for selecting visualization type
+                    viz_type = gr.Dropdown(
+                        choices=["N-gram Comparison", "Word Frequency", "Sentiment Analysis"],
+                        label="Visualization Type",
+                        info="Select the type of visualization to display",
+                        value="N-gram Comparison"
+                    )
+                    
+                    # Button to generate visualization
+                    generate_viz_btn = gr.Button("Generate Visualization", variant="primary")
+                    
+                with gr.Column(scale=3):
+                    # Image component to display the plot
+                    viz_output = gr.Image(
+                        label="Visualization",
+                        type="pil",
+                        height=500
+                    )
+                    
+                    viz_status = gr.Markdown("*No visualization generated*")
+            
+            # Function to generate and display visualizations
+            def generate_visualization(viz_type, dataset, analysis_results):
+                try:
+                    if not dataset or "entries" not in dataset or not dataset["entries"]:
+                        return None, "❌ **Error:** No dataset loaded. Please create or load a dataset first."
+                    
+                    # Example data (fallback when no real data is available)
+                    ex_data = {
+                        'attorney general': 3,
+                        'social justice': 3,
+                        'centrist approach': 2,
+                        'climate change': 2,
+                        'criminal justice': 2,
+                        'gun control': 2,
+                        'human rights': 2,
+                        'justice issues': 2,
+                        'measures like': 2,
+                        'middle class': 2
+                    }
+
+                    gran_data = {
+                        'political views': 3,
+                        'vice president': 3,
+                        'criminal justice': 2,
+                        'democratic party': 2,
+                        'foreign policy': 2,
+                        'harris advocated': 2,
+                        'lgbtq rights': 2,
+                        'president harris': 2,
+                        'social issues': 2,
+                        '2019 proposed': 1
+                    }
+                    
+                    # Use real data if available in analysis_results
+                    model1_data = {}
+                    model2_data = {}
+                    model1_name = "Model 1"
+                    model2_name = "Model 2"
+                    
+                    # Extract actual model names from dataset
+                    if dataset and "entries" in dataset and len(dataset["entries"]) >= 2:
+                        model1_name = dataset["entries"][0].get("model", "Model 1")
+                        model2_name = dataset["entries"][1].get("model", "Model 2")
+                    
+                    # Try to get real data from analysis_results
+                    if analysis_results and "analyses" in analysis_results:
+                        for prompt, analyses in analysis_results["analyses"].items():
+                            if viz_type == "N-gram Comparison" and "ngram_analysis" in analyses:
+                                ngram_results = analyses["ngram_analysis"]
+                                important_ngrams = ngram_results.get("important_ngrams", {})
+                                
+                                if model1_name in important_ngrams:
+                                    model1_data = {item["ngram"]: item["count"] for item in important_ngrams[model1_name]}
+                                    
+                                if model2_name in important_ngrams:
+                                    model2_data = {item["ngram"]: item["count"] for item in important_ngrams[model2_name]}
+                                    
+                            elif viz_type == "Word Frequency" and "bag_of_words" in analyses:
+                                bow_results = analyses["bag_of_words"]
+                                important_words = bow_results.get("important_words", {})
+                                
+                                if model1_name in important_words:
+                                    model1_data = {item["word"]: item["count"] for item in important_words[model1_name]}
+                                    
+                                if model2_name in important_words:
+                                    model2_data = {item["word"]: item["count"] for item in important_words[model2_name]}
+                    
+                    # If we couldn't get real data, use example data
+                    if not model1_data:
+                        model1_data = ex_data
+                    if not model2_data:
+                        model2_data = gran_data
+                    
+                    # Create the visualization
+                    plt.figure(figsize=(10, 6))
+                    
+                    if viz_type == "N-gram Comparison" or viz_type == "Word Frequency":
+                        # Plot for the first model
+                        plt.subplot(1, 2, 1)
+                        sorted_data1 = sorted(model1_data.items(), key=lambda x: x[1], reverse=True)[:10]  # Top 10
+                        terms1, counts1 = zip(*sorted_data1) if sorted_data1 else ([], [])
+                        
+                        # Create horizontal bar chart
+                        plt.barh([t[:20] + '...' if len(t) > 20 else t for t in terms1[::-1]], counts1[::-1])
+                        plt.xlabel('Frequency')
+                        plt.title(f'Top {viz_type.split()[0]}s Used by {model1_name}')
+                        plt.tight_layout()
+                        
+                        # Plot for the second model
+                        plt.subplot(1, 2, 2)
+                        sorted_data2 = sorted(model2_data.items(), key=lambda x: x[1], reverse=True)[:10]  # Top 10
+                        terms2, counts2 = zip(*sorted_data2) if sorted_data2 else ([], [])
+                        
+                        # Create horizontal bar chart
+                        plt.barh([t[:20] + '...' if len(t) > 20 else t for t in terms2[::-1]], counts2[::-1])
+                        plt.xlabel('Frequency')
+                        plt.title(f'Top {viz_type.split()[0]}s Used by {model2_name}')
+                        plt.tight_layout()
+                    
+                    elif viz_type == "Sentiment Analysis":
+                        # Generate sentiment comparison visualization
+                        # This would be populated with real data when available
+                        sentiment_scores = {
+                            model1_name: 0.75,  # Example score
+                            model2_name: 0.25   # Example score
+                        }
+                        
+                        # Extract real sentiment scores if available
+                        if "roberta_results_state" in analysis_results:
+                            roberta_results = analysis_results["roberta_results_state"]
+                            if "analyses" in roberta_results:
+                                for prompt, analyses in roberta_results["analyses"].items():
+                                    if "roberta_sentiment" in analyses:
+                                        sentiment_result = analyses["roberta_sentiment"]
+                                        sentiment_analysis = sentiment_result.get("sentiment_analysis", {})
+                                        
+                                        if model1_name in sentiment_analysis:
+                                            sentiment_scores[model1_name] = sentiment_analysis[model1_name].get("sentiment_score", 0)
+                                            
+                                        if model2_name in sentiment_analysis:
+                                            sentiment_scores[model2_name] = sentiment_analysis[model2_name].get("sentiment_score", 0)
+                        
+                        # Create sentiment bar chart
+                        plt.bar(list(sentiment_scores.keys()), list(sentiment_scores.values()))
+                        plt.ylim(-1, 1)
+                        plt.ylabel('Sentiment Score (-1 to 1)')
+                        plt.title('Sentiment Analysis Comparison')
+                        plt.axhline(y=0, color='r', linestyle='-', alpha=0.3)  # Add a zero line
+                    
+                    # Save the plot to a bytes buffer
+                    buf = io.BytesIO()
+                    plt.savefig(buf, format='png')
+                    buf.seek(0)
+                    
+                    # Convert plot to PIL Image
+                    from PIL import Image
+                    image = Image.open(buf)
+                    
+                    return image, f"✅ **Generated {viz_type} visualization**"
+                    
+                except Exception as e:
+                    import traceback
+                    error_msg = f"Error generating visualization: {str(e)}\n{traceback.format_exc()}"
+                    print(error_msg)
+                    return None, f"❌ **Error:** {str(e)}"
+            
+            # Connect the generate button to the function
+            generate_viz_btn.click(
+                fn=generate_visualization,
+                inputs=[viz_type, dataset_state, analysis_results_state],
+                outputs=[viz_output, viz_status]
+            )
 
         # Run analysis with proper parameters
         run_analysis_btn.click(