Update sentiment_app.py

sentiment_app.py

@@ -1,469 +1,123 @@
 import gradio as gr
 import torch
-from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+from transformers import pipeline
 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
+import collections
 
-# Setup plotting style
-sns.set_style("whitegrid")
-plt.rcParams['figure.figsize'] = (10, 6)
+# --- SETUP MODEL ---
+MODEL_NAME = "w11wo/indonesian-roberta-base-sentiment-classifier"
+device = 0 if torch.cuda.is_available() else -1
+sentiment_pipeline = pipeline("sentiment-analysis", model=MODEL_NAME, device=device)
 
-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
+all_messages = [] 
 
-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}%)
+def process_submission(text):
+    if not text or text.strip() == "":
+        return "⚠️ Mohon isi komentar Anda terlebih dahulu.", gr.update()
+    
+    # 1. Analisis Sentimen
+    result = sentiment_pipeline(text)[0]
+    label = result['label'].upper()
+    
+    # 2. Simpan ke "Database"
+    new_entry = {
+        "Waktu": datetime.now().strftime("%H:%M:%S"),
+        "Pesan": text.strip(),
+        "Sentimen": label
+    }
+    all_messages.append(new_entry)
+    
+    # 3. Respons untuk User
+    thanks_msg = f"""
+    ### 🙏 Terima kasih atas pesan Anda!
+    Masukan Anda sangat berharga bagi kami di Posko. Pesan Anda telah kami terima dan akan segera diproses oleh tim admin.
     """
     
-    return stats + "\n\n" + df.to_markdown(index=False)
+    return thanks_msg, gr.update(value="") # Clear input box
 
-def run_evaluation():
-    """Run model evaluation with visualization"""
-    eval_results = analyzer.evaluate_model(
-        SAMPLE_DATA['texts'],
-        SAMPLE_DATA['labels']
-    )
+def get_admin_dashboard():
+    if not all_messages:
+        return None, "Belum ada data pesan yang masuk."
     
-    # 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')
+    df = pd.DataFrame(all_messages)
     
-    # 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']
-            })
+    # --- VISUALISASI 1: Grafik Jenis Pesan Terbanyak ---
+    fig, ax = plt.subplots(figsize=(8, 5))
+    color_map = {"POSITIVE": "#4CAF50", "NEGATIVE": "#F44336", "NEUTRAL": "#FFC107"}
+    label_map = {"POSITIVE": "Pujian/Apresiasi", "NEGATIVE": "Keluhan/Kritik", "NEUTRAL": "Pertanyaan/Info"}
     
-    df_metrics = pd.DataFrame(metrics_data)
-    x = np.arange(len(df_metrics))
-    width = 0.25
+    counts = df['Sentimen'].value_counts()
+    counts.index = [label_map.get(i, i) for i in counts.index]
     
-    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)
+    sns.barplot(x=counts.index, y=counts.values, palette=[color_map.get(i.split('/')[0].upper(), "#999999") for i in counts.index], ax=ax)
+    ax.set_title("Distribusi Jenis Pesan di Posko", fontsize=14, fontweight='bold')
+    ax.set_ylabel("Jumlah Pesan")
     
-    # 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)
+    # --- TABEL 2: Top 10 Pesan Terbanyak (Informasi Serupa) ---
+    # Kita mengelompokkan pesan yang mirip atau identik
+    counter = collections.Counter([m['Pesan'].lower() for m in all_messages])
+    top_10 = counter.most_common(10)
     
-    # 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]
+    df_top = pd.DataFrame(top_10, columns=["Isi Pesan", "Jumlah Orang"])
     
-    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
+    return fig, df_top
 
-# Create Gradio Interface
-with gr.Blocks(title="Analisis Sentimen Keluhan Masyarakat", theme=gr.themes.Soft()) as demo:
+# --- INTERFACE GRADIO ---
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="emerald"), title="PoskoLog - Sistem Aspirasi Pengungsi") 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
-    
-    ---
+    # 📦 PoskoLog: Suara Pengungsi
+    Selamat datang di layanan aspirasi digital posko. Silakan sampaikan keluhan, kebutuhan, atau pertanyaan Anda.
     """)
     
     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"):
+        # --- TAB USER: FORM KOMENTAR ---
+        with gr.Tab("📝 Sampaikan Pesan"):
+            with gr.Column(variant="panel"):
+                gr.Markdown("### Formulir Aspirasi Pengungsi")
+                user_input = gr.Textbox(
+                    label="Komentar / Masukan Anda", 
+                    placeholder="Tuliskan kebutuhan atau keluhan Anda di sini (Contoh: Air bersih habis di tenda C)...",
+                    lines=4
+                )
+                submit_btn = gr.Button("Kirim Pesan", variant="primary")
+                
+                # Output area untuk ucapan terima kasih
+                user_feedback = gr.Markdown("")
+                
             gr.Markdown("""
-            ### Evaluasi Performa Model
-            
-            Menggunakan dataset sample untuk mengevaluasi performa model dengan berbagai metrik.
+            ---
+            *Catatan: Pesan Anda akan dianalisis secara otomatis untuk memprioritaskan bantuan yang paling mendesak.*
             """)
-            eval_btn = gr.Button("🚀 Jalankan Evaluasi", variant="primary", size="lg")
+
+        # --- TAB ADMIN: DASHBOARD MONITORING ---
+        with gr.Tab("📊 Dashboard Admin (Real-time)"):
+            gr.Markdown("### Ringkasan Informasi Posko")
+            refresh_btn = gr.Button("🔄 Perbarui Data Dashboard", variant="secondary")
             
             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**
-            """)
+                with gr.Column():
+                    plot_output = gr.Plot(label="Grafik Sentimen")
+                with gr.Column():
+                    gr.Markdown("#### 📈 Top 10 Masukan Terbanyak")
+                    table_output = gr.Dataframe(
+                        headers=["Isi Pesan", "Jumlah Orang"],
+                        interactive=False
+                    )
+
+    # Logic Interaksi
+    submit_btn.click(
+        fn=process_submission,
+        inputs=user_input,
+        outputs=[user_feedback, user_input]
+    )
+    
+    refresh_btn.click(
+        fn=get_admin_dashboard,
+        outputs=[plot_output, table_output]
+    )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    demo.launch(server_name="0.0.0.0", server_port=7860)