update

README.md

@@ -26,17 +26,30 @@ This is a Gradio app that allows you to compare the responses of two different L
 There are three main tabs:
 
 - Dataset Input
-- Analysis
-- RoBERTa Sentiment
+- Analysis (four options, including a classifier that is NLTK VADER based)
+- RoBERTa Sentiment (Transformer based classifier)
 - Summary
+- Visuals (this is a basic graphing display that is hard-coded, not dynamic based on the datasets)
 
+I will quote the assignment prompt and make a few comments:
 
+"You might think about it as a mini hackathon over the course of several weeks instead of a single day, aiming to build an engaging proof-of-concept demo of an idea you have – you are not expected to have a fully, production-ready application for this assignment."
+
+The app is fairly stable and has a decent amount of features, although it is not a fully production-ready application.  I believe with more time I could refine this, but a good amount of time was put into it to get it to an acceptable state for the assignment requirements.  One of the things is I would recommend restarting the space if you want to load another dataset and have the results built through the analysis options and displayed in the summary tab for you to send to an LLM if you want.  The visuals tab is more of an example of some hard-coded results, with the n-grams option of the anlysis tab having the dynamic graphing.  That option will display graphs based on the dataset, including a created dataset.  I could have added more graphs to other options, including the RoBERTa classifier, but felt the current state is of acceptable features.
 
 # 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.
+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.  The load dataset button will fill in the text boxes with the selected dataset.  With that or your own dataset, you then click the create dataset button and a message will display below that stating if it was successfully created.  Now click on the Analysis tab.
+
+The built-in datasets are:
+- person-harris.txt: Responses about Kamala Harris
+- person-trump.txt: Responses about Donald Trump
+- topic-foreign_policy.txt: Responses about foreign policy views
+- topic-the_economy.txt: Responses about economic views
+
+There are two responses each, one from LG's ExaOne 3.5, and the other from IBM's Granite 3.2.  These are both approximately 5gb models that are Ollama compatible, which is how the results were obtained.
 
 ## Analysis
 
@@ -47,8 +60,18 @@ Once you have loaded a dataset, you now have four options:
 - Bias Detection
 - Classifier
 
+The N-grams option will produce a dynamic graph.  Also, these options will product a text file with the results that can be accessed in the summary tab.  If you go through all four of these analysis options it will append them to the file.
+
 ### Bag of Words
 
+Bag of Words here is fairly basic.  There are no parameter options.  Click run analysis and you will see some comparison results.
+
+Similarity Metrics Terms:
+
+- Cosine Similarity: Measures the cosine of the angle between two non-zero vectors.  A value of 1 means they are identical, while a value of 0 means they are orthogonal.
+- Jaccard Similarity: Measures the similarity between two sets.  A value of 1 means they are identical, while a value of 0 means they have no overlap.
+- Semantic Similarity: Measures the similarity between two texts based on their meaning.  A value of 1 means they are identical, while a value of 0 means they have no similarity.
+- Common Words: The number of words that appear in both responses.
 
 
 ### N-grams

app.py

@@ -580,6 +580,105 @@ def create_app():
                                     f"- **{category}**: {diff}" 
                                     for category, diff in differences.items()
                                 ])
+                                
+                                # Create visualization using matplotlib
+                                import matplotlib.pyplot as plt
+                                import io
+                                import base64
+                                from PIL import Image
+                                
+                                try:
+                                    # Define metrics and mappings
+                                    metrics = ['Formality', 'Sentiment', 'Complexity']
+                                    mapping = {
+                                        'Formality': {'Informal': 1, 'Neutral': 2, 'Formal': 3},
+                                        'Sentiment': {'Negative': 1, 'Neutral': 2, 'Positive': 3},
+                                        'Complexity': {'Simple': 1, 'Average': 2, 'Complex': 3}
+                                    }
+                                    
+                                    # Get values for each model
+                                    model1_vals = []
+                                    model2_vals = []
+                                    
+                                    # Get formality value for model1
+                                    formality1 = model1_results.get('formality', 'Neutral')
+                                    if formality1 in mapping['Formality']:
+                                        model1_vals.append(mapping['Formality'][formality1])
+                                    else:
+                                        model1_vals.append(2)  # Default to neutral
+                                    
+                                    # Get sentiment value for model1
+                                    sentiment1 = model1_results.get('sentiment', 'Neutral')
+                                    if sentiment1 in mapping['Sentiment']:
+                                        model1_vals.append(mapping['Sentiment'][sentiment1])
+                                    else:
+                                        model1_vals.append(2)  # Default to neutral
+                                    
+                                    # Get complexity value for model1
+                                    complexity1 = model1_results.get('complexity', 'Average')
+                                    if complexity1 in mapping['Complexity']:
+                                        model1_vals.append(mapping['Complexity'][complexity1])
+                                    else:
+                                        model1_vals.append(2)  # Default to average
+                                    
+                                    # Get formality value for model2
+                                    formality2 = model2_results.get('formality', 'Neutral')
+                                    if formality2 in mapping['Formality']:
+                                        model2_vals.append(mapping['Formality'][formality2])
+                                    else:
+                                        model2_vals.append(2)  # Default to neutral
+                                    
+                                    # Get sentiment value for model2
+                                    sentiment2 = model2_results.get('sentiment', 'Neutral')
+                                    if sentiment2 in mapping['Sentiment']:
+                                        model2_vals.append(mapping['Sentiment'][sentiment2])
+                                    else:
+                                        model2_vals.append(2)  # Default to neutral
+                                    
+                                    # Get complexity value for model2
+                                    complexity2 = model2_results.get('complexity', 'Average')
+                                    if complexity2 in mapping['Complexity']:
+                                        model2_vals.append(mapping['Complexity'][complexity2])
+                                    else:
+                                        model2_vals.append(2)  # Default to average
+                                    
+                                    # Plot grouped bar chart
+                                    plt.figure(figsize=(10, 6))
+                                    x = range(len(metrics))
+                                    width = 0.35
+                                    plt.bar([p - width/2 for p in x], model1_vals, width=width, label=model1_name)
+                                    plt.bar([p + width/2 for p in x], model2_vals, width=width, label=model2_name)
+                                    plt.xticks(x, metrics)
+                                    plt.yticks([1, 2, 3], ['Low', 'Medium', 'High'])
+                                    plt.ylim(0, 3.5)
+                                    plt.ylabel('Level')
+                                    plt.title('Comparison of Model Characteristics')
+                                    plt.legend()
+                                    plt.tight_layout()
+                                    
+                                    # Save the plot to a bytes buffer
+                                    buf = io.BytesIO()
+                                    plt.savefig(buf, format='png', dpi=100)
+                                    buf.seek(0)
+                                    
+                                    # Convert to PIL Image
+                                    viz_image = Image.open(buf)
+                                    
+                                    # Convert the image to a base64 string for embedding
+                                    buffered = io.BytesIO()
+                                    viz_image.save(buffered, format="PNG")
+                                    img_str = base64.b64encode(buffered.getvalue()).decode()
+                                    
+                                    # Append the image to the metrics_value
+                                    similarity_title_visible = True
+                                    similarity_metrics_visible = True
+                                    similarity_metrics_value = f"""
+                                    <div style="margin-top: 20px;">
+                                    <img src="data:image/png;base64,{img_str}" alt="Classifier visualization" style="max-width: 100%;">
+                                    </div>
+                                    """
+                                except Exception as viz_error:
+                                    print(f"Classifier visualization error: {viz_error}")
 
                     # Check for Bias Detection analysis
                     elif selected_analysis == "Bias Detection" and "bias_detection" in analyses: