Create app.py

app.py

@@ -0,0 +1,574 @@
+import torch
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import numpy as np
+from wordcloud import WordCloud
+from collections import Counter, defaultdict
+import re
+import json
+import csv
+import io
+import tempfile
+from datetime import datetime
+import logging
+from functools import lru_cache
+from dataclasses import dataclass
+from typing import List, Dict, Optional, Tuple
+import nltk
+from nltk.corpus import stopwords
+import langdetect
+import pandas as pd
+
+# Configuration
+@dataclass
+class Config:
+    MAX_HISTORY_SIZE: int = 500
+    BATCH_SIZE_LIMIT: int = 30
+    MAX_TEXT_LENGTH: int = 512
+    CACHE_SIZE: int = 64
+    
+    # Supported languages and models
+    SUPPORTED_LANGUAGES = {
+        'auto': 'Auto Detect',
+        'en': 'English',
+        'zh': 'Chinese',
+        'es': 'Spanish',
+        'fr': 'French',
+        'de': 'German'
+    }
+    
+    MODELS = {
+        'en': "cardiffnlp/twitter-roberta-base-sentiment-latest",
+        'multilingual': "cardiffnlp/twitter-xlm-roberta-base-sentiment"
+    }
+    
+    # Color themes
+    THEMES = {
+        'default': {'pos': '#4CAF50', 'neg': '#F44336', 'neu': '#FF9800'},
+        'ocean': {'pos': '#0077BE', 'neg': '#FF6B35', 'neu': '#00BCD4'},
+        'dark': {'pos': '#66BB6A', 'neg': '#EF5350', 'neu': '#FFA726'},
+        'rainbow': {'pos': '#9C27B0', 'neg': '#E91E63', 'neu': '#FF5722'}
+    }
+
+config = Config()
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize NLTK
+try:
+    nltk.download('stopwords', quiet=True)
+    nltk.download('punkt', quiet=True)
+    STOP_WORDS = set(stopwords.words('english'))
+except:
+    STOP_WORDS = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
+
+class ModelManager:
+    """Manages multiple language models"""
+    def __init__(self):
+        self.models = {}
+        self.tokenizers = {}
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self._load_default_model()
+    
+    def _load_default_model(self):
+        """Load the default English model"""
+        try:
+            model_name = config.MODELS['multilingual']  # Use multilingual as default
+            self.tokenizers['default'] = AutoTokenizer.from_pretrained(model_name)
+            self.models['default'] = AutoModelForSequenceClassification.from_pretrained(model_name)
+            self.models['default'].to(self.device)
+            logger.info(f"Default model loaded: {model_name}")
+        except Exception as e:
+            logger.error(f"Failed to load default model: {e}")
+            raise
+    
+    def get_model(self, language='en'):
+        """Get model for specific language"""
+        if language in ['en', 'auto'] or language not in config.SUPPORTED_LANGUAGES:
+            return self.models['default'], self.tokenizers['default']
+        return self.models['default'], self.tokenizers['default']  # Use multilingual for all
+    
+    @staticmethod
+    def detect_language(text: str) -> str:
+        """Detect text language"""
+        try:
+            detected = langdetect.detect(text)
+            return detected if detected in config.SUPPORTED_LANGUAGES else 'en'
+        except:
+            return 'en'
+
+model_manager = ModelManager()
+
+class HistoryManager:
+    """Manages analysis history"""
+    def __init__(self):
+        self._history = []
+    
+    def add_entry(self, entry: Dict):
+        self._history.append(entry)
+        if len(self._history) > config.MAX_HISTORY_SIZE:
+            self._history = self._history[-config.MAX_HISTORY_SIZE:]
+    
+    def get_history(self) -> List[Dict]:
+        return self._history.copy()
+    
+    def clear(self) -> int:
+        count = len(self._history)
+        self._history.clear()
+        return count
+    
+    def get_stats(self) -> Dict:
+        if not self._history:
+            return {}
+        
+        sentiments = [item['sentiment'] for item in self._history]
+        confidences = [item['confidence'] for item in self._history]
+        
+        return {
+            'total_analyses': len(self._history),
+            'positive_count': sentiments.count('Positive'),
+            'negative_count': sentiments.count('Negative'),
+            'avg_confidence': np.mean(confidences),
+            'languages_detected': len(set(item.get('language', 'en') for item in self._history))
+        }
+
+history_manager = HistoryManager()
+
+class TextProcessor:
+    """Enhanced text processing"""
+    
+    @staticmethod
+    @lru_cache(maxsize=config.CACHE_SIZE)
+    def clean_text(text: str, remove_punctuation: bool = True, remove_numbers: bool = False) -> str:
+        """Clean text with options"""
+        text = text.lower().strip()
+        
+        if remove_numbers:
+            text = re.sub(r'\d+', '', text)
+        
+        if remove_punctuation:
+            text = re.sub(r'[^\w\s]', '', text)
+        
+        words = text.split()
+        cleaned_words = [w for w in words if w not in STOP_WORDS and len(w) > 2]
+        return ' '.join(cleaned_words)
+    
+    @staticmethod
+    def extract_keywords(text: str, top_k: int = 5) -> List[str]:
+        """Extract key words from text"""
+        cleaned = TextProcessor.clean_text(text)
+        words = cleaned.split()
+        word_freq = Counter(words)
+        return [word for word, _ in word_freq.most_common(top_k)]
+
+class SentimentAnalyzer:
+    """Enhanced sentiment analysis"""
+    
+    @staticmethod
+    def analyze_text(text: str, language: str = 'auto', preprocessing_options: Dict = None) -> Dict:
+        """Analyze single text with language support"""
+        if not text.strip():
+            raise ValueError("Empty text provided")
+        
+        # Detect language if auto
+        if language == 'auto':
+            detected_lang = model_manager.detect_language(text)
+        else:
+            detected_lang = language
+        
+        # Get appropriate model
+        model, tokenizer = model_manager.get_model(detected_lang)
+        
+        # Preprocessing options
+        options = preprocessing_options or {}
+        processed_text = text
+        if options.get('clean_text', False):
+            processed_text = TextProcessor.clean_text(
+                text, 
+                options.get('remove_punctuation', True),
+                options.get('remove_numbers', False)
+            )
+        
+        try:
+            # Tokenize and analyze
+            inputs = tokenizer(processed_text, return_tensors="pt", padding=True, 
+                             truncation=True, max_length=config.MAX_TEXT_LENGTH).to(model_manager.device)
+            
+            with torch.no_grad():
+                outputs = model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
+                
+            # Handle different model outputs
+            if len(probs) == 3:  # negative, neutral, positive
+                sentiment_idx = np.argmax(probs)
+                sentiment_labels = ['Negative', 'Neutral', 'Positive']
+                sentiment = sentiment_labels[sentiment_idx]
+                confidence = float(probs[sentiment_idx])
+                
+                result = {
+                    'sentiment': sentiment,
+                    'confidence': confidence,
+                    'neg_prob': float(probs[0]),
+                    'neu_prob': float(probs[1]),
+                    'pos_prob': float(probs[2]),
+                    'has_neutral': True
+                }
+            else:  # negative, positive
+                pred = np.argmax(probs)
+                sentiment = "Positive" if pred == 1 else "Negative"
+                confidence = float(probs[pred])
+                
+                result = {
+                    'sentiment': sentiment,
+                    'confidence': confidence,
+                    'neg_prob': float(probs[0]),
+                    'pos_prob': float(probs[1]),
+                    'neu_prob': 0.0,
+                    'has_neutral': False
+                }
+            
+            # Add metadata
+            result.update({
+                'language': detected_lang,
+                'keywords': TextProcessor.extract_keywords(text),
+                'word_count': len(text.split()),
+                'char_count': len(text)
+            })
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Analysis failed: {e}")
+            raise
+
+class PlotlyVisualizer:
+    """Enhanced visualizations with Plotly"""
+    
+    @staticmethod
+    def create_sentiment_gauge(result: Dict, theme: str = 'default') -> go.Figure:
+        """Create an animated sentiment gauge"""
+        colors = config.THEMES[theme]
+        
+        if result['has_neutral']:
+            # Three-way gauge
+            fig = go.Figure(go.Indicator(
+                mode = "gauge+number+delta",
+                value = result['pos_prob'] * 100,
+                domain = {'x': [0, 1], 'y': [0, 1]},
+                title = {'text': f"Sentiment: {result['sentiment']}"},
+                delta = {'reference': 50},
+                gauge = {
+                    'axis': {'range': [None, 100]},
+                    'bar': {'color': colors['pos'] if result['sentiment'] == 'Positive' else colors['neg']},
+                    'steps': [
+                        {'range': [0, 33], 'color': colors['neg']},
+                        {'range': [33, 67], 'color': colors['neu']},
+                        {'range': [67, 100], 'color': colors['pos']}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': 90
+                    }
+                }
+            ))
+        else:
+            # Two-way gauge
+            fig = go.Figure(go.Indicator(
+                mode = "gauge+number",
+                value = result['confidence'] * 100,
+                domain = {'x': [0, 1], 'y': [0, 1]},
+                title = {'text': f"Confidence: {result['sentiment']}"},
+                gauge = {
+                    'axis': {'range': [None, 100]},
+                    'bar': {'color': colors['pos'] if result['sentiment'] == 'Positive' else colors['neg']},
+                    'steps': [
+                        {'range': [0, 50], 'color': "lightgray"},
+                        {'range': [50, 100], 'color': "gray"}
+                    ]
+                }
+            ))
+        
+        fig.update_layout(height=400, font={'size': 16})
+        return fig
+    
+    @staticmethod
+    def create_probability_bars(result: Dict, theme: str = 'default') -> go.Figure:
+        """Create probability bar chart"""
+        colors = config.THEMES[theme]
+        
+        if result['has_neutral']:
+            labels = ['Negative', 'Neutral', 'Positive']
+            values = [result['neg_prob'], result['neu_prob'], result['pos_prob']]
+            bar_colors = [colors['neg'], colors['neu'], colors['pos']]
+        else:
+            labels = ['Negative', 'Positive']
+            values = [result['neg_prob'], result['pos_prob']]
+            bar_colors = [colors['neg'], colors['pos']]
+        
+        fig = go.Figure(data=[
+            go.Bar(x=labels, y=values, marker_color=bar_colors, text=[f'{v:.3f}' for v in values])
+        ])
+        
+        fig.update_traces(texttemplate='%{text}', textposition='outside')
+        fig.update_layout(
+            title="Sentiment Probabilities",
+            yaxis_title="Probability",
+            height=400,
+            showlegend=False
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_history_dashboard(history: List[Dict]) -> go.Figure:
+        """Create comprehensive history dashboard"""
+        if len(history) < 2:
+            return go.Figure()
+        
+        # Create subplots
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=['Sentiment Timeline', 'Confidence Distribution', 
+                           'Language Distribution', 'Sentiment Summary'],
+            specs=[[{"secondary_y": False}, {"secondary_y": False}],
+                   [{"type": "pie"}, {"type": "bar"}]]
+        )
+        
+        # Extract data
+        indices = list(range(len(history)))
+        pos_probs = [item['pos_prob'] for item in history]
+        confidences = [item['confidence'] for item in history]
+        sentiments = [item['sentiment'] for item in history]
+        languages = [item.get('language', 'en') for item in history]
+        
+        # Sentiment timeline
+        colors = ['#4CAF50' if s == 'Positive' else '#F44336' for s in sentiments]
+        fig.add_trace(
+            go.Scatter(x=indices, y=pos_probs, mode='lines+markers', 
+                      marker=dict(color=colors, size=8),
+                      name='Positive Probability'),
+            row=1, col=1
+        )
+        
+        # Confidence distribution
+        fig.add_trace(
+            go.Histogram(x=confidences, nbinsx=10, name='Confidence'),
+            row=1, col=2
+        )
+        
+        # Language distribution
+        lang_counts = Counter(languages)
+        fig.add_trace(
+            go.Pie(labels=list(lang_counts.keys()), values=list(lang_counts.values()),
+                   name="Languages"),
+            row=2, col=1
+        )
+        
+        # Sentiment summary
+        sent_counts = Counter(sentiments)
+        fig.add_trace(
+            go.Bar(x=list(sent_counts.keys()), y=list(sent_counts.values()),
+                   marker_color=['#4CAF50' if k == 'Positive' else '#F44336' for k in sent_counts.keys()]),
+            row=2, col=2
+        )
+        
+        fig.update_layout(height=800, showlegend=False)
+        return fig
+
+# Main application functions
+def analyze_single_text(text: str, language: str, theme: str, clean_text: bool, 
+                       remove_punct: bool, remove_nums: bool):
+    """Enhanced single text analysis"""
+    try:
+        if not text.strip():
+            return "Please enter text", None, None, "No analysis performed"
+        
+        preprocessing_options = {
+            'clean_text': clean_text,
+            'remove_punctuation': remove_punct,
+            'remove_numbers': remove_nums
+        }
+        
+        result = SentimentAnalyzer.analyze_text(text, language, preprocessing_options)
+        
+        # Add to history
+        history_entry = {
+            'text': text[:100] + '...' if len(text) > 100 else text,
+            'full_text': text,
+            'sentiment': result['sentiment'],
+            'confidence': result['confidence'],
+            'pos_prob': result['pos_prob'],
+            'neg_prob': result['neg_prob'],
+            'neu_prob': result.get('neu_prob', 0),
+            'language': result['language'],
+            'timestamp': datetime.now().isoformat()
+        }
+        history_manager.add_entry(history_entry)
+        
+        # Create visualizations
+        gauge_fig = PlotlyVisualizer.create_sentiment_gauge(result, theme)
+        bars_fig = PlotlyVisualizer.create_probability_bars(result, theme)
+        
+        # Create info text
+        info_text = f"""
+**Analysis Results:**
+- **Sentiment:** {result['sentiment']} ({result['confidence']:.3f} confidence)
+- **Language:** {result['language'].upper()}
+- **Keywords:** {', '.join(result['keywords'])}
+- **Stats:** {result['word_count']} words, {result['char_count']} characters
+        """
+        
+        return info_text, gauge_fig, bars_fig, "Analysis completed successfully"
+        
+    except Exception as e:
+        logger.error(f"Analysis failed: {e}")
+        return f"Error: {str(e)}", None, None, "Analysis failed"
+
+def get_history_stats():
+    """Get history statistics"""
+    stats = history_manager.get_stats()
+    if not stats:
+        return "No analysis history available"
+    
+    return f"""
+**History Statistics:**
+- Total Analyses: {stats['total_analyses']}
+- Positive: {stats['positive_count']} | Negative: {stats['negative_count']}
+- Average Confidence: {stats['avg_confidence']:.3f}
+- Languages Detected: {stats['languages_detected']}
+    """
+
+def plot_history_dashboard():
+    """Create history dashboard"""
+    history = history_manager.get_history()
+    if len(history) < 2:
+        return None, "Need at least 2 analyses for dashboard"
+    
+    fig = PlotlyVisualizer.create_history_dashboard(history)
+    return fig, f"Dashboard showing {len(history)} analyses"
+
+def export_history_excel():
+    """Export history to Excel"""
+    history = history_manager.get_history()
+    if not history:
+        return None, "No history to export"
+    
+    try:
+        df = pd.DataFrame(history)
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.xlsx')
+        df.to_excel(temp_file.name, index=False)
+        return temp_file.name, f"Exported {len(history)} entries to Excel"
+    except Exception as e:
+        return None, f"Export failed: {str(e)}"
+
+def clear_all_history():
+    """Clear analysis history"""
+    count = history_manager.clear()
+    return f"Cleared {count} entries from history"
+
+# Sample data
+SAMPLE_TEXTS = [
+    ["Amazing movie with incredible acting and stunning visuals!"],
+    ["Terrible film, waste of time and money."],
+    ["The movie was okay, nothing special but not bad either."],
+    ["¡Excelente película! Me encantó la historia."],  # Spanish
+    ["这部电影很棒，我非常喜欢！"],  # Chinese
+]
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Sentiment Analyzer") as demo:
+    gr.Markdown("# 🎭 Advanced Multilingual Sentiment Analyzer")
+    gr.Markdown("Analyze sentiment with multiple languages, themes, and advanced visualizations")
+    
+    with gr.Tab("📝 Single Analysis"):
+        with gr.Row():
+            with gr.Column(scale=2):
+                text_input = gr.Textbox(
+                    label="Text to Analyze",
+                    placeholder="Enter your text here... (supports multiple languages)",
+                    lines=4
+                )
+                
+                with gr.Row():
+                    language_select = gr.Dropdown(
+                        choices=list(config.SUPPORTED_LANGUAGES.items()),
+                        value='auto',
+                        label="Language"
+                    )
+                    theme_select = gr.Dropdown(
+                        choices=list(config.THEMES.keys()),
+                        value='default',
+                        label="Theme"
+                    )
+                
+                with gr.Row():
+                    clean_text = gr.Checkbox(label="Clean Text", value=False)
+                    remove_punct = gr.Checkbox(label="Remove Punctuation", value=True)
+                    remove_nums = gr.Checkbox(label="Remove Numbers", value=False)
+                
+                analyze_btn = gr.Button("🔍 Analyze", variant="primary", size="lg")
+                
+                gr.Examples(
+                    examples=SAMPLE_TEXTS,
+                    inputs=text_input,
+                    label="Sample Texts (Multiple Languages)"
+                )
+            
+            with gr.Column(scale=1):
+                result_info = gr.Markdown("Enter text and click Analyze")
+        
+        with gr.Row():
+            gauge_plot = gr.Plot(label="Sentiment Gauge")
+            bars_plot = gr.Plot(label="Probability Distribution")
+        
+        status_output = gr.Textbox(label="Status", interactive=False)
+    
+    with gr.Tab("📊 History & Analytics"):
+        with gr.Row():
+            stats_btn = gr.Button("📈 Get Statistics")
+            dashboard_btn = gr.Button("📊 View Dashboard")
+            clear_btn = gr.Button("🗑️ Clear History", variant="stop")
+        
+        with gr.Row():
+            export_excel_btn = gr.Button("📁 Export Excel")
+        
+        stats_output = gr.Markdown("Click 'Get Statistics' to view analysis history")
+        dashboard_plot = gr.Plot(label="Analytics Dashboard")
+        excel_file = gr.File(label="Download Excel Report")
+        history_status = gr.Textbox(label="Status", interactive=False)
+    
+    # Event handlers
+    analyze_btn.click(
+        analyze_single_text,
+        inputs=[text_input, language_select, theme_select, clean_text, remove_punct, remove_nums],
+        outputs=[result_info, gauge_plot, bars_plot, status_output]
+    )
+    
+    stats_btn.click(
+        get_history_stats,
+        outputs=stats_output
+    )
+    
+    dashboard_btn.click(
+        plot_history_dashboard,
+        outputs=[dashboard_plot, history_status]
+    )
+    
+    export_excel_btn.click(
+        export_history_excel,
+        outputs=[excel_file, history_status]
+    )
+    
+    clear_btn.click(
+        clear_all_history,
+        outputs=history_status
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)