Create app.py

app.py

@@ -0,0 +1,455 @@
+# app.py
+import gradio as gr
+import torch
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+class AdvancedSentimentAnalyzer:
+    def __init__(self, model_name="tabularisai/multilingual-sentiment-analysis"):
+        self.model_name = model_name
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+        self.classifier = pipeline(
+            "text-classification",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            return_all_scores=True
+        )
+        
+        self.sentiment_map = {
+            0: "Very Negative", 
+            1: "Negative", 
+            2: "Neutral", 
+            3: "Positive", 
+            4: "Very Positive"
+        }
+        
+        self.sentiment_colors = {
+            "Very Negative": "#FF6B6B",
+            "Negative": "#FFA8A8", 
+            "Neutral": "#FFD93D",
+            "Positive": "#6BCF7F",
+            "Very Positive": "#4ECDC4"
+        }
+        
+        self.language_detection_keywords = {
+            'english': ['the', 'and', 'is', 'in', 'to'],
+            'spanish': ['el', 'la', 'de', 'que', 'y'],
+            'french': ['le', 'la', 'de', 'et', 'que'],
+            'german': ['der', 'die', 'das', 'und', 'zu'],
+            'italian': ['il', 'la', 'di', 'e', 'che'],
+            'portuguese': ['o', 'a', 'de', 'e', 'que'],
+            'dutch': ['de', 'het', 'en', 'van', 'te'],
+            'russian': ['и', 'в', 'не', 'на', 'я'],
+            'chinese': ['的', '是', '在', '了', '有'],
+            'japanese': ['の', 'に', 'は', 'を', 'た'],
+            'korean': ['이', '에', '는', '을', '다'],
+            'arabic': ['ال', 'في', 'من', 'على', 'أن'],
+            'hindi': ['की', 'से', 'है', 'और', 'के'],
+            'turkish': ['ve', 'bir', 'bu', 'ile', 'için']
+        }
+    
+    def detect_language(self, text):
+        """Simple language detection based on common words"""
+        text_lower = text.lower()
+        scores = {}
+        
+        for lang, keywords in self.language_detection_keywords.items():
+            score = sum(1 for keyword in keywords if keyword in text_lower)
+            scores[lang] = score
+        
+        detected_lang = max(scores, key=scores.get) if scores else 'unknown'
+        return detected_lang.capitalize()
+    
+    def analyze_sentiment(self, text):
+        """Advanced sentiment analysis with detailed metrics"""
+        try:
+            # Get predictions
+            predictions = self.classifier(text)[0]
+            
+            # Convert to structured format
+            sentiment_scores = {
+                self.sentiment_map[i]: pred['score'] 
+                for i, pred in enumerate(predictions)
+            }
+            
+            # Determine dominant sentiment
+            dominant_sentiment = max(sentiment_scores, key=sentiment_scores.get)
+            confidence = sentiment_scores[dominant_sentiment]
+            
+            # Calculate sentiment score (-2 to +2 scale)
+            sentiment_score = (
+                sentiment_scores["Very Positive"] * 2 +
+                sentiment_scores["Positive"] * 1 +
+                sentiment_scores["Neutral"] * 0 +
+                sentiment_scores["Negative"] * -1 +
+                sentiment_scores["Very Negative"] * -2
+            )
+            
+            # Detect language
+            detected_language = self.detect_language(text)
+            
+            # Emotional intensity
+            emotional_intensity = max(sentiment_scores.values()) - min(sentiment_scores.values())
+            
+            return {
+                'text': text,
+                'sentiment': dominant_sentiment,
+                'confidence': confidence,
+                'scores': sentiment_scores,
+                'sentiment_score': sentiment_score,
+                'language': detected_language,
+                'emotional_intensity': emotional_intensity,
+                'timestamp': datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            return {
+                'text': text,
+                'sentiment': 'Neutral',
+                'confidence': 0.0,
+                'scores': {sent: 0.2 for sent in self.sentiment_map.values()},
+                'sentiment_score': 0,
+                'language': 'Unknown',
+                'emotional_intensity': 0.0,
+                'error': str(e)
+            }
+    
+    def batch_analyze(self, texts):
+        """Analyze multiple texts"""
+        return [self.analyze_sentiment(text) for text in texts]
+
+# Initialize analyzer
+analyzer = AdvancedSentimentAnalyzer()
+
+def create_sentiment_chart(scores):
+    """Create beautiful sentiment distribution chart"""
+    fig = go.Figure(data=[
+        go.Bar(
+            x=list(scores.keys()),
+            y=list(scores.values()),
+            marker_color=[analyzer.sentiment_colors[sent] for sent in scores.keys()],
+            text=[f'{score:.1%}' for score in scores.values()],
+            textposition='auto',
+        )
+    ])
+    
+    fig.update_layout(
+        title="Sentiment Distribution",
+        xaxis_title="Sentiment",
+        yaxis_title="Confidence Score",
+        template="plotly_white",
+        height=300
+    )
+    
+    return fig
+
+def create_radar_chart(scores):
+    """Create radar chart for sentiment analysis"""
+    fig = go.Figure(data=go.Scatterpolar(
+        r=list(scores.values()),
+        theta=list(scores.keys()),
+        fill='toself',
+        line=dict(color='#4ECDC4'),
+        marker=dict(size=8)
+    ))
+    
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                range=[0, 1]
+            )),
+        showlegend=False,
+        template="plotly_white",
+        height=300
+    )
+    
+    return fig
+
+def analyze_single_review(review_text):
+    """Analyze single review with enhanced visualization"""
+    if not review_text.strip():
+        return "Please enter some text to analyze.", None, None
+    
+    result = analyzer.analyze_sentiment(review_text)
+    
+    # Create main output
+    sentiment_color = analyzer.sentiment_colors[result['sentiment']]
+    
+    output_html = f"""
+    <div style="padding: 25px; border-radius: 15px; background: linear-gradient(135deg, {sentiment_color}20, {sentiment_color}40); border-left: 5px solid {sentiment_color};">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
+            <h3 style="margin: 0; color: #2D3748;">🎯 Analysis Result</h3>
+            <span style="background-color: {sentiment_color}; color: white; padding: 5px 15px; border-radius: 20px; font-weight: bold;">
+                {result['sentiment'].upper()}
+            </span>
+        </div>
+        
+        <div style="background: white; padding: 15px; border-radius: 10px; margin: 10px 0;">
+            <p style="margin: 0; font-style: italic;">"{result['text']}"</p>
+        </div>
+        
+        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-top: 20px;">
+            <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
+                <div style="font-size: 24px; color: {sentiment_color}; margin-bottom: 5px;">📊</div>
+                <div style="font-weight: bold; color: #4A5568;">Confidence</div>
+                <div style="font-size: 18px; color: #2D3748;">{result['confidence']:.1%}</div>
+            </div>
+            
+            <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
+                <div style="font-size: 24px; color: {sentiment_color}; margin-bottom: 5px;">🌐</div>
+                <div style="font-weight: bold; color: #4A5568;">Language</div>
+                <div style="font-size: 18px; color: #2D3748;">{result['language']}</div>
+            </div>
+            
+            <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
+                <div style="font-size: 24px; color: {sentiment_color}; margin-bottom: 5px;">⚡</div>
+                <div style="font-weight: bold; color: #4A5568;">Intensity</div>
+                <div style="font-size: 18px; color: #2D3748;">{result['emotional_intensity']:.2f}</div>
+            </div>
+        </div>
+    </div>
+    """
+    
+    # Create charts
+    bar_chart = create_sentiment_chart(result['scores'])
+    radar_chart = create_radar_chart(result['scores'])
+    
+    return output_html, bar_chart, radar_chart
+
+def analyze_csv_file(csv_file):
+    """Analyze reviews from CSV file with advanced analytics"""
+    try:
+        df = pd.read_csv(csv_file.name)
+        
+        # Assume first column contains reviews
+        review_column = df.columns[0]
+        reviews = df[review_column].dropna().tolist()
+        
+        print(f"Analyzing {len(reviews)} reviews...")
+        results = analyzer.batch_analyze(reviews)
+        
+        # Create comprehensive results dataframe
+        results_df = pd.DataFrame({
+            'Review': [r['text'] for r in results],
+            'Sentiment': [r['sentiment'] for r in results],
+            'Confidence': [r['confidence'] for r in results],
+            'Sentiment_Score': [r['sentiment_score'] for r in results],
+            'Language': [r['language'] for r in results],
+            'Emotional_Intensity': [r['emotional_intensity'] for r in results],
+            'Very_Negative_Score': [r['scores']['Very Negative'] for r in results],
+            'Negative_Score': [r['scores']['Negative'] for r in results],
+            'Neutral_Score': [r['scores']['Neutral'] for r in results],
+            'Positive_Score': [r['scores']['Positive'] for r in results],
+            'Very_Positive_Score': [r['scores']['Very Positive'] for r in results],
+        })
+        
+        # Generate analytics
+        sentiment_counts = results_df['Sentiment'].value_counts()
+        avg_confidence = results_df['Confidence'].mean()
+        avg_sentiment_score = results_df['Sentiment_Score'].mean()
+        language_distribution = results_df['Language'].value_counts()
+        
+        # Create summary visualization
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('Sentiment Distribution', 'Language Distribution', 
+                          'Confidence Distribution', 'Sentiment Scores'),
+            specs=[[{"type": "pie"}, {"type": "pie"}],
+                   [{"type": "histogram"}, {"type": "histogram"}]]
+        )
+        
+        # Sentiment pie chart
+        fig.add_trace(
+            go.Pie(
+                labels=sentiment_counts.index,
+                values=sentiment_counts.values,
+                marker_colors=[analyzer.sentiment_colors[sent] for sent in sentiment_counts.index]
+            ), 1, 1
+        )
+        
+        # Language pie chart
+        fig.add_trace(
+            go.Pie(labels=language_distribution.index, values=language_distribution.values),
+            1, 2
+        )
+        
+        # Confidence histogram
+        fig.add_trace(go.Histogram(x=results_df['Confidence'], nbinsx=20), 2, 1)
+        
+        # Sentiment score histogram
+        fig.add_trace(go.Histogram(x=results_df['Sentiment_Score'], nbinsx=20), 2, 2)
+        
+        fig.update_layout(height=600, showlegend=False, template="plotly_white")
+        
+        # Save results
+        output_filename = f"advanced_sentiment_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        results_df.to_csv(output_filename, index=False)
+        
+        # Generate comprehensive summary
+        summary = f"""
+        📊 **BATCH ANALYSIS COMPLETE**
+        
+        **Dataset Overview:**
+        - 📝 Total Reviews Analyzed: {len(results):,}
+        - 🌐 Languages Detected: {len(language_distribution)}
+        - ⏱️ Analysis Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+        
+        **Sentiment Breakdown:**
+        🟢 Very Positive: {sentiment_counts.get('Very Positive', 0):,}
+        🟡 Positive: {sentiment_counts.get('Positive', 0):,}  
+        ⚪ Neutral: {sentiment_counts.get('Neutral', 0):,}
+        🟠 Negative: {sentiment_counts.get('Negative', 0):,}
+        🔴 Very Negative: {sentiment_counts.get('Very Negative', 0):,}
+        
+        **Performance Metrics:**
+        - 📈 Average Confidence: {avg_confidence:.1%}
+        - 🎯 Average Sentiment Score: {avg_sentiment_score:.2f}
+        - 🏆 Most Common Language: {language_distribution.index[0] if len(language_distribution) > 0 else 'N/A'}
+        
+        **Files Generated:**
+        - 💾 Results CSV: `{output_filename}`
+        - 📊 Analytics Dashboard: See chart below
+        
+        **Next Steps:**
+        - Download the CSV for detailed analysis
+        - Use filters to segment by sentiment or language
+        - Identify trends and patterns in customer feedback
+        """
+        
+        return summary, output_filename, fig
+        
+    except Exception as e:
+        return f"❌ Error processing file: {str(e)}", None, None
+
+# Create enhanced Gradio interface
+with gr.Blocks(
+    theme=gr.themes.Soft(),
+    title="🌍 Multilingual Sentiment Analyzer",
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .sentiment-positive { border-left: 4px solid #6BCF7F !important; }
+    .sentiment-negative { border-left: 4px solid #FF6B6B !important; }
+    .sentiment-neutral { border-left: 4px solid #FFD93D !important; }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🌍 Advanced Multilingual Sentiment Analysis
+    
+    *Powered by fine-tuned multilingual transformer model supporting 23 languages*
+    
+    Analyze customer reviews, social media posts, and feedback across multiple languages with state-of-the-art accuracy.
+    """)
+    
+    with gr.Tab("🔍 Single Review Analysis"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 📥 Input Review")
+                single_review = gr.Textbox(
+                    label="Enter text in any supported language",
+                    placeholder="Type your review here... (Supports 23 languages including English, Spanish, Chinese, French, German, Arabic, etc.)",
+                    lines=4,
+                    elem_id="review-input"
+                )
+                analyze_btn = gr.Button("🚀 Analyze Sentiment", variant="primary")
+                
+                gr.Markdown("""
+                **Supported Languages:** 
+                English, Chinese, Spanish, Hindi, Arabic, Bengali, Portuguese, Russian, 
+                Japanese, German, Malay, Telugu, Vietnamese, Korean, French, Turkish, 
+                Italian, Polish, Ukrainian, Tagalog, Dutch, Swiss German, Swahili
+                """)
+            
+            with gr.Column(scale=2):
+                gr.Markdown("### 📊 Analysis Results")
+                output_html = gr.HTML(label="Detailed Analysis")
+                
+                with gr.Row():
+                    bar_chart = gr.Plot(label="Sentiment Distribution")
+                    radar_chart = gr.Plot(label="Sentiment Radar")
+        
+        analyze_btn.click(
+            analyze_single_review,
+            inputs=single_review,
+            outputs=[output_html, bar_chart, radar_chart]
+        )
+    
+    with gr.Tab("📁 Batch CSV Analysis"):
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### 📤 Upload CSV File")
+                csv_upload = gr.File(
+                    label="Upload CSV file with reviews",
+                    file_types=[".csv"],
+                    type="filepath"
+                )
+                gr.Markdown("""
+                **CSV Format Requirements:**
+                - First column should contain the review text
+                - File should be UTF-8 encoded
+                - Maximum file size: 100MB
+                - Supports up to 10,000 reviews per batch
+                """)
+                
+                batch_analyze_btn = gr.Button("📈 Analyze Batch", variant="primary")
+            
+            with gr.Column():
+                gr.Markdown("### 📋 Analysis Summary")
+                batch_output = gr.Markdown(label="Batch Summary")
+                download_output = gr.File(label="Download Results")
+                batch_chart = gr.Plot(label="Batch Analytics")
+        
+        batch_analyze_btn.click(
+            analyze_csv_file,
+            inputs=csv_upload,
+            outputs=[batch_output, download_output, batch_chart]
+        )
+    
+    with gr.Tab("ℹ️ About & Instructions"):
+        gr.Markdown("""
+        ## 🎯 About This Tool
+        
+        This advanced sentiment analysis system uses a fine-tuned multilingual transformer model to analyze text in 23 languages.
+        
+        ### 🌟 Key Features
+        
+        - **Multilingual Support**: Analyze sentiment in 23 languages
+        - **5-Point Scale**: Very Negative → Negative → Neutral → Positive → Very Positive
+        - **Advanced Analytics**: Confidence scores, emotional intensity, language detection
+        - **Batch Processing**: Analyze thousands of reviews via CSV upload
+        - **Visual Analytics**: Interactive charts and comprehensive dashboards
+        
+        ### 🚀 Use Cases
+        
+        - **E-commerce**: Product reviews from global marketplaces
+        - **Customer Support**: Analyze support tickets and feedback
+        - **Social Media**: Monitor brand sentiment across languages
+        - **Market Research**: Understand international customer opinions
+        
+        ### 📊 Model Information
+        
+        - **Base Model**: `distilbert-base-multilingual-cased`
+        - **Fine-tuned on**: Synthetic multilingual data
+        - **Languages**: 23 languages including major world languages
+        - **Accuracy**: State-of-the-art performance across languages
+        
+        ### 🔧 Technical Details
+        
+        The model uses a transformer architecture fine-tuned specifically for sentiment analysis across multiple languages and cultural contexts.
+        """)
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        server_name="0.0.0.0",
+        show_error=True
+    )