Upload sentiment_app.py

sentiment_app.py

@@ -0,0 +1,469 @@
+import gradio as gr
+import torch
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
+import numpy as np
+from datetime import datetime
+import io
+import base64
+
+# Setup plotting style
+sns.set_style("whitegrid")
+plt.rcParams['figure.figsize'] = (10, 6)
+
+class SentimentAnalyzer:
+    def __init__(self, model_name="w11wo/indonesian-roberta-base-sentiment-classifier"):
+        """
+        Initialize sentiment analyzer with Indonesian RoBERTa model
+        Model ini dipilih karena:
+        - Sudah pre-trained untuk sentiment analysis
+        - Cepat (RoBERTa lebih efisien dari BERT)
+        - Tahan terhadap slang dan variasi bahasa Indonesia
+        """
+        print(f"Loading model: {model_name}")
+        self.device = 0 if torch.cuda.is_available() else -1
+        
+        # Load sentiment analysis pipeline
+        self.sentiment_pipeline = pipeline(
+            "sentiment-analysis",
+            model=model_name,
+            device=self.device,
+            truncation=True,
+            max_length=512
+        )
+        
+        # Mapping label untuk kategori keluhan
+        self.label_mapping = {
+            "POSITIVE": "Positif/Pujian",
+            "NEGATIVE": "Keluhan/Kritik",
+            "NEUTRAL": "Netral/Pertanyaan"
+        }
+        
+        print("Model loaded successfully!")
+    
+    def analyze(self, text):
+        """Analyze sentiment of a single text"""
+        if not text or text.strip() == "":
+            return {
+                "label": "Invalid",
+                "kategori": "Input kosong",
+                "confidence": 0.0,
+                "interpretation": "Silakan masukkan teks untuk dianalisis"
+            }
+        
+        result = self.sentiment_pipeline(text)[0]
+        label = result['label'].upper()
+        score = result['score']
+        
+        # Interpretasi berdasarkan confidence
+        if score >= 0.8:
+            confidence_level = "Sangat Yakin"
+        elif score >= 0.6:
+            confidence_level = "Yakin"
+        else:
+            confidence_level = "Kurang Yakin"
+        
+        # Interpretasi untuk admin bencana
+        if label == "NEGATIVE":
+            if score >= 0.8:
+                interpretation = "⚠️ PRIORITAS TINGGI - Keluhan serius yang memerlukan tindakan segera"
+            else:
+                interpretation = "⚡ Keluhan yang perlu ditindaklanjuti"
+        elif label == "POSITIVE":
+            interpretation = "✅ Feedback positif atau apresiasi"
+        else:
+            interpretation = "ℹ️ Pertanyaan atau informasi netral"
+        
+        return {
+            "label": label,
+            "kategori": self.label_mapping.get(label, label),
+            "confidence": score,
+            "confidence_level": confidence_level,
+            "interpretation": interpretation
+        }
+    
+    def batch_analyze(self, texts):
+        """Analyze multiple texts"""
+        results = []
+        for text in texts:
+            result = self.analyze(text)
+            results.append(result)
+        return results
+    
+    def evaluate_model(self, test_texts, true_labels):
+        """
+        Evaluate model performance with visualization
+        test_texts: list of texts
+        true_labels: list of true labels (POSITIVE, NEGATIVE, NEUTRAL)
+        """
+        predictions = []
+        pred_labels = []
+        
+        for text in test_texts:
+            result = self.analyze(text)
+            predictions.append(result)
+            pred_labels.append(result['label'])
+        
+        # Calculate metrics
+        accuracy = accuracy_score(true_labels, pred_labels)
+        report = classification_report(
+            true_labels, 
+            pred_labels,
+            target_names=list(set(true_labels)),
+            output_dict=True,
+            zero_division=0
+        )
+        
+        # Create confusion matrix
+        cm = confusion_matrix(true_labels, pred_labels, labels=list(set(true_labels)))
+        
+        return {
+            'accuracy': accuracy,
+            'classification_report': report,
+            'confusion_matrix': cm,
+            'predictions': predictions,
+            'labels': list(set(true_labels))
+        }
+
+# Initialize analyzer
+analyzer = SentimentAnalyzer()
+
+# Sample data untuk testing (contoh keluhan bencana dan feedback masyarakat)
+SAMPLE_DATA = {
+    "texts": [
+        "Bantuan bencana sangat lambat, kami sudah 3 hari belum dapat makanan!",
+        "Terima kasih banyak atas bantuan yang cepat, sangat membantu kami",
+        "Kapan bantuan akan tiba di lokasi kami?",
+        "Posko pengungsian penuh, tidak ada tempat untuk tidur!",
+        "Tim relawan sangat baik dan peduli",
+        "Mohon info jalur evakuasi terdekat",
+        "Air bersih habis, kondisi sangat memprihatinkan",
+        "Koordinasi tim bantuan sangat bagus",
+        "Gimana cara daftar bantuan sosial?",
+        "Hadeh parah banget nih pelayanan, gak jelas!",
+        "Mantap jiwa pelayanannya, cepet banget",
+        "Mana nih bantuan yang dijanjikan? Udah lama nungguin!",
+        "Alhamdulillah bantuan sudah sampai dengan selamat",
+        "Tempat pengungsian kotor dan tidak layak!",
+        "Bagaimana prosedur mendapatkan bantuan medis?"
+    ],
+    "labels": [
+        "NEGATIVE", "POSITIVE", "NEUTRAL",
+        "NEGATIVE", "POSITIVE", "NEUTRAL",
+        "NEGATIVE", "POSITIVE", "NEUTRAL",
+        "NEGATIVE", "POSITIVE", "NEGATIVE",
+        "POSITIVE", "NEGATIVE", "NEUTRAL"
+    ]
+}
+
+def analyze_single_text(text):
+    """Gradio function for single text analysis"""
+    result = analyzer.analyze(text)
+    
+    # Format output
+    output = f"""
+    🎯 **Hasil Analisis:**
+    
+    📊 **Kategori**: {result['kategori']}
+    📈 **Confidence**: {result['confidence']:.2%} ({result['confidence_level']})
+    💡 **Interpretasi**: {result['interpretation']}
+    """
+    
+    return output
+
+def analyze_batch_texts(text_input):
+    """Gradio function for batch text analysis"""
+    if not text_input or text_input.strip() == "":
+        return "Silakan masukkan teks (satu per baris)"
+    
+    texts = [t.strip() for t in text_input.split('\n') if t.strip()]
+    results = analyzer.batch_analyze(texts)
+    
+    # Create DataFrame for display
+    df_data = []
+    for text, result in zip(texts, results):
+        df_data.append({
+            'Teks': text[:50] + '...' if len(text) > 50 else text,
+            'Kategori': result['kategori'],
+            'Confidence': f"{result['confidence']:.2%}",
+            'Prioritas': '🔴' if result['label'] == 'NEGATIVE' and result['confidence'] >= 0.8 else 
+                        '🟡' if result['label'] == 'NEGATIVE' else '🟢'
+        })
+    
+    df = pd.DataFrame(df_data)
+    
+    # Count statistics
+    total = len(results)
+    keluhan = sum(1 for r in results if r['label'] == 'NEGATIVE')
+    positif = sum(1 for r in results if r['label'] == 'POSITIVE')
+    netral = sum(1 for r in results if r['label'] == 'NEUTRAL')
+    
+    stats = f"""
+    📊 **Ringkasan Analisis:**
+    - Total pesan: {total}
+    - Keluhan/Kritik: {keluhan} ({keluhan/total*100:.1f}%)
+    - Positif/Pujian: {positif} ({positif/total*100:.1f}%)
+    - Netral/Pertanyaan: {netral} ({netral/total*100:.1f}%)
+    """
+    
+    return stats + "\n\n" + df.to_markdown(index=False)
+
+def run_evaluation():
+    """Run model evaluation with visualization"""
+    eval_results = analyzer.evaluate_model(
+        SAMPLE_DATA['texts'],
+        SAMPLE_DATA['labels']
+    )
+    
+    # Create visualizations
+    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+    
+    # 1. Confusion Matrix
+    cm = eval_results['confusion_matrix']
+    labels = eval_results['labels']
+    sns.heatmap(
+        cm, 
+        annot=True, 
+        fmt='d', 
+        cmap='Blues',
+        xticklabels=[analyzer.label_mapping.get(l, l) for l in labels],
+        yticklabels=[analyzer.label_mapping.get(l, l) for l in labels],
+        ax=axes[0, 0]
+    )
+    axes[0, 0].set_title('Confusion Matrix', fontsize=14, fontweight='bold')
+    axes[0, 0].set_ylabel('True Label')
+    axes[0, 0].set_xlabel('Predicted Label')
+    
+    # 2. Per-class metrics
+    report = eval_results['classification_report']
+    metrics_data = []
+    for label in labels:
+        if label in report:
+            metrics_data.append({
+                'Class': analyzer.label_mapping.get(label, label),
+                'Precision': report[label]['precision'],
+                'Recall': report[label]['recall'],
+                'F1-Score': report[label]['f1-score']
+            })
+    
+    df_metrics = pd.DataFrame(metrics_data)
+    x = np.arange(len(df_metrics))
+    width = 0.25
+    
+    axes[0, 1].bar(x - width, df_metrics['Precision'], width, label='Precision', alpha=0.8)
+    axes[0, 1].bar(x, df_metrics['Recall'], width, label='Recall', alpha=0.8)
+    axes[0, 1].bar(x + width, df_metrics['F1-Score'], width, label='F1-Score', alpha=0.8)
+    axes[0, 1].set_xlabel('Class')
+    axes[0, 1].set_ylabel('Score')
+    axes[0, 1].set_title('Metrics per Class', fontsize=14, fontweight='bold')
+    axes[0, 1].set_xticks(x)
+    axes[0, 1].set_xticklabels(df_metrics['Class'], rotation=15)
+    axes[0, 1].legend()
+    axes[0, 1].set_ylim([0, 1.1])
+    axes[0, 1].grid(axis='y', alpha=0.3)
+    
+    # 3. Confidence distribution
+    confidences = [p['confidence'] for p in eval_results['predictions']]
+    axes[1, 0].hist(confidences, bins=20, color='skyblue', edgecolor='black', alpha=0.7)
+    axes[1, 0].axvline(np.mean(confidences), color='red', linestyle='--', 
+                       label=f'Mean: {np.mean(confidences):.3f}', linewidth=2)
+    axes[1, 0].set_xlabel('Confidence Score')
+    axes[1, 0].set_ylabel('Frequency')
+    axes[1, 0].set_title('Confidence Distribution', fontsize=14, fontweight='bold')
+    axes[1, 0].legend()
+    axes[1, 0].grid(axis='y', alpha=0.3)
+    
+    # 4. Label distribution
+    pred_labels = [p['label'] for p in eval_results['predictions']]
+    label_counts = pd.Series(pred_labels).value_counts()
+    colors = {'POSITIVE': '#4CAF50', 'NEGATIVE': '#F44336', 'NEUTRAL': '#FFC107'}
+    plot_colors = [colors.get(l, '#999999') for l in label_counts.index]
+    
+    axes[1, 1].pie(
+        label_counts.values,
+        labels=[analyzer.label_mapping.get(l, l) for l in label_counts.index],
+        autopct='%1.1f%%',
+        colors=plot_colors,
+        startangle=90
+    )
+    axes[1, 1].set_title('Prediction Distribution', fontsize=14, fontweight='bold')
+    
+    plt.tight_layout()
+    
+    # Summary text
+    summary = f"""
+    ╔══════════════════════════════════════════════════╗
+    ║          EVALUASI MODEL SENTIMENT ANALYSIS        ║
+    ╚══════════════════════════════════════════════════╝
+    
+    📊 Overall Accuracy: {eval_results['accuracy']:.2%}
+    
+    📈 Detailed Metrics:
+    """
+    
+    for label in labels:
+        if label in report:
+            summary += f"""
+    {analyzer.label_mapping.get(label, label)}:
+      - Precision: {report[label]['precision']:.3f}
+      - Recall: {report[label]['recall']:.3f}
+      - F1-Score: {report[label]['f1-score']:.3f}
+      - Support: {report[label]['support']}
+    """
+    
+    summary += f"""
+    
+    💡 Interpretasi:
+    - Model menunjukkan performa {'BAIK' if eval_results['accuracy'] > 0.8 else 'CUKUP BAIK' if eval_results['accuracy'] > 0.6 else 'PERLU DITINGKATKAN'}
+    - Confidence rata-rata: {np.mean(confidences):.3f}
+    - Cocok untuk filtering keluhan masyarakat secara otomatis
+    - Dapat menangani slang dan variasi bahasa Indonesia
+    
+    Waktu Evaluasi: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+    """
+    
+    return fig, summary
+
+# Create Gradio Interface
+with gr.Blocks(title="Analisis Sentimen Keluhan Masyarakat", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🎯 Sistem Analisis Sentimen Keluhan Masyarakat
+    
+    **Model**: Indonesian RoBERTa Sentiment Classifier
+    
+    Sistem ini menggunakan model `w11wo/indonesian-roberta-base-sentiment-classifier` yang:
+    - ✅ Sudah pre-trained untuk analisis sentimen Bahasa Indonesia
+    - ⚡ Cepat dan efisien (berbasis RoBERTa)
+    - 🎭 Tahan terhadap slang dan variasi bahasa informal
+    - 🎯 Akurat untuk membedakan keluhan, pujian, dan pertanyaan
+    
+    ---
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Single Text Analysis
+        with gr.Tab("📝 Analisis Teks Tunggal"):
+            gr.Markdown("### Analisis sentimen untuk satu teks")
+            with gr.Row():
+                with gr.Column():
+                    input_text = gr.Textbox(
+                        label="Masukkan Teks",
+                        placeholder="Contoh: Bantuan sangat lambat, sudah 3 hari belum dapat makanan!",
+                        lines=5
+                    )
+                    analyze_btn = gr.Button("🔍 Analisis", variant="primary")
+                with gr.Column():
+                    output_single = gr.Markdown(label="Hasil Analisis")
+            
+            # Examples
+            gr.Examples(
+                examples=[
+                    ["Bantuan bencana sangat lambat, kami sudah 3 hari belum dapat makanan!"],
+                    ["Terima kasih banyak atas bantuan yang cepat, sangat membantu kami"],
+                    ["Kapan bantuan akan tiba di lokasi kami?"],
+                    ["Hadeh parah banget nih pelayanan, gak jelas!"],
+                    ["Mantap jiwa pelayanannya, cepet banget"],
+                ],
+                inputs=input_text
+            )
+            
+            analyze_btn.click(analyze_single_text, inputs=input_text, outputs=output_single)
+        
+        # Tab 2: Batch Analysis
+        with gr.Tab("📊 Analisis Batch"):
+            gr.Markdown("### Analisis sentimen untuk multiple teks (satu per baris)")
+            with gr.Row():
+                with gr.Column():
+                    input_batch = gr.Textbox(
+                        label="Masukkan Teks (satu per baris)",
+                        placeholder="Contoh:\nBantuan sangat lambat!\nTerima kasih banyak\nKapan bantuan tiba?",
+                        lines=10
+                    )
+                    batch_btn = gr.Button("🔍 Analisis Batch", variant="primary")
+                    
+                    load_sample_btn = gr.Button("📋 Load Sample Data", variant="secondary")
+                with gr.Column():
+                    output_batch = gr.Markdown(label="Hasil Analisis Batch")
+            
+            batch_btn.click(analyze_batch_texts, inputs=input_batch, outputs=output_batch)
+            load_sample_btn.click(
+                lambda: '\n'.join(SAMPLE_DATA['texts']),
+                outputs=input_batch
+            )
+        
+        # Tab 3: Model Evaluation
+        with gr.Tab("📈 Evaluasi Model"):
+            gr.Markdown("""
+            ### Evaluasi Performa Model
+            
+            Menggunakan dataset sample untuk mengevaluasi performa model dengan berbagai metrik.
+            """)
+            eval_btn = gr.Button("🚀 Jalankan Evaluasi", variant="primary", size="lg")
+            
+            with gr.Row():
+                eval_plot = gr.Plot(label="Visualisasi Evaluasi")
+            
+            eval_summary = gr.Textbox(label="Ringkasan Evaluasi", lines=20)
+            
+            eval_btn.click(run_evaluation, outputs=[eval_plot, eval_summary])
+        
+        # Tab 4: Info
+        with gr.Tab("ℹ️ Informasi"):
+            gr.Markdown("""
+            ## 📚 Tentang Sistem
+            
+            ### Model yang Digunakan
+            **w11wo/indonesian-roberta-base-sentiment-classifier**
+            
+            #### Kenapa Model Ini?
+            1. **Pre-trained & Siap Pakai**: Tidak perlu training tambahan
+            2. **Berbasis RoBERTa**: Lebih cepat dan efisien dibanding BERT
+            3. **Bahasa Indonesia**: Dilatih khusus untuk teks Bahasa Indonesia
+            4. **Tahan Slang**: Mampu memahami variasi bahasa informal dan slang
+            5. **Akurat**: Presisi tinggi untuk klasifikasi sentimen
+            
+            ### Output Labels
+            - **POSITIVE**: Feedback positif, pujian, apresiasi
+            - **NEGATIVE**: Keluhan, kritik, masalah yang perlu ditangani
+            - **NEUTRAL**: Pertanyaan, informasi netral, inquiry
+            
+            ### Use Case: Admin Bencana
+            Sistem ini sangat cocok untuk:
+            - ✅ Filtering keluhan prioritas tinggi dari ribuan pesan
+            - ✅ Identifikasi masalah urgent yang perlu tindakan segera
+            - ✅ Monitoring sentimen masyarakat terhadap bantuan
+            - ✅ Analisis feedback untuk perbaikan layanan
+            
+            ### Perbandingan Model (yang dipilih vs alternatif)
+            
+            | Model | Kecepatan | Akurasi | Tahan Slang | Siap Pakai |
+            |-------|-----------|---------|-------------|------------|
+            | **w11wo/roberta-sentiment** ✅ | ⚡⚡⚡ | ⭐⭐⭐⭐ | ✅ | ✅ |
+            | indobert-base-p1 | ⚡⚡ | ⭐⭐⭐⭐ | ⚠️ | ❌ (perlu fine-tune) |
+            | indobart-v2 | ⚡ | ⭐⭐⭐ | ✅ | ❌ (untuk summarization) |
+            | mdhugol/indobert | ⚡⚡ | ⭐⭐⭐⭐⭐ | ✅ | ✅ |
+            
+            ### Tech Stack
+            - 🤗 Transformers (Hugging Face)
+            - 🎨 Gradio (Interface)
+            - 📊 Scikit-learn (Evaluation)
+            - 📈 Matplotlib & Seaborn (Visualization)
+            - 🐳 Docker (Deployment)
+            
+            ### Tips Penggunaan
+            1. Untuk analisis cepat 1-2 teks → gunakan tab "Analisis Teks Tunggal"
+            2. Untuk filtering ribuan pesan → gunakan tab "Analisis Batch"
+            3. Untuk validasi model → gunakan tab "Evaluasi Model"
+            4. Confidence ≥ 80% → sangat yakin, prioritaskan untuk keluhan
+            5. Confidence < 60% → review manual disarankan
+            
+            ---
+            
+            **Dibuat dengan ❤️ untuk membantu admin bencana melayani masyarakat dengan lebih efisien**
+            """)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)