Update app.py

app.py

@@ -4,64 +4,80 @@ from transformers import BertTokenizer, BertForSequenceClassification
 import matplotlib.pyplot as plt
 import numpy as np
 from wordcloud import WordCloud
-import seaborn as sns
+from collections import Counter, defaultdict
+from sklearn.feature_extraction.text import TfidfVectorizer
+import networkx as nx
+import re
 
+# Load model
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-print(f"Using device: {device}")
-
 tokenizer = BertTokenizer.from_pretrained("entropy25/sentimentanalysis")
 model = BertForSequenceClassification.from_pretrained("entropy25/sentimentanalysis")
 model.to(device)
 
-sentiment_history = []
+# Global storage
+history = []
+
+def clean_text(text):
+    """Simple text preprocessing"""
+    text = re.sub(r'[^\w\s]', '', text.lower())
+    words = text.split()
+    # Simple stopwords
+    stopwords = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'have', 'has', 'had', 'will', 'would', 'could', 'should', 'this', 'that', 'these', 'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'me', 'him', 'her', 'us', 'them'}
+    return [w for w in words if w not in stopwords and len(w) > 2]
 
-def analyze_sentiment(text):
+def analyze_text(text):
+    """Core sentiment analysis"""
     if not text.strip():
-        return "Please enter a review", None, None, None
+        return "Please enter text", 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 = probabilities.max()
-        sentiment = "Positive" if prediction == 1 else "Negative"
+        probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
+        pred = torch.argmax(outputs.logits, dim=-1).item()
+        conf = probs.max()
+        sentiment = "Positive" if pred == 1 else "Negative"
     
-    sentiment_history.append({
+    # Store in history
+    history.append({
         'text': text[:100],
+        'full_text': text,
         'sentiment': sentiment,
-        'confidence': confidence,
-        'positive_prob': probabilities[1],
-        'negative_prob': probabilities[0]
+        'confidence': conf,
+        'pos_prob': probs[1],
+        'neg_prob': probs[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)
+    result = f"Sentiment: {sentiment} (Confidence: {conf:.3f})"
+    
+    # Generate plots
+    prob_plot = plot_probs(probs)
+    gauge_plot = plot_gauge(conf, sentiment)
+    cloud_plot = plot_wordcloud(text, sentiment)
     
-    return result_text, prob_plot, gauge_plot, wordcloud_plot
+    return result, prob_plot, gauge_plot, cloud_plot
 
-def plot_probabilities(probabilities):
-    sentiments = ["Negative", "Positive"]
+def plot_probs(probs):
+    """Probability bar chart"""
+    fig, ax = plt.subplots(figsize=(8, 5))
+    labels = ["Negative", "Positive"]
     colors = ['#ff6b6b', '#4ecdc4']
     
-    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')
+    bars = ax.bar(labels, probs, color=colors, alpha=0.8)
+    ax.set_title("Sentiment Probabilities", fontweight='bold')
     ax.set_ylabel("Probability")
     ax.set_ylim(0, 1)
     
-    for bar, prob in zip(bars, probabilities):
-        height = bar.get_height()
-        ax.text(bar.get_x() + bar.get_width()/2., height + 0.02,
+    for bar, prob in zip(bars, probs):
+        ax.text(bar.get_x() + bar.get_width()/2., bar.get_height() + 0.02,
                 f'{prob:.3f}', ha='center', va='bottom', fontweight='bold')
     
     plt.tight_layout()
     return fig
 
-def create_gauge(confidence, sentiment):
+def plot_gauge(conf, sentiment):
+    """Confidence gauge"""
     fig, ax = plt.subplots(figsize=(8, 6))
     
     theta = np.linspace(0, np.pi, 100)
@@ -71,137 +87,325 @@ def create_gauge(confidence, sentiment):
         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)
+    pos = np.pi * (0.5 + (0.4 if sentiment == 'Positive' else -0.4) * conf)
+    ax.plot([pos, pos], [0, 0.6], 'k-', linewidth=6)
+    ax.plot(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_title(f'{sentiment} - Confidence: {conf:.3f}', 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)
+    ax.axis('off')
     
     plt.tight_layout()
     return fig
 
-def generate_wordcloud(text, sentiment):
+def plot_wordcloud(text, sentiment):
+    """Word cloud visualization"""
     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)
+        colormap = 'Greens' if sentiment == 'Positive' else 'Reds'
+        wc = WordCloud(width=800, height=400, background_color='white',
+                      colormap=colormap, max_words=30).generate(text)
         
         fig, ax = plt.subplots(figsize=(10, 5))
-        ax.imshow(wordcloud, interpolation='bilinear')
+        ax.imshow(wc, interpolation='bilinear')
         ax.axis('off')
-        ax.set_title(f'{sentiment} Sentiment - Word Cloud', fontsize=14, fontweight='bold')
+        ax.set_title(f'{sentiment} Word Cloud', fontweight='bold')
         
         plt.tight_layout()
         return fig
     except:
         return None
 
-def analyze_batch(reviews_text):
-    if not reviews_text.strip():
+def batch_analysis(reviews):
+    """Analyze multiple reviews"""
+    if not reviews.strip():
         return None
     
-    reviews = [r.strip() for r in reviews_text.split('\n') if r.strip()]
-    if len(reviews) < 2:
+    texts = [r.strip() for r in reviews.split('\n') if r.strip()]
+    if len(texts) < 2:
         return None
     
     results = []
-    for review in reviews:
-        inputs = tokenizer(review, return_tensors="pt", padding=True, truncation=True, max_length=512).to(device)
+    for text in texts:
+        inputs = tokenizer(text, 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()
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
+            pred = torch.argmax(outputs.logits, dim=-1).item()
+            sentiment = "Positive" if pred == 1 else "Negative"
+            conf = probs.max()
             
         results.append({
-            'review': review[:50] + '...' if len(review) > 50 else review,
+            'text': text[:50] + '...' if len(text) > 50 else text,
             'sentiment': sentiment,
-            'confidence': confidence,
-            'positive_prob': probabilities[1]
+            'confidence': conf,
+            'pos_prob': probs[1]
+        })
+        
+        # Add to history
+        history.append({
+            'text': text[:100],
+            'full_text': text,
+            'sentiment': sentiment,
+            'confidence': conf,
+            'pos_prob': probs[1],
+            'neg_prob': probs[0]
         })
     
+    # Create visualization
     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'])
-    
+    # Pie chart
+    sent_counts = Counter([r['sentiment'] for r in results])
     colors = ['#4ecdc4', '#ff6b6b']
-    ax1.pie(sentiment_counts.values(), labels=sentiment_counts.keys(), 
+    ax1.pie(sent_counts.values(), labels=sent_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],
+    # Confidence histogram
+    confs = [r['confidence'] for r in results]
+    ax2.hist(confs, bins=8, alpha=0.7, color='skyblue', edgecolor='black')
+    ax2.set_title('Confidence Distribution')
+    ax2.set_xlabel('Confidence')
+    ax2.set_ylabel('Count')
+    
+    # Probability scatter
+    indices = range(len(results))
+    pos_probs = [r['pos_prob'] for r in results]
+    ax3.scatter(indices, pos_probs, 
+               c=['#4ecdc4' if r['sentiment'] == 'Positive' else '#ff6b6b' 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])
+    # Confidence vs Sentiment
+    sent_binary = [1 if r['sentiment'] == 'Positive' else 0 for r in results]
+    ax4.scatter(confs, sent_binary, alpha=0.7, s=100, 
+               c=['#4ecdc4' if s == 1 else '#ff6b6b' for s in sent_binary])
     ax4.set_title('Sentiment vs Confidence')
-    ax4.set_xlabel('Confidence Score')
-    ax4.set_ylabel('Sentiment (0=Negative, 1=Positive)')
+    ax4.set_xlabel('Confidence')
+    ax4.set_ylabel('Sentiment')
     ax4.set_yticks([0, 1])
     ax4.set_yticklabels(['Negative', 'Positive'])
     
     plt.tight_layout()
     return fig
 
+def keyword_heatmap():
+    """Keyword sentiment heatmap"""
+    if len(history) < 3:
+        return None
+    
+    word_stats = defaultdict(list)
+    
+    for item in history:
+        words = clean_text(item['full_text'])
+        sentiment_score = item['pos_prob']
+        
+        for word in words:
+            word_stats[word].append(sentiment_score)
+    
+    # Filter words with at least 2 occurrences
+    filtered = {w: scores for w, scores in word_stats.items() if len(scores) >= 2}
+    
+    if len(filtered) < 5:
+        return None
+    
+    # Get top 20 most frequent words
+    top_words = sorted(filtered.items(), key=lambda x: len(x[1]), reverse=True)[:20]
+    
+    words = [item[0] for item in top_words]
+    avg_sentiments = [np.mean(item[1]) for item in top_words]
+    frequencies = [len(item[1]) for item in top_words]
+    
+    # Create heatmap data
+    data = np.array([avg_sentiments, [f/max(frequencies) for f in frequencies]]).T
+    
+    fig, ax = plt.subplots(figsize=(12, 8))
+    
+    im = ax.imshow(data, cmap='RdYlGn', aspect='auto')
+    
+    ax.set_xticks([0, 1])
+    ax.set_xticklabels(['Avg Sentiment', 'Frequency'])
+    ax.set_yticks(range(len(words)))
+    ax.set_yticklabels(words)
+    
+    # Add text annotations
+    for i in range(len(words)):
+        ax.text(0, i, f'{avg_sentiments[i]:.2f}', ha='center', va='center', 
+                color='black', fontweight='bold')
+        ax.text(1, i, f'{frequencies[i]}', ha='center', va='center', 
+                color='black', fontweight='bold')
+    
+    ax.set_title('Keyword Sentiment Heatmap', fontweight='bold')
+    plt.colorbar(im, ax=ax, label='Intensity')
+    
+    plt.tight_layout()
+    return fig
+
+def cooccurrence_network():
+    """Word co-occurrence network"""
+    if len(history) < 3:
+        return None
+    
+    all_words = []
+    for item in history:
+        words = clean_text(item['full_text'])
+        if len(words) >= 3:
+            all_words.extend(words)
+    
+    if len(all_words) < 10:
+        return None
+    
+    word_freq = Counter(all_words)
+    top_words = [word for word, freq in word_freq.most_common(15) if freq >= 2]
+    
+    if len(top_words) < 5:
+        return None
+    
+    # Calculate co-occurrences
+    cooccur = defaultdict(int)
+    
+    for item in history:
+        words = [w for w in clean_text(item['full_text']) if w in top_words]
+        
+        for i, w1 in enumerate(words):
+            for j, w2 in enumerate(words):
+                if i != j and w1 != w2:
+                    pair = tuple(sorted([w1, w2]))
+                    cooccur[pair] += 1
+    
+    # Create network
+    G = nx.Graph()
+    
+    for word in top_words:
+        G.add_node(word, size=word_freq[word])
+    
+    for (w1, w2), weight in cooccur.items():
+        if weight >= 2:
+            G.add_edge(w1, w2, weight=weight)
+    
+    if len(G.edges()) == 0:
+        return None
+    
+    # Plot network
+    fig, ax = plt.subplots(figsize=(12, 10))
+    
+    pos = nx.spring_layout(G, k=3, iterations=50)
+    
+    node_sizes = [G.nodes[node]['size'] * 200 for node in G.nodes()]
+    nx.draw_networkx_nodes(G, pos, node_size=node_sizes, 
+                          node_color='lightblue', alpha=0.7, ax=ax)
+    
+    edges = G.edges()
+    weights = [G[u][v]['weight'] for u, v in edges]
+    nx.draw_networkx_edges(G, pos, width=[w*0.5 for w in weights], 
+                          alpha=0.6, edge_color='gray', ax=ax)
+    
+    nx.draw_networkx_labels(G, pos, font_size=10, font_weight='bold', ax=ax)
+    
+    ax.set_title('Word Co-occurrence Network', fontweight='bold')
+    ax.axis('off')
+    
+    plt.tight_layout()
+    return fig
+
+def tfidf_analysis():
+    """TF-IDF keyword analysis"""
+    if len(history) < 4:
+        return None
+    
+    pos_texts = []
+    neg_texts = []
+    
+    for item in history:
+        if item['sentiment'] == 'Positive':
+            pos_texts.append(' '.join(clean_text(item['full_text'])))
+        else:
+            neg_texts.append(' '.join(clean_text(item['full_text'])))
+    
+    if len(pos_texts) < 2 or len(neg_texts) < 2:
+        return None
+    
+    try:
+        # Positive TF-IDF
+        vectorizer_pos = TfidfVectorizer(max_features=50, ngram_range=(1, 2))
+        pos_tfidf = vectorizer_pos.fit_transform(pos_texts)
+        pos_features = vectorizer_pos.get_feature_names_out()
+        pos_scores = pos_tfidf.sum(axis=0).A1
+        
+        # Negative TF-IDF
+        vectorizer_neg = TfidfVectorizer(max_features=50, ngram_range=(1, 2))
+        neg_tfidf = vectorizer_neg.fit_transform(neg_texts)
+        neg_features = vectorizer_neg.get_feature_names_out()
+        neg_scores = neg_tfidf.sum(axis=0).A1
+        
+        # Top 10 features
+        pos_top_idx = np.argsort(pos_scores)[-10:][::-1]
+        neg_top_idx = np.argsort(neg_scores)[-10:][::-1]
+        
+        pos_words = [pos_features[i] for i in pos_top_idx]
+        pos_vals = [pos_scores[i] for i in pos_top_idx]
+        
+        neg_words = [neg_features[i] for i in neg_top_idx]
+        neg_vals = [neg_scores[i] for i in neg_top_idx]
+        
+        # Plot
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
+        
+        # Positive
+        bars1 = ax1.barh(pos_words, pos_vals, color='#4ecdc4', alpha=0.8)
+        ax1.set_title('Positive Keywords (TF-IDF)', fontweight='bold')
+        ax1.set_xlabel('TF-IDF Score')
+        
+        for bar, score in zip(bars1, pos_vals):
+            ax1.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2, 
+                    f'{score:.3f}', va='center', fontsize=9)
+        
+        # Negative
+        bars2 = ax2.barh(neg_words, neg_vals, color='#ff6b6b', alpha=0.8)
+        ax2.set_title('Negative Keywords (TF-IDF)', fontweight='bold')
+        ax2.set_xlabel('TF-IDF Score')
+        
+        for bar, score in zip(bars2, neg_vals):
+            ax2.text(bar.get_width() + 0.001, bar.get_y() + bar.get_height()/2, 
+                    f'{score:.3f}', va='center', fontsize=9)
+        
+        plt.tight_layout()
+        return fig
+        
+    except:
+        return None
+
 def plot_history():
-    if len(sentiment_history) < 2:
+    """Analysis history visualization"""
+    if len(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]
+    indices = list(range(len(history)))
+    pos_probs = [item['pos_prob'] for item in history]
+    confs = [item['confidence'] for item in 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)
+    colors = ['#4ecdc4' if p > 0.5 else '#ff6b6b' for p in pos_probs]
+    ax1.scatter(indices, pos_probs, c=colors, alpha=0.7, s=100)
+    ax1.plot(indices, pos_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_title('Sentiment 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.bar(indices, confs, alpha=0.7, color='lightblue', edgecolor='navy')
     ax2.set_title('Confidence Scores Over Time')
     ax2.set_xlabel('Analysis Number')
     ax2.set_ylabel('Confidence Score')
@@ -210,72 +414,83 @@ def plot_history():
     plt.tight_layout()
     return fig
 
+# Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft(), title="Movie Sentiment Analyzer") as demo:
-    gr.Markdown("# 🎬 AI Movie Sentiment Analyzer")
-    gr.Markdown("Advanced sentiment analysis for movie reviews using BERT model with comprehensive visualizations")
+    gr.Markdown("# 🎬 Movie Sentiment Analyzer")
+    gr.Markdown("Advanced sentiment analysis with comprehensive visualizations")
     
-    with gr.Tab("Single Review Analysis"):
+    with gr.Tab("Single 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...",
+            with gr.Column():
+                text_input = gr.Textbox(
+                    label="Movie Review",
+                    placeholder="Enter your movie review here...",
                     lines=5
                 )
-                analyze_btn = gr.Button("Analyze Sentiment", variant="primary", size="lg")
+                analyze_btn = gr.Button("Analyze", 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
-                )
+                gr.Examples([
+                    ["The cinematography was stunning, but the plot felt predictable."],
+                    ["A masterpiece! Amazing performances and direction."],
+                    ["Boring movie with terrible acting and weak plot."],
+                    ["Great special effects but cheesy dialogue."],
+                    ["Incredible ending that left me speechless!"]
+                ], inputs=text_input)
             
-            with gr.Column(scale=1):
-                sentiment_output = gr.Textbox(label="Analysis Result", lines=2)
+            with gr.Column():
+                result_output = gr.Textbox(label="Result", lines=2)
         
         with gr.Row():
-            prob_plot = gr.Plot(label="Probability Distribution")
-            gauge_plot = gr.Plot(label="Sentiment Gauge")
+            prob_plot = gr.Plot(label="Probabilities")
+            gauge_plot = gr.Plot(label="Confidence Gauge")
         
-        with gr.Row():
-            wordcloud_plot = gr.Plot(label="Word Cloud Visualization")
+        wordcloud_plot = gr.Plot(label="Word Cloud")
     
     with gr.Tab("Batch Analysis"):
-        gr.Markdown("### Analyze Multiple Reviews")
-        gr.Markdown("Enter multiple reviews separated by new lines for comparative analysis")
+        gr.Markdown("### Multiple Reviews Analysis")
         
         batch_input = gr.Textbox(
-            label="Multiple Reviews (one per line)",
-            placeholder="First review here...\nSecond review here...\nThird review here...",
+            label="Reviews (one per line)",
+            placeholder="Review 1...\nReview 2...\nReview 3...",
             lines=8
         )
-        batch_btn = gr.Button("Analyze All Reviews", variant="primary")
-        batch_plot = gr.Plot(label="Batch Analysis Results")
+        batch_btn = gr.Button("Analyze Batch", variant="primary")
+        batch_plot = gr.Plot(label="Batch Results")
+    
+    with gr.Tab("Advanced Analytics"):
+        gr.Markdown("### Advanced Visualizations")
+        
+        with gr.Row():
+            heatmap_btn = gr.Button("Keyword Heatmap", variant="primary")
+            network_btn = gr.Button("Word Network", variant="primary")
+            tfidf_btn = gr.Button("TF-IDF Analysis", variant="primary")
+        
+        heatmap_plot = gr.Plot(label="Keyword Sentiment Heatmap")
+        network_plot = gr.Plot(label="Word Co-occurrence Network")
+        tfidf_plot = gr.Plot(label="TF-IDF Keywords")
+        
+        gr.Markdown("**Status:** All features implemented")
     
-    with gr.Tab("Analysis History"):
-        gr.Markdown("### Historical Analysis Trends")
-        gr.Markdown("View patterns and trends from your previous analyses")
+    with gr.Tab("History"):
+        gr.Markdown("### Analysis History")
         
         with gr.Row():
-            history_plot = gr.Plot(label="Sentiment History")
-            refresh_btn = gr.Button("Refresh History", variant="secondary")
+            refresh_btn = gr.Button("Refresh", variant="secondary")
+            clear_btn = gr.Button("Clear History", variant="stop")
         
-        clear_btn = gr.Button("Clear History", variant="stop")
+        history_plot = gr.Plot(label="Historical Trends")
+    
+    # Event handlers
+    analyze_btn.click(analyze_text, inputs=text_input, 
+                     outputs=[result_output, prob_plot, gauge_plot, wordcloud_plot])
+    batch_btn.click(batch_analysis, inputs=batch_input, outputs=batch_plot)
     
-    analyze_btn.click(
-        fn=analyze_sentiment,
-        inputs=input_text,
-        outputs=[sentiment_output, prob_plot, gauge_plot, wordcloud_plot]
-    )
+    heatmap_btn.click(keyword_heatmap, outputs=heatmap_plot)
+    network_btn.click(cooccurrence_network, outputs=network_plot)
+    tfidf_btn.click(tfidf_analysis, outputs=tfidf_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)
+    refresh_btn.click(plot_history, outputs=history_plot)
+    clear_btn.click(lambda: history.clear(), outputs=None)
 
 demo.launch(share=True)