Update app.py

app.py

@@ -3,96 +3,280 @@ import gradio as gr
 from transformers import BertTokenizer, BertForSequenceClassification
 import matplotlib.pyplot as plt
 import numpy as np
+from wordcloud import WordCloud
+import seaborn as sns
 
-# Set the device to GPU or CPU
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Using device: {device}")
 
-# Load model and tokenizer from Hugging Face Model Hub
-tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis") # Replace with your model path
-model = BertForSequenceClassification.from_pretrained("entropy25/sentimentanalysis") # Replace with your model path
+tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis")
+model = BertForSequenceClassification.from_pretrained("entropy25/sentimentanalysis")
 model.to(device)
 
-# Define sentiment analysis function
+sentiment_history = []
+
 def analyze_sentiment(text):
+    if not text.strip():
+        return "Please enter a review", None, None, None
+    
     inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
     with torch.no_grad():
         outputs = model(**inputs)
         logits = outputs.logits
+        probabilities = torch.nn.functional.softmax(logits, dim=-1).cpu().numpy()[0]
         prediction = torch.argmax(logits, dim=-1).item()
-        confidence = torch.nn.functional.softmax(logits, dim=-1).max().item() # Get maximum confidence score
+        confidence = probabilities.max()
         sentiment = "Positive" if prediction == 1 else "Negative"
-    # Return sentiment and confidence score
-    return f"Sentiment: {sentiment} (Confidence: {confidence:.2f})"
+    
+    sentiment_history.append({
+        'text': text[:100],
+        'sentiment': sentiment,
+        'confidence': confidence,
+        'positive_prob': probabilities[1],
+        'negative_prob': probabilities[0]
+    })
+    
+    result_text = f"Sentiment: {sentiment} (Confidence: {confidence:.3f})"
+    prob_plot = plot_probabilities(probabilities)
+    gauge_plot = create_gauge(confidence, sentiment)
+    wordcloud_plot = generate_wordcloud(text, sentiment)
+    
+    return result_text, prob_plot, gauge_plot, wordcloud_plot
 
-# Plot sentiment distribution as a visualization
-def plot_sentiment_distribution():
-    sentiments = ["Positive", "Negative"]
-    # Randomly generate some distribution data for demonstration
-    scores = np.random.rand(2)
+def plot_probabilities(probabilities):
+    sentiments = ["Negative", "Positive"]
+    colors = ['#ff6b6b', '#4ecdc4']
     
-    fig, ax = plt.subplots(figsize=(8, 6))
-    bars = ax.bar(sentiments, scores, color=['green', 'red'])
-    ax.set_title("Sentiment Distribution")
-    ax.set_ylabel("Confidence")
+    fig, ax = plt.subplots(figsize=(8, 5))
+    bars = ax.bar(sentiments, probabilities, color=colors, alpha=0.8)
+    ax.set_title("Sentiment Probability Distribution", fontsize=14, fontweight='bold')
+    ax.set_ylabel("Probability")
     ax.set_ylim(0, 1)
     
-    # Add value labels on bars
-    for bar, score in zip(bars, scores):
+    for bar, prob in zip(bars, probabilities):
         height = bar.get_height()
-        ax.text(bar.get_x() + bar.get_width()/2., height + 0.01,
-                f'{score:.2f}', ha='center', va='bottom')
+        ax.text(bar.get_x() + bar.get_width()/2., height + 0.02,
+                f'{prob:.3f}', ha='center', va='bottom', fontweight='bold')
     
     plt.tight_layout()
     return fig
 
-# Gradio interface setup
-with gr.Blocks() as demo:
+def create_gauge(confidence, sentiment):
+    fig, ax = plt.subplots(figsize=(8, 6))
+    
+    theta = np.linspace(0, np.pi, 100)
+    colors = plt.cm.RdYlGn(np.linspace(0.2, 0.8, 100))
+    
+    for i in range(len(theta)-1):
+        ax.fill_between([theta[i], theta[i+1]], [0, 0], [0.8, 0.8], 
+                       color=colors[i], alpha=0.7)
+    
+    pointer_pos = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * confidence)
+    ax.plot([pointer_pos, pointer_pos], [0, 0.6], 'k-', linewidth=6)
+    ax.plot(pointer_pos, 0.6, 'ko', markersize=10)
+    
+    ax.set_xlim(0, np.pi)
+    ax.set_ylim(0, 1)
+    ax.set_title(f'{sentiment} Sentiment - Confidence: {confidence:.3f}', 
+                fontsize=14, fontweight='bold')
+    ax.set_xticks([0, np.pi/2, np.pi])
+    ax.set_xticklabels(['Negative', 'Neutral', 'Positive'])
+    ax.set_yticks([])
+    ax.spines['top'].set_visible(False)
+    ax.spines['right'].set_visible(False)
+    ax.spines['left'].set_visible(False)
+    
+    plt.tight_layout()
+    return fig
+
+def generate_wordcloud(text, sentiment):
+    if len(text.split()) < 3:
+        return None
+    
+    colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
+    
+    try:
+        wordcloud = WordCloud(
+            width=800, height=400,
+            background_color='white',
+            colormap=colormap,
+            max_words=30,
+            relative_scaling=0.5
+        ).generate(text)
+        
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.imshow(wordcloud, interpolation='bilinear')
+        ax.axis('off')
+        ax.set_title(f'{sentiment} Sentiment - Word Cloud', fontsize=14, fontweight='bold')
+        
+        plt.tight_layout()
+        return fig
+    except:
+        return None
+
+def analyze_batch(reviews_text):
+    if not reviews_text.strip():
+        return None
+    
+    reviews = [r.strip() for r in reviews_text.split('\n') if r.strip()]
+    if len(reviews) < 2:
+        return None
+    
+    results = []
+    for review in reviews:
+        inputs = tokenizer(review, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
+        with torch.no_grad():
+            outputs = model(**inputs)
+            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
+            prediction = torch.argmax(outputs.logits, dim=-1).item()
+            sentiment = "Positive" if prediction == 1 else "Negative"
+            confidence = probabilities.max()
+            
+        results.append({
+            'review': review[:50] + '...' if len(review) > 50 else review,
+            'sentiment': sentiment,
+            'confidence': confidence,
+            'positive_prob': probabilities[1]
+        })
+    
+    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
+    
+    sentiment_counts = {'Positive': 0, 'Negative': 0}
+    confidences = []
+    positive_probs = []
+    
+    for r in results:
+        sentiment_counts[r['sentiment']] += 1
+        confidences.append(r['confidence'])
+        positive_probs.append(r['positive_prob'])
+    
+    colors = ['#4ecdc4', '#ff6b6b']
+    ax1.pie(sentiment_counts.values(), labels=sentiment_counts.keys(), 
+            autopct='%1.1f%%', colors=colors, startangle=90)
+    ax1.set_title('Sentiment Distribution')
+    
+    ax2.hist(confidences, bins=8, alpha=0.7, color='skyblue', edgecolor='black')
+    ax2.set_title('Confidence Score Distribution')
+    ax2.set_xlabel('Confidence Score')
+    ax2.set_ylabel('Frequency')
+    
+    review_indices = range(len(results))
+    ax3.scatter(review_indices, positive_probs, 
+               c=[colors[0] if r['sentiment'] == 'Positive' else colors[1] for r in results],
+               alpha=0.7, s=100)
+    ax3.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+    ax3.set_title('Positive Probability by Review')
+    ax3.set_xlabel('Review Index')
+    ax3.set_ylabel('Positive Probability')
+    
+    sentiment_scores = [1 if r['sentiment'] == 'Positive' else 0 for r in results]
+    confidence_scores = confidences
+    ax4.scatter(confidence_scores, sentiment_scores, alpha=0.7, s=100, 
+               c=[colors[0] if s == 1 else colors[1] for s in sentiment_scores])
+    ax4.set_title('Sentiment vs Confidence')
+    ax4.set_xlabel('Confidence Score')
+    ax4.set_ylabel('Sentiment (0=Negative, 1=Positive)')
+    ax4.set_yticks([0, 1])
+    ax4.set_yticklabels(['Negative', 'Positive'])
+    
+    plt.tight_layout()
+    return fig
+
+def plot_history():
+    if len(sentiment_history) < 2:
+        return None
+    
+    indices = list(range(len(sentiment_history)))
+    positive_probs = [item['positive_prob'] for item in sentiment_history]
+    confidences = [item['confidence'] for item in sentiment_history]
+    
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
+    
+    colors = ['#4ecdc4' if prob > 0.5 else '#ff6b6b' for prob in positive_probs]
+    ax1.scatter(indices, positive_probs, c=colors, alpha=0.7, s=100)
+    ax1.plot(indices, positive_probs, alpha=0.5, linewidth=2)
+    ax1.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
+    ax1.set_title('Sentiment Analysis History - Positive Probability')
+    ax1.set_xlabel('Analysis Number')
+    ax1.set_ylabel('Positive Probability')
+    ax1.grid(True, alpha=0.3)
+    
+    ax2.bar(indices, confidences, alpha=0.7, color='lightblue', edgecolor='navy')
+    ax2.set_title('Confidence Scores Over Time')
+    ax2.set_xlabel('Analysis Number')
+    ax2.set_ylabel('Confidence Score')
+    ax2.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    return fig
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as demo:
     gr.Markdown("# 🎬 AI Movie Sentiment Analyzer")
-    gr.Markdown("This tool uses a BERT model to analyze movie reviews. Enter a review to analyze its sentiment!")
-    
-    with gr.Row():
-        with gr.Column(scale=3):
-            input_text = gr.Textbox(
-                label="Enter a movie review",
-                placeholder="Example: The plot was really engaging, but the ending was disappointing!",
-                lines=4
-            )
-            submit_button = gr.Button("Analyze Sentiment")
+    gr.Markdown("Advanced sentiment analysis for movie reviews using BERT model with comprehensive visualizations")
+    
+    with gr.Tab("Single Review Analysis"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_text = gr.Textbox(
+                    label="Enter Movie Review",
+                    placeholder="The cinematography was stunning, but the plot felt predictable...",
+                    lines=5
+                )
+                analyze_btn = gr.Button("Analyze Sentiment", variant="primary", size="lg")
+                
+                gr.Examples(
+                    examples=[
+                        ["The cinematography was absolutely stunning, but the pacing felt slow at times."],
+                        ["A masterpiece in every way! The performances, direction, and music were phenomenal."],
+                        ["The movie was boring, and I couldn't connect with any of the characters."],
+                        ["Incredible special effects, but the dialogue was cheesy and the plot had holes."],
+                        ["The ending left me speechless, fantastic build-up throughout the entire film."]
+                    ],
+                    inputs=input_text
+                )
+            
+            with gr.Column(scale=1):
+                sentiment_output = gr.Textbox(label="Analysis Result", lines=2)
         
-        with gr.Column(scale=2):
-            sentiment_output = gr.Textbox(label="Prediction")
-            sentiment_plot_btn = gr.Button("Visualize Sentiment Distribution")
-            plot_output = gr.Plot()
-    
-    # Trigger sentiment analysis when button is clicked
-    submit_button.click(fn=analyze_sentiment, inputs=input_text, outputs=sentiment_output)
-    sentiment_plot_btn.click(fn=plot_sentiment_distribution, outputs=plot_output)
-    
-    # Add some more complex example inputs for user convenience
-    examples = [
-        ["The cinematography was absolutely stunning, but the pacing felt slow at times."],
-        ["I loved the emotional depth of the characters, but the plot twist felt forced and unrealistic."],
-        ["A masterpiece in every way! The performances, direction, and music were phenomenal."],
-        ["The movie was boring, and I couldn't connect with any of the characters. The story was predictable."],
-        ["A thrilling experience with great action scenes, but I expected a bit more from the storyline."],
-        ["I was deeply moved by the performances, but the story lacked originality and felt cliche."],
-        ["Incredible special effects, but the dialogue was cheesy and the plot was full of holes."],
-        ["The direction was good, but the pacing was uneven, and it dragged on for too long."],
-        ["A great film for fans of the genre, but it may not appeal to everyone. It's definitely a niche film."],
-        ["The ending left me speechless, and the entire movie had a fantastic build-up."]
-    ]
-    
-    # 正确的方式：使用 gr.Examples 组件
-    gr.Examples(
-        examples=examples,
-        inputs=input_text,
-        outputs=sentiment_output,
+        with gr.Row():
+            prob_plot = gr.Plot(label="Probability Distribution")
+            gauge_plot = gr.Plot(label="Sentiment Gauge")
+        
+        with gr.Row():
+            wordcloud_plot = gr.Plot(label="Word Cloud Visualization")
+    
+    with gr.Tab("Batch Analysis"):
+        gr.Markdown("### Analyze Multiple Reviews")
+        gr.Markdown("Enter multiple reviews separated by new lines for comparative analysis")
+        
+        batch_input = gr.Textbox(
+            label="Multiple Reviews (one per line)",
+            placeholder="First review here...\nSecond review here...\nThird review here...",
+            lines=8
+        )
+        batch_btn = gr.Button("Analyze All Reviews", variant="primary")
+        batch_plot = gr.Plot(label="Batch Analysis Results")
+    
+    with gr.Tab("Analysis History"):
+        gr.Markdown("### Historical Analysis Trends")
+        gr.Markdown("View patterns and trends from your previous analyses")
+        
+        with gr.Row():
+            history_plot = gr.Plot(label="Sentiment History")
+            refresh_btn = gr.Button("Refresh History", variant="secondary")
+        
+        clear_btn = gr.Button("Clear History", variant="stop")
+    
+    analyze_btn.click(
         fn=analyze_sentiment,
-        cache_examples=True
+        inputs=input_text,
+        outputs=[sentiment_output, prob_plot, gauge_plot, wordcloud_plot]
     )
+    
+    batch_btn.click(fn=analyze_batch, inputs=batch_input, outputs=batch_plot)
+    refresh_btn.click(fn=plot_history, outputs=history_plot)
+    clear_btn.click(lambda: sentiment_history.clear(), outputs=None)
 
-# Launch the interface - 移除 examples 参数
 demo.launch(share=True)