Upload 5 files

README.md

@@ -1,19 +1,49 @@
 ---
-title: Pln
-emoji: 🚀
-colorFrom: red
+title: MineVision AI - Advanced Fatigue Analytics
+emoji: ⛏️
+colorFrom: blue
 colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+sdk: streamlit
+sdk_version: 1.38.0  # Ganti dengan versi streamlit yang digunakan
+app_file: app.py
 pinned: false
-short_description: Streamlit template space
+license: apache-2.0
 ---
 
-# Welcome to Streamlit!
+# MineVision AI - Advanced Fatigue Analytics
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Deskripsi
+Aplikasi ini adalah dashboard analitik kelelahan berbasis web yang dirancang untuk operasi pertambangan. Menggunakan data dari sistem deteksi kelelahan (seperti Wenco DSS), aplikasi ini menyediakan wawasan dan analisis real-time untuk membantu mengidentifikasi, menilai, dan mengelola risiko kelelahan operator. Tujuannya adalah untuk meningkatkan keselamatan kerja dan produktivitas dengan mengurangi kecelakaan yang terkait dengan kelelahan.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## Fitur Utama
+*   **Dashboard Eksekutif**: Menampilkan metrik keselamatan utama seperti total alert, jumlah operator dan aset, serta durasi rata-rata kejadian.
+*   **Analisis Tren**: Visualisasi tren kelelahan berdasarkan jam, shift, hari dalam seminggu, dan minggu.
+*   **Analisis Lanjutan**: Analisis berdasarkan jenis armada, kecepatan vs jam, durasi vs jam, distribusi kecepatan, dan distribusi operator per shift.
+*   **Kategorisasi Risiko Kelelahan**: Menganalisis kejadian berdasarkan matriks risiko kelelahan (Kritis, Tinggi, Sedang, Rendah) berdasarkan kecepatan dan waktu.
+*   **Wawasan Berbasis AI**: Ringkasan otomatis dan wawasan berdasarkan data yang dianalisis.
+*   **Asisten AI Interaktif**: Chatbot sederhana untuk menanyakan informasi tentang data kelelahan (operator terbanyak, shift terbanyak, dll.).
+
+## Teknologi yang Digunakan
+*   **Streamlit**: Framework untuk membuat aplikasi web interaktif dalam Python.
+*   **Pandas**: Manipulasi dan analisis data.
+*   **Plotly/Plotly Express**: Visualisasi data interaktif.
+*   **Openpyxl**: Pembacaan file Excel.
+
+## Cara Menggunakan
+1.  Akses aplikasi melalui URL Hugging Face Spaces.
+2.  Gunakan filter di sidebar untuk menyaring data berdasarkan Tahun, Bulan, Minggu, Rentang Tanggal, Operator, Shift, dan Rentang Jam.
+3.  Jelajahi berbagai bagian dashboard untuk memahami pola kelelahan.
+4.  Gunakan kotak chat "MineVision AI Assistant" di bagian atas untuk menanyakan pertanyaan spesifik tentang data.
+
+## Struktur Proyek
+*   `app.py`: File utama yang berisi kode aplikasi Streamlit.
+*   `requirements.txt`: File yang berisi daftar dependensi Python yang diperlukan untuk menjalankan aplikasi.
+*   `manual fatique.xlsx`: File data input contoh (jika disertakan dalam repositori).
+
+## Catatan
+*   Aplikasi ini dirancang untuk menganalisis data kelelahan operator dari file Excel. Pastikan struktur data masukan sesuai atau sesuaikan kode untuk membaca data dari sumber lain.
+*   Wawasan dan rekomendasi didasarkan pada analisis data historis dan prinsip-prinsip manajemen risiko kelelahan (FRMS).
+*   Asisten AI saat ini menyediakan jawaban berbasis aturan sederhana berdasarkan data yang tersedia dan informasi umum tentang FRMS. Ini bukan model AI canggih seperti GPT.
+
+## Lisensi
+Apache 2.0

app.py

@@ -0,0 +1,1247 @@
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import numpy as np
+from datetime import datetime, timedelta
+from typing import List
+import os
+
+# =================== PAGE CONFIG ===================
+st.set_page_config(
+    page_title="PLN Audit Insight & Intelligence Dashboard",
+    page_icon="",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# =================== CUSTOM CSS (Updated for PLN Colors) ===================
+st.markdown("""<style>
+    .main-header {
+        background-color: white;
+        padding: 25px;
+        border-radius: 12px;
+        margin-bottom: 25px;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.06);
+        border: 1px solid #e0e0e0;
+    }
+    h1, h2, h3, h4, h5, .stMarkdown h1, .stMarkdown h2, .stMarkdown h3 {
+        text-align: center;
+        font-weight: 700;
+        color: #003DA5; /* Dark Blue - PLN Color */
+    }
+    .metric-card {
+        background: white;
+        padding: 16px;
+        border-radius: 10px;
+        box-shadow: 0 3px 10px rgba(0,0,0,0.05);
+        text-align: center;
+        border: 1px solid #f0f0f0;
+    }
+    .ai-insight {
+        background: #f0f4ff; /* Light Blue */
+        padding: 14px 18px;
+        border-left: 4px solid #003DA5; /* PLN Blue */
+        margin: 10px 0;
+        border-radius: 0 6px 6px 0;
+        font-size: 0.95em;
+    }
+    .ai-recommendation {
+        background: #e8f5e9;
+        padding: 14px 18px;
+        border-left: 4px solid #4caf50;
+        margin: 10px 0;
+        border-radius: 0 6px 6px 0;
+        font-size: 0.95em;
+    }
+    .risk-very-high { color: #c62828; font-weight: bold; }
+    .risk-high { color: #d32f2f; }
+    .risk-moderate { color: #f57c00; }
+    .risk-slight { color: #388e3c; }
+    .trend-worsening { color: #d32f2f; }
+    .trend-improvement { color: #388e3c; }
+    .trend-stable { color: #616161; }
+    .chart-container {
+        border: 1px solid #e0e0e0;
+        border-radius: 8px;
+        padding: 15px;
+        margin: 10px 0;
+        background-color: white;
+        box-shadow: 0 2px 6px rgba(0,0,0,0.03);
+    }
+    .section-title {
+        color: #003DA5; /* PLN Blue */
+        font-weight: 700;
+        font-size: 1.5em;
+        text-align: left;
+        margin-top: 20px;
+        margin-bottom: 10px;
+    }
+    .ai-section {
+        background: #ffffff;
+        padding: 20px;
+        border-radius: 8px;
+        margin: 10px 0;
+        box-shadow: 0 2px 6px rgba(0,0,0,0.03);
+    }
+    /* PLN Styled Selectbox and Multiselect */
+    .stSelectbox > label, .stMultiselect > label {
+        color: #003DA5; /* PLN Blue */
+        font-weight: bold;
+    }
+    .stSelectbox > div > div, .stMultiselect > div > div {
+        border: 2px solid #003DA5; /* PLN Blue Border */
+        border-radius: 8px;
+    }
+    .st-bq {
+        background-color: #f0f4ff; /* Light Blue Background */
+    }
+    .stButton > button {
+        background-color: #003DA5; /* PLN Blue Button */
+        color: white;
+        border: none;
+        border-radius: 8px;
+        padding: 8px 16px;
+        font-weight: bold;
+    }
+    .stButton > button:hover {
+        background-color: #0050A0; /* Darker PLN Blue on Hover */
+    }
+    /* Filter Container Styling */
+    .filter-container {
+        background-color: #f9f9f9;
+        border-radius: 10px;
+        padding: 15px;
+        margin-bottom: 15px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+    }
+    .filter-title {
+        color: #003DA5;
+        font-weight: bold;
+        font-size: 1.1em;
+        margin-bottom: 10px;
+        text-align: center;
+    }
+</style>""", unsafe_allow_html=True)
+
+# =================== DATA LOADING (FROM data.xlsx) ===================
+@st.cache_data(ttl=300)  # refresh every 5 min
+def load_data():
+    file_path = "data.xlsx"
+    if not os.path.exists(file_path):
+        st.error(f"❌ File **`{file_path}`** not found. Please ensure it's in the same directory as this script.")
+        return pd.DataFrame()
+    try:
+        # Load Excel file
+        df = pd.read_excel(file_path, sheet_name='Sheet1', engine='openpyxl')
+        # Check for required columns
+        required_cols = ['created_at']
+        missing = [c for c in required_cols if c not in df.columns]
+        if missing:
+            st.error(f"❌ Missing required columns: {missing}. Available: {list(df.columns)}")
+            return pd.DataFrame()
+        # Parse datetime
+        df['created_at'] = pd.to_datetime(df['created_at'], errors='coerce')
+        if df['created_at'].isna().all():
+            st.error("❌ `created_at` column could not be parsed as datetime.")
+            return pd.DataFrame()
+        # Optional: close_at
+        if 'close_at' in df.columns:
+            df['close_at'] = pd.to_datetime(df['close_at'], errors='coerce')
+            df['days_to_close'] = (df['close_at'] - df['created_at']).dt.total_seconds() / (24 * 3600)
+            df['days_to_close'] = df['days_to_close'].apply(lambda x: x if x >= 0 else np.nan)
+        else:
+            df['days_to_close'] = np.nan
+        # Derived columns
+        df['created_month'] = df['created_at'].dt.to_period('M')
+        df['created_date'] = df['created_at'].dt.date
+        df['created_week'] = df['created_at'].dt.to_period('W')
+        # Keep only valid rows
+        df = df.dropna(subset=['created_at']).copy()
+        # Log shape
+        st.sidebar.success(f"Loaded {len(df):,} Audit Findings from `data.xlsx`")
+        return df
+    except Exception as e:
+        st.exception(f"Error loading data.xlsx: {e}")
+        return pd.DataFrame()
+
+df = load_data()
+if df.empty:
+    st.stop()
+
+# =================== SIDEBAR FILTERS (Perbaikan) ===================
+st.sidebar.markdown('<div class="filter-container">', unsafe_allow_html=True)
+st.sidebar.markdown('<h4 class="filter-title">Filter Dashboard</h4>', unsafe_allow_html=True)
+
+# Inisialisasi df_filtered
+df_filtered = df.copy()
+
+# Flag to track if filters were applied
+filters_applied = False
+
+# 1. Date Range Filter
+min_date = df['created_at'].min().date()
+max_date = df['created_at'].max().date()
+date_range = st.sidebar.date_input(
+    "Date Range",
+    value=(min_date, max_date),
+    min_value=min_date,
+    max_value=max_date
+)
+
+# 2. Filter by Vendor (nama_perusahaan) - Default to All
+if 'nama_perusahaan' in df.columns:
+    unique_vendors = sorted(df['nama_perusahaan'].dropna().astype(str).unique())
+    all_vendors_option = "All Vendors"
+    vendor_options = [all_vendors_option] + list(unique_vendors)
+    selected_vendor = st.sidebar.selectbox("Vendor", vendor_options, index=0) # Default to "All"
+    if selected_vendor != all_vendors_option:
+        df_filtered = df_filtered[df_filtered['nama_perusahaan'].astype(str) == selected_vendor]
+        filters_applied = True
+
+# 3. Filter by Area/Unit Type (temuan_nama_distrik or creator_nama_distrik) - Renamed
+area_col = None
+if 'temuan_nama_distrik' in df_filtered.columns:
+    area_col = 'temuan_nama_distrik'
+elif 'creator_nama_distrik' in df_filtered.columns:
+    area_col = 'creator_nama_distrik'
+
+if area_col:
+    # Define mapping for display names
+    area_mapping = {
+        'UMRO': 'Unit Maintenance',
+        'UP GRESIK': 'Unit Pembangkit'
+    }
+    unique_areas_raw = sorted(df_filtered[area_col].dropna().astype(str).unique())
+    # Map raw values to display names, keep unmapped values as is
+    unique_areas_display = [area_mapping.get(area, area) for area in unique_areas_raw]
+    # Prepend "All" option
+    all_areas_option = "All Units"
+    area_options = [all_areas_option] + unique_areas_display
+    selected_area_display = st.sidebar.selectbox("Unit Type", area_options, index=0) # Default to "All"
+    if selected_area_display != all_areas_option:
+        # Reverse map the selected display name back to the raw value for filtering
+        selected_area_raw = next((raw for raw, disp in area_mapping.items() if disp == selected_area_display), selected_area_display)
+        df_filtered = df_filtered[df_filtered[area_col].astype(str) == selected_area_raw]
+        filters_applied = True
+
+# 4. Status filter - Changed to selectbox (dropdown)
+status_filter_applied = False
+if 'temuan_status' in df_filtered.columns:
+    all_status = sorted(df_filtered['temuan_status'].dropna().astype(str).unique())
+    # Prepend "All" option
+    all_status_option = "All Status"
+    status_options = [all_status_option] + list(all_status)
+    selected_status = st.sidebar.selectbox(
+        "Status",
+        status_options,
+        index=0 # Default to "All"
+    )
+    if selected_status != all_status_option:
+        df_filtered = df_filtered[df_filtered['temuan_status'].astype(str) == selected_status]
+        status_filter_applied = True
+        filters_applied = True
+
+# Apply date filter *after* other filters
+if len(date_range) == 2:
+    df_filtered = df_filtered[
+        (df_filtered['created_at'].dt.date >= date_range[0]) &
+        (df_filtered['created_at'].dt.date <= date_range[1])
+    ]
+    if date_range[0] != min_date or date_range[1] != max_date:
+        filters_applied = True
+
+# Submit Button
+submit_clicked = st.sidebar.button("Apply Filters")
+
+# Apply filters logic when button is clicked
+if submit_clicked:
+    # The filtering based on selections already happened above
+    # Here we just update the summary based on the current state of df_filtered
+    active_filters = []
+    if 'selected_vendor' in locals() and selected_vendor != all_vendors_option:
+        active_filters.append(f"Vendor: {selected_vendor}")
+    if 'selected_area_display' in locals() and selected_area_display != all_areas_option:
+        active_filters.append(f"Unit: {selected_area_display}")
+    if 'selected_status' in locals() and selected_status != all_status_option:
+        active_filters.append(f"Status: {selected_status}")
+    if len(date_range) == 2 and (date_range[0] != min_date or date_range[1] != max_date):
+         active_filters.append(f"Date: {date_range[0]} to {date_range[1]}")
+
+    if active_filters:
+        st.sidebar.success("**Active Filters:**")
+        for f in active_filters:
+            st.sidebar.markdown(f"- {f}")
+        st.sidebar.info(f"Showing {len(df_filtered)} records based on filters.")
+    else:
+        st.sidebar.info("No specific filters applied (showing all records).")
+else:
+    # Show default message when not submitted yet
+    st.sidebar.info("Set filters and click 'Apply Filters'.")
+
+st.sidebar.markdown('</div>', unsafe_allow_html=True)
+
+
+# =================== HEADER ===================
+st.markdown("""
+<div class="main-header">
+    <h1>PLN Audit Insight & Intelligence Dashboard</h1>
+    <p style="text-align:center; color:#546e7a; font-size:1.1em; margin-top:8px;">
+        Operational Risk Intelligence for Audit & Compliance
+    </p>
+</div>
+""", unsafe_allow_html=True)
+
+
+# =================== 1. Pie Charts: Temuan/Person by Company (PG & UM) - PERBAIKAN ===================
+st.markdown("<h3 class='section-title'>OBJECTIVE 1 - Company Reporting Activity: Who Reports the Most?</h3>", unsafe_allow_html=True)
+
+# Asumsikan df_filtered adalah data utama yang telah difilter
+df_local = df_filtered.copy()
+
+# Tambah kolom bulan
+df_local['created_month'] = df_local['created_at'].dt.to_period('M')
+
+# --- Langsung buat Area_Type PG / UM tanpa filter ---
+
+if 'temuan_kode_distrik' in df_local.columns:
+
+    df_local['Area_Type'] = df_local['temuan_kode_distrik'].apply(
+        lambda x: 'PG' if 'PG' in str(x).upper()
+        else 'UM' if 'UM' in str(x).upper()
+        else 'Other'
+    )
+
+    # Otomatis bagi dataset
+    df_pg = df_local[df_local['Area_Type'] == 'PG'].copy()
+    df_um = df_local[df_local['Area_Type'] == 'UM'].copy()
+
+else:
+    df_pg = pd.DataFrame()
+    df_um = pd.DataFrame()
+
+    # --- Fungsi untuk menghitung rasio perusahaan ---
+    def calculate_avg_ratio_per_company(df_area):
+        if df_area.empty:
+            # Jika area tidak dipilih atau data kosong setelah filter
+            return pd.DataFrame()
+        # Hitung temuan per bulan per perusahaan
+        findings_by_company_month = df_area.groupby(['created_month', 'nama_perusahaan']).size().reset_index(name='findings_count')
+        # Hitung jumlah orang unik per bulan per perusahaan
+        creators_by_company_month = df_area.groupby(['created_month', 'nama_perusahaan'])['creator_nid'].nunique().reset_index(name='unique_creators')
+        # Gabung
+        merged = findings_by_company_month.merge(creators_by_company_month, on=['created_month', 'nama_perusahaan'], how='outer')
+        # Isi NaN dengan 0 untuk kolom yang mungkin hilang dari merge
+        merged = merged.fillna({'findings_count': 0, 'unique_creators': 0})
+        # Filter untuk menghindari pembagian dengan nol
+        # Kita hanya ingin menghitung rasio jika jumlah pelapor > 0
+        merged = merged[merged['unique_creators'] > 0]
+        # Hitung rasio (ignore NaN)
+        # Pembagian oleh 0 akan menghasilkan inf, jadi kita ganti inf dengan NaN
+        merged['ratio'] = merged['findings_count'] / merged['unique_creators']
+        merged['ratio'] = merged['ratio'].replace([np.inf, -np.inf], np.nan)
+
+        # Jika tidak ada baris valid setelah filter, kembalikan DataFrame kosong
+        if merged.empty:
+            return pd.DataFrame()
+
+        # Rata-rata bulanan per perusahaan
+        # Group by nama_perusahaan dan ambil mean dari rasio
+        # mean() akan mengabaikan NaN secara default
+        avg_ratio = merged.groupby('nama_perusahaan')['ratio'].mean().reset_index(name='avg_monthly_ratio')
+
+        # Jika hasil akhirnya hanya NaN (karena semua rasio perusahaan adalah NaN), kembalikan DataFrame kosong
+        if avg_ratio['avg_monthly_ratio'].isna().all():
+            return pd.DataFrame()
+
+        return avg_ratio
+
+    # Hitung untuk masing-masing area
+    avg_ratio_pg = calculate_avg_ratio_per_company(df_pg)
+    avg_ratio_um = calculate_avg_ratio_per_company(df_um)
+
+    # Fungsi untuk menentukan warna
+    def get_color_map(company_series):
+        pln_color = "#FFD700"  # Kuning untuk PLN
+        # Daftar warna biru (dari gelap ke terang)
+        blue_colors = ["#1E90FF", "#87CEEB", "#B0E0E6", "#ADD8E6", "#E0F6FF"] 
+        color_map = {}
+        for company in company_series:
+            if 'PLN' in str(company).upper():
+                color_map[company] = pln_color
+            else:
+                # Pilih warna biru berdasarkan indeks, ulangi jika perlu
+                idx = len([c for c in color_map.values() if c != pln_color]) % len(blue_colors)
+                color_map[company] = blue_colors[idx]
+        return color_map
+
+    # Plot
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("<h5>Avg Monthly Finding by Company</h5>", unsafe_allow_html=True)
+        if not avg_ratio_pg.empty:
+            color_discrete_map_pg = get_color_map(avg_ratio_pg['nama_perusahaan'])
+            fig_pg = px.pie(
+                avg_ratio_pg, 
+                values='avg_monthly_ratio', 
+                names='nama_perusahaan', 
+                title='Unit Pembangkit Company',
+                color='nama_perusahaan',
+                color_discrete_map=color_discrete_map_pg
+            )
+            st.plotly_chart(fig_pg, use_container_width=True)
+            
+            # AI Insight untuk PG
+            if not avg_ratio_pg.empty:
+                # Temukan perusahaan dengan rasio tertinggi dan terendah di PG
+                top_company_pg = avg_ratio_pg.loc[avg_ratio_pg['avg_monthly_ratio'].idxmax()]
+                low_company_pg = avg_ratio_pg.loc[avg_ratio_pg['avg_monthly_ratio'].idxmin()]
+                
+                st.markdown("### Insight")
+                insight_text = (
+                    f"<div class='ai-insight'>"
+                    f"In PG Area, <strong>{top_company_pg['nama_perusahaan']}</strong> has the highest average finding-to-person ratio "
+                    f"(<strong>{top_company_pg['avg_monthly_ratio']:.2f}</strong>), indicating potentially high exposure or active reporting. "
+                    f"Consider reviewing their operational procedures. "
+                    f"Conversely, <strong>{low_company_pg['nama_perusahaan']}</strong> has the lowest ratio "
+                    f"(<strong>{low_company_pg['avg_monthly_ratio']:.2f}</strong>), suggesting effective risk management or lower activity levels."
+                    f"</div>"
+                )
+                st.markdown(insight_text, unsafe_allow_html=True)
+        else:
+            st.warning("No data for PG area or all ratios are NaN.")
+
+    with col2:
+        st.markdown("<h5>Avg Monthly Finding by Company</h5>", unsafe_allow_html=True)
+        if not avg_ratio_um.empty:
+            color_discrete_map_um = get_color_map(avg_ratio_um['nama_perusahaan'])
+            fig_um = px.pie(
+                avg_ratio_um, 
+                values='avg_monthly_ratio', 
+                names='nama_perusahaan', 
+                title='Unit Maintenance',
+                color='nama_perusahaan',
+                color_discrete_map=color_discrete_map_um
+            )
+            st.plotly_chart(fig_um, use_container_width=True)
+            
+            # AI Insight untuk UM
+            if not avg_ratio_um.empty:
+                # Temukan perusahaan dengan rasio tertinggi dan terendah di UM
+                top_company_um = avg_ratio_um.loc[avg_ratio_um['avg_monthly_ratio'].idxmax()]
+                low_company_um = avg_ratio_um.loc[avg_ratio_um['avg_monthly_ratio'].idxmin()]
+                
+                st.markdown("### Insight")
+                insight_text = (
+                    f"<div class='ai-insight'>"
+                    f"In UM Area, <strong>{top_company_um['nama_perusahaan']}</strong> exhibits the highest average finding-to-person ratio "
+                    f"(<strong>{top_company_um['avg_monthly_ratio']:.2f}</strong>), warranting a focused safety audit. "
+                    f"<strong>{low_company_um['nama_perusahaan']}</strong> shows the lowest ratio "
+                    f"(<strong>{low_company_um['avg_monthly_ratio']:.2f}</strong>), which could reflect strong safety practices or requires verification of reporting completeness."
+                    f"</div>"
+                )
+                st.markdown(insight_text, unsafe_allow_html=True)
+        else:
+            st.warning("No data for UM area or all ratios are NaN.")
+
+
+# =================== 2. Treemap: Distribusi Temuan per Area (nama_lokasi_full) - PERBAIKAN ===================
+st.markdown("<h3 class='section-title'>OBJECTIVE 2 - Active vs Inactive Locations: Who Leads?</h3>", unsafe_allow_html=True)
+
+# Hitung temuan per bulan per lokasi
+findings_by_location_month = df_local.groupby(['created_month', 'nama_lokasi_full']).size().reset_index(name='findings_count')
+# Hitung jumlah orang unik per bulan per lokasi
+creators_by_location_month = df_local.groupby(['created_month', 'nama_lokasi_full'])['creator_nid'].nunique().reset_index(name='unique_creators')
+# Gabung
+merged_loc = findings_by_location_month.merge(creators_by_location_month, on=['created_month', 'nama_lokasi_full'], how='outer')
+# Isi NaN dengan 0 untuk kolom yang mungkin hilang dari merge
+merged_loc = merged_loc.fillna({'findings_count': 0, 'unique_creators': 0})
+# Filter untuk menghindari pembagian dengan nol
+merged_loc = merged_loc[merged_loc['unique_creators'] > 0]
+# Hitung rasio (ignore NaN)
+# Pembagian oleh 0 akan menghasilkan inf, jadi kita ganti inf dengan NaN
+merged_loc['ratio'] = merged_loc['findings_count'] / merged_loc['unique_creators']
+merged_loc['ratio'] = merged_loc['ratio'].replace([np.inf, -np.inf], np.nan)
+
+# Rata-rata bulanan per lokasi
+# Group by nama_lokasi_full dan ambil mean dari rasio
+# mean() akan mengabaikan NaN secara default
+avg_ratio_per_location = merged_loc.groupby('nama_lokasi_full')['ratio'].mean().reset_index(name='avg_monthly_ratio')
+
+# Filter hasil akhir untuk menghindari NaN
+avg_ratio_per_location = avg_ratio_per_location.dropna(subset=['avg_monthly_ratio'])
+
+# Plot Treemap
+if not avg_ratio_per_location.empty:
+    # Tambahkan kolom untuk warna berdasarkan kriteria
+    def categorize_risk(r):
+        if r > 1.3:
+            return 'High Activity (> 1.3)' # Warna Hijau
+        elif r > 1.0:
+            return 'Medium Activity (1.0 - 1.3)' # Warna Kuning
+        else:
+            return 'Low Activity (<= 1.0)' # Warna Merah
+
+    avg_ratio_per_location['Activity_Category'] = avg_ratio_per_location['avg_monthly_ratio'].apply(categorize_risk)
+
+    # Peta warna
+    color_map = {
+        'High Activity (> 1.3)': '#4CAF50',      # Hijau
+        'Medium Activity (1.0 - 1.3)': '#FFB300', # Kuning
+        'Low Activity (<= 1.0)': '#D32F2F'      # Merah
+    }
+
+    # Gunakan treemap plot dengan ukuran mencerminkan rata-rata rasio dan warna berdasarkan kategori aktivitas
+    fig_treemap = px.treemap(
+        avg_ratio_per_location,
+        path=['nama_lokasi_full'],  # Path untuk hierarki (hanya satu level di sini)
+        values='avg_monthly_ratio', # Nilai yang menentukan ukuran area
+        title='Avg Monthly Finding by Location',
+        labels={'avg_monthly_ratio': 'Avg Monthly Finding/Person Ratio', 'nama_lokasi_full': 'Location'},
+        color='Activity_Category', # Warna berdasarkan kategori aktivitas
+        color_discrete_map=color_map
+    )
+    # Format hover
+    fig_treemap.update_traces(
+        hovertemplate="<b>%{label}</b><br>Avg Ratio: %{value:.2f}<br>Activity Level: %{color}<extra></extra>"
+    )
+    fig_treemap.update_layout(height=600)
+    st.plotly_chart(fig_treemap, use_container_width=True)
+
+    # AI Insight untuk Treemap Lokasi (Business-focused)
+    if not avg_ratio_per_location.empty:
+        # Temukan lokasi dengan rasio tertinggi dan terendah
+        top_location = avg_ratio_per_location.loc[avg_ratio_per_location['avg_monthly_ratio'].idxmax()]
+        low_location = avg_ratio_per_location.loc[avg_ratio_per_location['avg_monthly_ratio'].idxmin()]
+
+        st.markdown("### Insight")
+        insight_text = (
+            f"<div class='ai-insight'>"
+            f"The treemap visualizes the average finding-to-person ratio per location, indicating reporting activity levels. "
+            f"Locations with <span style='color:#4CAF50; font-weight:bold;'>green</span> color have a high ratio reporting"
+            f"Those with <span style='color:#FFB300; font-weight:bold;'>yellow</span> color have a medium ratio, indicating area with moderate reporting. "
+            f"Locations with <span style='color:#D32F2F; font-weight:bold;'>red</span> color have a low ratio  indicate lower activity levels or potentially under-reporting. "
+            f"<strong>{top_location['nama_lokasi_full']}</strong> shows the highest activity level "
+            f"(<strong>{top_location['avg_monthly_ratio']:.2f}</strong>, color: {top_location['Activity_Category']}). "
+            f"<strong>{low_location['nama_lokasi_full']}</strong> shows the lowest activity level "
+            f"(<strong>{low_location['avg_monthly_ratio']:.2f}</strong>, color: {low_location['Activity_Category']}). "
+            f"Areas with high activity (green) warrant investigation into the underlying causes of frequent findings. "
+            f"Areas with low activity (red) should be reviewed to ensure reporting completeness and identify any hidden risks."
+            f"</div>"
+        )
+        st.markdown(insight_text, unsafe_allow_html=True)
+else:
+    st.warning("No data available for location ratio calculation or all ratios are NaN.")
+
+import plotly.express as px
+import numpy as np
+
+import plotly.express as px
+import numpy as np
+# =================== 3. Reporter & Executor Analysis (3a, 3b, 3c, 3d) ===================
+st.markdown("<h3 class='section-title'>OBJECTIVE 3 - Frequency & Response Time: Who Reports Well? Who Executes Well?</h3>", unsafe_allow_html=True)
+
+# 3a & 3b: Reporter Frequency & Executor Lead Time by nama (Average Monthly Rate per Division)
+col_3a, col_3b = st.columns(2)
+
+with col_3a:
+    st.markdown("<h5>3a. Average Finding by Division (Reporter)</h5>", unsafe_allow_html=True)
+    if 'nama' in df_local.columns:
+        # Hitung temuan per bulan per nama
+        findings_by_nama_month = df_local.groupby(['created_month', 'nama']).size().reset_index(name='findings_count')
+        # Hitung jumlah orang unik per bulan per nama
+        creators_by_nama_month = df_local.groupby(['created_month', 'nama'])['creator_nid'].nunique().reset_index(name='unique_creators')
+        # Gabung
+        merged_rep = findings_by_nama_month.merge(creators_by_nama_month, on=['created_month', 'nama'], how='outer')
+        # Isi NaN dengan 0 untuk kolom yang mungkin hilang dari merge
+        merged_rep = merged_rep.fillna({'findings_count': 0, 'unique_creators': 0})
+        # Filter untuk menghindari pembagian dengan nol
+        merged_rep = merged_rep[merged_rep['unique_creators'] > 0]
+        # Hitung rasio (ignore NaN)
+        merged_rep['ratio'] = merged_rep['findings_count'] / merged_rep['unique_creators']
+        merged_rep['ratio'] = merged_rep['ratio'].replace([np.inf, -np.inf], np.nan)
+
+        # Rata-rata bulanan per nama
+        avg_ratio_per_nama = merged_rep.groupby('nama')['ratio'].mean().reset_index(name='avg_monthly_ratio')
+
+        # Filter hasil akhir untuk menghindari NaN
+        avg_ratio_per_nama = avg_ratio_per_nama.dropna(subset=['avg_monthly_ratio'])
+        if not avg_ratio_per_nama.empty:
+            # Tambahkan kolom untuk warna KE DATAFRAME
+            # Urutkan untuk menentukan 5 teratas
+            avg_ratio_per_nama_sorted = avg_ratio_per_nama.sort_values('avg_monthly_ratio', ascending=True)
+            top_5_indices = avg_ratio_per_nama_sorted.tail(5).index
+            # Buat warna default, lalu ubah untuk top 5
+            avg_ratio_per_nama_sorted['color'] = '#1f77b4' # Warna default plotly
+            avg_ratio_per_nama_sorted.loc[avg_ratio_per_nama_sorted.index.isin(top_5_indices), 'color'] = '#4CAF50' # Warna hijau untuk top 5
+
+            # Pilihan sorting
+            sort_option_3a = st.selectbox("Sort 3a by:", ["Lowest First", "Highest First"], key='sort_3a')
+            if sort_option_3a == "Highest First":
+                avg_ratio_per_nama_sorted = avg_ratio_per_nama_sorted.sort_values('avg_monthly_ratio', ascending=False)
+            # Jika "Lowest First", sudah diurutkan ascending di atas
+
+            fig_rep_nama = px.bar(
+                avg_ratio_per_nama_sorted,
+                x='avg_monthly_ratio',
+                y='nama',
+                orientation='h',
+                title='Avg Monthly Finding by Division',
+                labels={'avg_monthly_ratio': 'Avg Monthly Finding/Person Ratio', 'nama': 'Division'},
+                color='color', # Gunakan nama kolom yang ditambahkan
+                color_discrete_map={c: c for c in avg_ratio_per_nama_sorted['color'].unique()}, # Peta warna
+                text=avg_ratio_per_nama_sorted['avg_monthly_ratio'].apply(lambda x: f'{x:.2f}') # Format 2 angka desimal
+            )
+            # Hapus legend untuk warna karena tidak informatif
+            fig_rep_nama.update_layout(yaxis={'categoryorder': 'total ascending'}, height=500, showlegend=False)
+            fig_rep_nama.update_traces(textposition='auto') # Posisi teks otomatis
+            st.plotly_chart(fig_rep_nama, use_container_width=True)
+
+            # AI Insight for 3a
+            top_nama = avg_ratio_per_nama_sorted.iloc[-1] if not avg_ratio_per_nama_sorted.empty else None
+            low_nama = avg_ratio_per_nama_sorted.iloc[0] if not avg_ratio_per_nama_sorted.empty else None
+            if top_nama is not None and low_nama is not None:
+                st.markdown("### Insight")
+                insight_text = (
+                    f"<div class='ai-insight'>"
+                    f"The division <strong>{top_nama['nama']}</strong> has the highest average finding-to-person ratio "
+                    f"(<strong>{top_nama['avg_monthly_ratio']:.2f}</strong>), indicating potentially high reporting activity or exposure. "
+                    f"Conversely, <strong>{low_nama['nama']}</strong> has the lowest ratio "
+                    f"(<strong>{low_nama['avg_monthly_ratio']:.2f}</strong>), suggesting lower activity or potentially under-reporting. "
+                    f"Monitor high-ratio divisions for potential systemic issues and verify reporting completeness in low-ratio ones."
+                    f"</div>"
+                )
+                st.markdown(insight_text, unsafe_allow_html=True)
+        else:
+            st.warning("No data or all ratios are NaN for reporter analysis by division.")
+    else:
+        st.warning("Column 'nama' not available for reporter analysis (3a).")
+
+with col_3b:
+    st.markdown("<h5>3b. Average  by Division (Executor)</h5>", unsafe_allow_html=True)
+    if 'nama' in df_local.columns and 'days_to_close' in df_local.columns:
+        # Hitung rata-rata lead time per nama per bulan
+        leadtime_by_nama_month = df_local.groupby(['created_month', 'nama'])['days_to_close'].mean().reset_index(name='avg_leadtime')
+        # Rata-rata bulanan keseluruhan per nama
+        avg_leadtime_nama = leadtime_by_nama_month.groupby('nama')['avg_leadtime'].mean().reset_index(name='avg_monthly_leadtime')
+
+        # Filter hasil akhir untuk menghindari NaN
+        avg_leadtime_nama = avg_leadtime_nama.dropna(subset=['avg_monthly_leadtime'])
+        if not avg_leadtime_nama.empty:
+            # Tambahkan kolom untuk warna KE DATAFRAME
+            # Urutkan untuk menentukan 5 teratas
+            avg_leadtime_nama_sorted = avg_leadtime_nama.sort_values('avg_monthly_leadtime', ascending=True)
+            top_5_indices = avg_leadtime_nama_sorted.tail(5).index
+            # Buat warna default, lalu ubah untuk top 5
+            avg_leadtime_nama_sorted['color'] = '#1f77b4' # Warna default plotly
+            avg_leadtime_nama_sorted.loc[avg_leadtime_nama_sorted.index.isin(top_5_indices), 'color'] = '#D32F2F' # Warna merah untuk top 5
+
+            # Pilihan sorting
+            sort_option_3b = st.selectbox("Sort 3b by:", ["Fastest First", "Slowest First"], key='sort_3b')
+            if sort_option_3b == "Slowest First":
+                avg_leadtime_nama_sorted = avg_leadtime_nama_sorted.sort_values('avg_monthly_leadtime', ascending=False)
+            # Jika "Fastest First", sudah diurutkan ascending di atas
+
+            fig_exec_nama = px.bar(
+                avg_leadtime_nama_sorted,
+                x='avg_monthly_leadtime',
+                y='nama',
+                orientation='h',
+                title='Avg Monthly Lead Time by Division',
+                labels={'avg_monthly_leadtime': 'Avg Lead Time (Days)', 'nama': 'Division'},
+                color='color', # Gunakan nama kolom yang ditambahkan
+                color_discrete_map={c: c for c in avg_leadtime_nama_sorted['color'].unique()}, # Peta warna
+                text=avg_leadtime_nama_sorted['avg_monthly_leadtime'].apply(lambda x: f'{x:.2f}') # Format 2 angka desimal
+            )
+            # Hapus legend untuk warna karena tidak informatif
+            fig_exec_nama.update_layout(yaxis={'categoryorder': 'total ascending'}, height=500, showlegend=False)
+            fig_exec_nama.update_traces(textposition='auto') # Posisi teks otomatis
+            st.plotly_chart(fig_exec_nama, use_container_width=True)
+
+            # AI Insight for 3b
+            top_nama = avg_leadtime_nama_sorted.iloc[-1] if not avg_leadtime_nama_sorted.empty else None
+            low_nama = avg_leadtime_nama_sorted.iloc[0] if not avg_leadtime_nama_sorted.empty else None
+            if top_nama is not None and low_nama is not None:
+                st.markdown("### Insight")
+                insight_text = (
+                    f"<div class='ai-insight'>"
+                    f"The division <strong>{top_nama['nama']}</strong> has the highest average lead time "
+                    f"(<strong>{top_nama['avg_monthly_leadtime']:.2f} days</strong>), indicating slower resolution. "
+                    f"<strong>{low_nama['nama']}</strong> has the fastest average resolution "
+                    f"(<strong>{low_nama['avg_monthly_leadtime']:.2f} days</strong>). "
+                    f"Focus on improving SLA compliance in divisions with longer lead times."
+                    f"</div>"
+                )
+                st.markdown(insight_text, unsafe_allow_html=True)
+        else:
+            st.warning("No data or all lead times are NaN for executor analysis by division.")
+    else:
+        st.warning("Columns 'nama' or 'days_to_close' not available for executor analysis (3b).")
+
+# 3c & 3d: Reporter Frequency & Executor Lead Time by creator_name and nama_pic (Average Monthly Rate per Person)
+col_3c, col_3d = st.columns(2)
+
+with col_3c:
+    st.markdown("<h5>3c. Average Finding Rate per Reporter (Name)</h5>", unsafe_allow_html=True)
+    if 'creator_name' in df_local.columns:
+        # Hitung temuan per bulan per creator_name
+        findings_by_creator_month = df_local.groupby(['created_month', 'creator_name']).size().reset_index(name='findings_count')
+        # Hitung jumlah bulan aktif per creator_name
+        active_months_by_creator = findings_by_creator_month.groupby('creator_name')['created_month'].nunique().reset_index(name='active_months')
+        # Gabung untuk mendapatkan total temuan per creator
+        total_findings_by_creator = findings_by_creator_month.groupby('creator_name')['findings_count'].sum().reset_index()
+        # Gabung semua
+        merged_rep_creator = total_findings_by_creator.merge(active_months_by_creator, on='creator_name', how='outer')
+        # Isi NaN dengan 0
+        merged_rep_creator = merged_rep_creator.fillna({'findings_count': 0, 'active_months': 0})
+        # Filter untuk menghindari pembagian dengan nol (jika seseorang tidak aktif sepanjang periode)
+        merged_rep_creator = merged_rep_creator[merged_rep_creator['active_months'] > 0]
+        # Hitung rata-rata bulanan (ignore NaN)
+        merged_rep_creator['avg_monthly_rate'] = merged_rep_creator['findings_count'] / merged_rep_creator['active_months']
+        merged_rep_creator['avg_monthly_rate'] = merged_rep_creator['avg_monthly_rate'].replace([np.inf, -np.inf], np.nan)
+
+        # Filter hasil akhir untuk menghindari NaN
+        avg_rate_per_creator = merged_rep_creator.dropna(subset=['avg_monthly_rate'])
+        if not avg_rate_per_creator.empty:
+            # Tambahkan kolom untuk warna KE DATAFRAME
+            # Urutkan untuk menentukan 5 teratas
+            avg_rate_per_creator_sorted = avg_rate_per_creator.sort_values('avg_monthly_rate', ascending=True)
+            top_5_indices = avg_rate_per_creator_sorted.tail(5).index
+            # Buat warna default, lalu ubah untuk top 5
+            avg_rate_per_creator_sorted['color'] = '#1f77b4' # Warna default plotly
+            avg_rate_per_creator_sorted.loc[avg_rate_per_creator_sorted.index.isin(top_5_indices), 'color'] = '#4CAF50' # Warna hijau untuk top 5
+
+            # Pilihan sorting
+            sort_option_3c = st.selectbox("Sort 3c by:", ["Lowest First", "Highest First"], key='sort_3c')
+            if sort_option_3c == "Highest First":
+                avg_rate_per_creator_sorted = avg_rate_per_creator_sorted.sort_values('avg_monthly_rate', ascending=False)
+            # Jika "Lowest First", sudah diurutkan ascending di atas
+
+            # Ambil top 10 untuk visualisasi
+            top10_creators = avg_rate_per_creator_sorted.tail(1000) # Ambil 10 terakhir setelah sorting
+            fig_rep_creator = px.bar(
+                top10_creators,
+                x='avg_monthly_rate',
+                y='creator_name',
+                orientation='h',
+                title='Avg Monthly Finding by Creator Name',
+                labels={'avg_monthly_rate': 'Avg Monthly Finding Rate', 'creator_name': 'Creator Name'},
+                color='color', # Gunakan nama kolom yang ditambahkan
+                color_discrete_map={c: c for c in top10_creators['color'].unique()}, # Peta warna
+                text=top10_creators['avg_monthly_rate'].apply(lambda x: f'{x:.2f}') # Format 2 angka desimal
+            )
+            # Hapus legend untuk warna karena tidak informatif
+            fig_rep_creator.update_layout(yaxis={'categoryorder': 'total ascending'}, height=500, showlegend=False)
+            fig_rep_creator.update_traces(textposition='auto') # Posisi teks otomatis
+            st.plotly_chart(fig_rep_creator, use_container_width=True)
+
+            # AI Insight for 3c
+            top_creator = avg_rate_per_creator_sorted.iloc[-1] if not avg_rate_per_creator_sorted.empty else None
+            low_creator = avg_rate_per_creator_sorted.iloc[0] if not avg_rate_per_creator_sorted.empty else None
+            if top_creator is not None and low_creator is not None:
+                st.markdown("### Insight")
+                insight_text = (
+                    f"<div class='ai-insight'>"
+                    f"The reporter <strong>{top_creator['creator_name']}</strong> has the highest average monthly finding rate "
+                    f"(<strong>{top_creator['avg_monthly_rate']:.2f}</strong>), indicating active engagement. "
+                    f"<strong>{low_creator['creator_name']}</strong> has the lowest rate "
+                    f"(<strong>{low_creator['avg_monthly_rate']:.2f}</strong>), which might indicate lower activity or under-reporting. "
+                    f"Recognize high performers and investigate low performers."
+                    f"</div>"
+                )
+                st.markdown(insight_text, unsafe_allow_html=True)
+        else:
+            st.warning("No data or all rates are NaN for reporter analysis by creator_name.")
+    else:
+        st.warning("Column 'creator_name' not available for reporter analysis (3c).")
+
+with col_3d:
+    st.markdown("<h5>3d. Average Lead Time by Executor (Name)</h5>", unsafe_allow_html=True)
+    if 'nama_pic' in df_local.columns and 'days_to_close' in df_local.columns:
+        # Hitung rata-rata lead time per executor per bulan
+        leadtime_by_executor_month = df_local.groupby(['created_month', 'nama_pic'])['days_to_close'].mean().reset_index(name='avg_leadtime')
+        # Hitung jumlah bulan aktif per executor
+        active_months_by_executor = leadtime_by_executor_month.groupby('nama_pic')['created_month'].nunique().reset_index(name='active_months')
+        # Hitung total lead time per executor
+        total_leadtime_by_executor = leadtime_by_executor_month.groupby('nama_pic')['avg_leadtime'].sum().reset_index()
+        # Gabung semua
+        merged_exec_pic = total_leadtime_by_executor.merge(active_months_by_executor, on='nama_pic', how='outer')
+        # Isi NaN dengan 0
+        merged_exec_pic = merged_exec_pic.fillna({'avg_leadtime': 0, 'active_months': 0})
+        # Filter untuk menghindari pembagian dengan nol
+        merged_exec_pic = merged_exec_pic[merged_exec_pic['active_months'] > 0]
+        # Hitung rata-rata bulanan (ignore NaN)
+        merged_exec_pic['avg_monthly_leadtime'] = merged_exec_pic['avg_leadtime'] / merged_exec_pic['active_months']
+        merged_exec_pic['avg_monthly_leadtime'] = merged_exec_pic['avg_monthly_leadtime'].replace([np.inf, -np.inf], np.nan)
+
+        # Filter hasil akhir untuk menghindari NaN
+        avg_leadtime_per_executor = merged_exec_pic.dropna(subset=['avg_monthly_leadtime'])
+        if not avg_leadtime_per_executor.empty:
+            # Tambahkan kolom untuk warna KE DATAFRAME
+            # Urutkan untuk menentukan 5 teratas
+            avg_leadtime_per_executor_sorted = avg_leadtime_per_executor.sort_values('avg_monthly_leadtime', ascending=True)
+            top_5_indices = avg_leadtime_per_executor_sorted.tail(5).index
+            # Buat warna default, lalu ubah untuk top 5
+            avg_leadtime_per_executor_sorted['color'] = '#1f77b4' # Warna default plotly
+            avg_leadtime_per_executor_sorted.loc[avg_leadtime_per_executor_sorted.index.isin(top_5_indices), 'color'] = '#D32F2F' # Warna merah untuk top 5
+
+            # Pilihan sorting
+            sort_option_3d = st.selectbox("Sort 3d by:", ["Fastest First", "Slowest First"], key='sort_3d')
+            if sort_option_3d == "Slowest First":
+                avg_leadtime_per_executor_sorted = avg_leadtime_per_executor_sorted.sort_values('avg_monthly_leadtime', ascending=False)
+            # Jika "Fastest First", sudah diurutkan ascending di atas
+
+            # Ambil top 10 untuk visualisasi
+            top10_executors = avg_leadtime_per_executor_sorted.nlargest(1000, 'avg_monthly_leadtime') # Ambil 10 terlama
+            fig_exec_pic = px.bar(
+                top10_executors,
+                x='avg_monthly_leadtime',
+                y='nama_pic',
+                orientation='h',
+                title='Avg Monthly Lead Time by Executor (Name)',
+                labels={'avg_monthly_leadtime': 'Avg Monthly Lead Time (Days)', 'nama_pic': 'Executor Name'},
+                color='color', # Gunakan nama kolom yang ditambahkan
+                color_discrete_map={c: c for c in top10_executors['color'].unique()}, # Peta warna
+                text=top10_executors['avg_monthly_leadtime'].apply(lambda x: f'{x:.2f}') # Format 2 angka desimal
+            )
+            # Hapus legend untuk warna karena tidak informatif
+            fig_exec_pic.update_layout(yaxis={'categoryorder': 'total ascending'}, height=500, showlegend=False)
+            fig_exec_pic.update_traces(textposition='auto') # Posisi teks otomatis
+            st.plotly_chart(fig_exec_pic, use_container_width=True)
+
+            # AI Insight for 3d
+            top_executor = avg_leadtime_per_executor_sorted.iloc[-1] if not avg_leadtime_per_executor_sorted.empty else None
+            low_executor = avg_leadtime_per_executor_sorted.iloc[0] if not avg_leadtime_per_executor_sorted.empty else None
+            if top_executor is not None and low_executor is not None:
+                st.markdown("### Insight")
+                insight_text = (
+                    f"<div class='ai-insight'>"
+                    f"The executor <strong>{top_executor['nama_pic']}</strong> has the highest average monthly lead time "
+                    f"(<strong>{top_executor['avg_monthly_leadtime']:.2f} days</strong>), indicating slower resolution. "
+                    f"<strong>{low_executor['nama_pic']}</strong> resolves tasks fastest on average "
+                    f"(<strong>{low_executor['avg_monthly_leadtime']:.2f} days</strong>). "
+                    f"Focus on improving SLA compliance for executors with longer lead times."
+                    f"</div>"
+                )
+                st.markdown(insight_text, unsafe_allow_html=True)
+        else:
+            st.warning("No data or all lead times are NaN for executor analysis by nama_pic.")
+    else:
+        st.warning("Columns 'nama_pic' or 'days_to_close' not available for executor analysis (3d).")
+    ####OBJECTIVE 4
+try:
+    from wordcloud import WordCloud
+    import matplotlib.pyplot as plt
+    WORDCLOUD_AVAILABLE = True
+except ImportError:
+    WORDCLOUD_AVAILABLE = False
+    st.warning("⚠️ Library `wordcloud` atau `matplotlib` tidak ditemukan. Install dengan `pip install wordcloud matplotlib` untuk fitur WordCloud.")
+
+if WORDCLOUD_AVAILABLE:
+    st.markdown("<h3 class='section-title'>4. Global Text Insights (Word Clouds)</h3>", unsafe_allow_html=True)
+
+    col_wc1, col_wc2, col_wc3 = st.columns(3)
+
+    # Fungsi untuk membuat dan menampilkan wordcloud
+    def generate_wordcloud(text_data, title, col):
+        # Periksa apakah text_data adalah Series kosong atau None
+        if text_data is None or text_data.empty:
+            col.warning(f"No data available in series for {title}.")
+            return
+        # Periksa apakah semua nilai adalah NaN
+        if text_data.isna().all():
+            col.warning(f"All data is NaN for {title}.")
+            return
+        # Gabung semua teks menjadi satu string
+        text = ' '.join(text_data.dropna().astype(str))
+        # Bersihkan teks dari karakter non-alfanumerik (opsional)
+        import re
+        text = re.sub(r'[^a-zA-Z\s]', ' ', text)
+        if text.strip(): # Pastikan teks tidak kosong setelah pembersihan
+            # Buat WordCloud
+            wordcloud = WordCloud(
+                width=400, 
+                height=300,
+                background_color='white',
+                colormap='viridis',
+                max_words=100,
+                relative_scaling=0.5,
+                random_state=42
+            ).generate(text)
+
+            # Plot menggunakan matplotlib
+            fig, ax = plt.subplots(figsize=(8, 6))
+            ax.imshow(wordcloud, interpolation='bilinear')
+            ax.axis('off')
+            ax.set_title(title, fontsize=16)
+            plt.tight_layout()
+
+            # Tampilkan di Streamlit
+            col.pyplot(fig, use_container_width=True)
+        else:
+            col.warning(f"No valid text data for {title} after cleaning.")
+
+    # Kolom Judul
+    with col_wc1:
+        if 'judul' in df_local.columns:
+            generate_wordcloud(df_local['judul'], "Word Cloud: Judul", col_wc1)
+        else:
+            col_wc1.warning("Column 'judul' not available.")
+
+    # Kolom Kondisi
+    with col_wc2:
+        if 'kondisi' in df_local.columns:
+            generate_wordcloud(df_local['kondisi'], "Word Cloud: Kondisi", col_wc2)
+        else:
+            col_wc2.warning("Column 'kondisi' not available.")
+
+    # Kolom Rekomendasi
+    with col_wc3:
+        if 'rekomendasi' in df_local.columns:
+            generate_wordcloud(df_local['rekomendasi'], "Word Cloud: Rekomendasi", col_wc3)
+        else:
+            col_wc3.warning("Column 'rekomendasi' not available.")
+else:
+    st.markdown("<h3 class='section-title'>4. Global Text Insights (Word Clouds)</h3>", unsafe_allow_html=True)
+    st.info("WordCloud library not installed. Install `wordcloud` and `matplotlib` to enable this feature.")
+
+# =================== 5. Matrix (Tetap Dipertahankan) ===================
+st.markdown("<h3 class='section-title'>OBJECTIVE 5 - Findings vs Lead Time: Which Companies Move Slow?</h3>", unsafe_allow_html=True)
+
+import math
+import plotly.express as px
+import pandas as pd
+try:
+    df_local_matrix = df.copy()
+    # ============================
+    # 0. Filter: ONLY 1 COMPANY & 1 PROFILE (if applicable)
+    # ============================
+    # (Skipped for general dashboard view)
+    # ============================
+    # 1. Exclude Positive findings
+    # ============================
+    if 'temuan_kategori' in df_local_matrix.columns:
+        df_local_matrix = df_local_matrix[df_local_matrix["temuan_kategori"] != "Positive"]
+    # ============================
+    # 2. Ensure datetime columns
+    # ============================
+    df_local_matrix['created_at'] = pd.to_datetime(df_local_matrix['created_at'], errors='coerce')
+    df_local_matrix['close_at'] = pd.to_datetime(df_local_matrix['close_at'], errors='coerce')
+    # ============================
+    # 3. Compute LEAD TIME
+    # ============================
+    df_local_matrix['lead_time_days'] = (df_local_matrix['close_at'] - df_local_matrix['created_at']).dt.days
+    df_local_matrix['lead_time_days'] = df_local_matrix['lead_time_days'].fillna(0)
+    # ============================
+    # 4. Average Monthly Finding Count per Operator
+    # ============================
+    if 'nama' not in df_local_matrix.columns:
+        st.error("❌ Kolom 'nama' (operator) tidak ditemukan.")
+        # st.stop() # Stop bisa dihilangkan agar script tetap jalan
+    else:
+        # Buat kolom bulan (YYYY-MM)
+        df_local_matrix = df_local_matrix.assign(month=df_local_matrix['created_at'].dt.to_period('M').astype(str))
+        # Hitung jumlah temuan per operator per bulan
+        monthly_counts = (
+            df_local_matrix
+            .groupby(['nama', 'month'])['kode_temuan']
+            .nunique()
+            .reset_index(name='monthly_count')
+        )
+        # Hitung rata-rata bulanan per operator
+        operator_avg = (
+            monthly_counts
+            .groupby('nama')['monthly_count']
+            .mean()  # <-- RATA-RATA per bulan (bukan total!)
+            .reset_index(name='Finding Count')
+        )
+        # ============================
+        # 5. Average Lead Time per Operator
+        # ============================
+        operator_lead = (
+            df_local_matrix.groupby('nama')['lead_time_days']
+            .mean()
+            .reset_index(name='Average Lead Time')
+        )
+        # ============================
+        # 6. Merge Risk Matrix
+        # ============================
+        risk_matrix = operator_avg.merge(operator_lead, on='nama', how='left')
+        risk_matrix = risk_matrix.rename(columns={'nama': 'Operator Name'})
+        # Handle operator tanpa lead time (e.g., belum closed)
+        risk_matrix['Average Lead Time'] = risk_matrix['Average Lead Time'].fillna(0)
+        # ============================
+        # 7. Quadrant Logic (unchanged)
+        # ============================
+        X_LIMIT = 20
+        Y_LIMIT = 3
+        def assign_quadrant(row):
+            if row['Finding Count'] >= X_LIMIT and row['Average Lead Time'] >= Y_LIMIT:
+                return "Quadrant I – High Leadtime & High Count"
+            elif row['Finding Count'] < X_LIMIT and row['Average Lead Time'] >= Y_LIMIT:
+                return "Quadrant II – High Leadtime but Low Count"
+            elif row['Finding Count'] >= X_LIMIT and row['Average Lead Time'] < Y_LIMIT:
+                return "Quadrant III – Low Leadtime but High Count"
+            else:
+                return "Quadrant IV – Low Leadtime & Low Count"
+        risk_matrix['quadrant'] = risk_matrix.apply(assign_quadrant, axis=1)
+        quadrant_count = risk_matrix['quadrant'].value_counts()
+        # ============================
+        # 8. Scatter Plot (format visual tetap sam persis)
+        # ============================
+        max_x = risk_matrix['Finding Count'].max() + 1
+        max_y = risk_matrix['Average Lead Time'].max() + 5
+        fig = px.scatter(
+            risk_matrix,
+            x='Finding Count',
+            y='Average Lead Time',
+            hover_name="Operator Name",
+            size=[12] * len(risk_matrix),
+            size_max=15,
+            title="Audit Findings Risk Matrix: Avg Monthly Count vs Lead Time"
+        )
+        # Background quadrant (same as original)
+        fig.add_shape(type="rect", x0=X_LIMIT, x1=max_x, y0=Y_LIMIT, y1=max_y,
+                      fillcolor="rgba(255,0,0,0.25)", line_width=0)      # Q1
+        fig.add_shape(type="rect", x0=0, x1=X_LIMIT, y0=Y_LIMIT, y1=max_y,
+                      fillcolor="rgba(255,150,50,0.25)", line_width=0)  # Q2
+        fig.add_shape(type="rect", x0=X_LIMIT, x1=max_x, y0=0, y1=Y_LIMIT,
+                      fillcolor="rgba(255,200,200,0.25)", line_width=0) # Q3
+        fig.add_shape(type="rect", x0=0, x1=X_LIMIT, y0=0, y1=Y_LIMIT,
+                      fillcolor="rgba(0,120,255,0.15)", line_width=0)   # Q4
+        fig.add_vline(x=X_LIMIT, line_dash="dash", line_color="black")
+        fig.add_hline(y=Y_LIMIT, line_dash="dash", line_color="black")
+        # Quadrant count annotations (same positions & style)
+        fig.add_annotation(x=X_LIMIT + (max_x - X_LIMIT)/2,
+                           y=Y_LIMIT + (max_y - Y_LIMIT)/2,
+                           text=f"<b>{quadrant_count.get('Quadrant I – High Leadtime & High Count',0)}</b>",
+                           showarrow=False, font=dict(size=22, color="darkred"))
+        fig.add_annotation(x=X_LIMIT/2,
+                           y=Y_LIMIT + (max_y - Y_LIMIT)/2,
+                           text=f"<b>{quadrant_count.get('Quadrant II – High Leadtime but Low Count',0)}</b>",
+                           showarrow=False, font=dict(size=22, color="orange"))
+        fig.add_annotation(x=X_LIMIT + (max_x - X_LIMIT)/2,
+                           y=Y_LIMIT/2,
+                           text=f"<b>{quadrant_count.get('Quadrant III – Low Leadtime but High Count',0)}</b>",
+                           showarrow=False, font=dict(size=22, color="red"))
+        fig.add_annotation(x=X_LIMIT/2,
+                           y=Y_LIMIT/2,
+                           text=f"<b>{quadrant_count.get('Quadrant IV – Low Leadtime & Low Count',0)}</b>",
+                           showarrow=False, font=dict(size=22, color="green"))
+        st.plotly_chart(fig, use_container_width=True)
+        # ============================
+        # 9. Summary Table
+        # ============================
+        st.subheader("Summary (Avg Monthly Count vs Avg Lead Time)")
+        st.dataframe(
+            risk_matrix.sort_values("Finding Count", ascending=False),
+            use_container_width=True
+        )
+except Exception as e:
+    st.error(f"⚠️ Error Risk Matrix: {e}")
+    # st.exception(e) # Uncomment for debugging
+
+# =================== 6. ✅ AI INSIGHT ENGINE (BARU - BERDASARKAN DATA & RATIO) ===================
+st.markdown("## 6. Insight & Recommendation")
+
+def compute_ai_insights(df: pd.DataFrame) -> List[dict]:
+    """
+    Generates insights and recommendations based on the current data and average monthly ratios.
+    Returns a list of dictionaries, each containing an 'insight' and a 'recommendation'.
+    """
+    insight_recommendations = []
+
+    if df.empty:
+        return insight_recommendations
+
+    total_findings = len(df)
+    total_locations = df['nama_lokasi_full'].nunique() if 'nama_lokasi_full' in df.columns else 0
+    total_companies = df['nama_perusahaan'].nunique() if 'nama_perusahaan' in df.columns else 0
+    total_divisions = df['nama'].nunique() if 'nama' in df.columns else 0
+
+    # --- 1. Insight & Recommendation: Rata-rata Bulanan Ratio Temuan/Orang Perusahaan ---
+    if 'nama_perusahaan' in df.columns and 'creator_nid' in df.columns:
+        df_with_month = df.copy()
+        df_with_month['created_month'] = df_with_month['created_at'].dt.to_period('M')
+        
+        # Hitung temuan per bulan per perusahaan
+        findings_by_company_month = df_with_month.groupby(['created_month', 'nama_perusahaan']).size().reset_index(name='findings_count')
+        # Hitung jumlah orang unik per bulan per perusahaan
+        creators_by_company_month = df_with_month.groupby(['created_month', 'nama_perusahaan'])['creator_nid'].nunique().reset_index(name='unique_creators')
+        # Gabung
+        merged_ratio = findings_by_company_month.merge(creators_by_company_month, on=['created_month', 'nama_perusahaan'], how='outer')
+        # Filter untuk menghindari pembagian dengan nol
+        merged_ratio = merged_ratio[merged_ratio['unique_creators'] > 0]
+        # Hitung rasio (ignore NaN)
+        merged_ratio['ratio'] = merged_ratio['findings_count'] / merged_ratio['unique_creators']
+        merged_ratio['ratio'] = merged_ratio['ratio'].replace([np.inf, -np.inf], np.nan)
+
+        # Rata-rata bulanan per perusahaan
+        avg_ratio_per_company = merged_ratio.groupby('nama_perusahaan')['ratio'].mean().reset_index(name='avg_monthly_ratio')
+        # Filter hasil akhir untuk menghindari NaN
+        avg_ratio_per_company = avg_ratio_per_company.dropna(subset=['avg_monthly_ratio'])
+
+        if not avg_ratio_per_company.empty:
+            # Temukan perusahaan dengan rasio tertinggi dan terendah
+            top_company_ratio = avg_ratio_per_company.loc[avg_ratio_per_company['avg_monthly_ratio'].idxmax()]
+            low_company_ratio = avg_ratio_per_company.loc[avg_ratio_per_company['avg_monthly_ratio'].idxmin()]
+            
+            insight_text = (
+                f"Based on the average monthly finding-to-person ratio, "
+                f"Company '{top_company_ratio['nama_perusahaan']}' has the highest activity level ({top_company_ratio['avg_monthly_ratio']:.2f} findings/person/month), "
+                f"while '{low_company_ratio['nama_perusahaan']}' has the lowest ({low_company_ratio['avg_monthly_ratio']:.2f} findings/person/month)."
+            )
+            recommendation_text = (
+                f"For '{top_company_ratio['nama_perusahaan']}': Investigate the underlying reasons for the high ratio. Is it due to active reporting, higher risk, or more personnel? "
+                f"For '{low_company_ratio['nama_perusahaan']}': Verify if the low ratio reflects effective risk management or potential under-reporting."
+            )
+            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+
+    # --- 2. Insight & Recommendation: Distribusi Temuan (Umum) ---
+    if 'temuan_kategori' in df.columns:
+        cat_counts = df['temuan_kategori'].value_counts()
+        top_cat = cat_counts.index[0] if not cat_counts.empty else "N/A"
+        top_cat_count = cat_counts.iloc[0] if not cat_counts.empty else 0
+        if top_cat != "N/A":
+            perc = (top_cat_count / total_findings) * 100
+            if top_cat == "Positive":
+                insight_text = (
+                    f"The majority of findings ({top_cat_count} or {perc:.1f}%) are categorized as 'Positive'. "
+                    f"This indicates a strong culture of recognizing and reporting good practices and safety compliance."
+                )
+                recommendation_text = (
+                    f"Maintain and reinforce the positive reporting culture. "
+                    f"Consider using these 'Positive' examples as best practice case studies for training and awareness programs."
+                )
+            else:
+                insight_text = (
+                    f"The most frequent finding category is '{top_cat}' ({top_cat_count} instances, {perc:.1f}% of total). "
+                    f"This highlights a specific area requiring focused attention."
+                )
+                recommendation_text = (
+                    f"Conduct a root-cause analysis for the '{top_cat}' category. "
+                    f"Develop targeted corrective actions and preventive measures to address the underlying issues."
+                )
+            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+
+    # --- 3. Insight & Recommendation: Aktivitas Lokasi (Umum) ---
+    if 'nama_lokasi_full' in df.columns and total_locations > 0:
+        loc_counts = df['nama_lokasi_full'].value_counts()
+        top_loc = loc_counts.index[0] if not loc_counts.empty else "N/A"
+        top_loc_count = loc_counts.iloc[0] if not loc_counts.empty else 0
+        if top_loc != "N/A":
+            insight_text = (
+                f"Location '{top_loc}' has the highest number of findings ({top_loc_count}). "
+                f"This could indicate higher activity, more scrutiny, or potentially higher risk in this area."
+            )
+            recommendation_text = (
+                f"Perform a detailed review of activities in '{top_loc}'. "
+                f"Determine if the high volume is due to increased activity or specific risk factors. "
+                f"Ensure adequate resources and controls are in place."
+            )
+            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+
+    # --- 4. Insight & Recommendation: Kinerja Resolusi (Umum) ---
+    if 'days_to_close' in df.columns:
+        closed_df = df.dropna(subset=['days_to_close'])
+        if not closed_df.empty:
+            avg_close_time = closed_df['days_to_close'].mean()
+            median_close_time = closed_df['days_to_close'].median()
+            # Ambang batas SLA, misal 7 hari
+            sla_threshold = 7
+            slow_findings = closed_df[closed_df['days_to_close'] > sla_threshold]
+            slow_count = len(slow_findings)
+            slow_percentage = (slow_count / len(closed_df)) * 100 if len(closed_df) > 0 else 0
+
+            insight_text = (
+                f"The average time to close findings is {avg_close_time:.1f} days (median: {median_close_time:.1f} days). "
+                f"{slow_count} findings ({slow_percentage:.1f}%) exceeded the {sla_threshold}-day SLA."
+            )
+            if slow_percentage > 20:
+                recommendation_text = (
+                    f"The resolution performance is below target. Investigate bottlenecks in the closure process. "
+                    f"Prioritize findings that are taking longer than {sla_threshold} days. Consider implementing an escalation matrix."
+                )
+            else:
+                recommendation_text = (
+                    f"The resolution performance is generally good, but there's room for improvement. "
+                    f"Focus on reducing the backlog of findings that exceed the {sla_threshold}-day SLA."
+                )
+            insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+
+    # --- 5. Insight & Recommendation: Tren Bulanan (Umum) ---
+    if 'created_at' in df.columns:
+        monthly_trend = df.set_index('created_at').resample('M').size()
+        if len(monthly_trend) >= 2:
+            last_month_count = monthly_trend.iloc[-1]
+            prev_month_count = monthly_trend.iloc[-2]
+            if prev_month_count > 0:
+                change_pct = (last_month_count - prev_month_count) / prev_month_count * 100
+                trend_word = "increase" if change_pct > 0 else "decrease"
+                insight_text = (
+                    f"There was a {change_pct:+.1f}% {trend_word} in finding volume between the last two months "
+                    f"({monthly_trend.index[-2].strftime('%b %Y')} and {monthly_trend.index[-1].strftime('%b %Y')})."
+                )
+                if abs(change_pct) > 20: # Jika perubahan besar
+                    recommendation_text = (
+                        f"Investigate the cause of this significant {trend_word} in findings. "
+                        f"Review operational changes, contractor activities, or audit focus shifts that occurred recently."
+                    )
+                else:
+                    recommendation_text = (
+                        f"Monitor the trend over the next few weeks to see if this change represents a new pattern or a temporary fluctuation."
+                    )
+                insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+
+    # --- 6. Insight & Recommendation: Aktivitas Pelapor (Umum) ---
+    if 'creator_nid' in df.columns:
+        active_reporters = df['creator_nid'].nunique()
+        total_reports = len(df)
+        avg_reports_per_person = total_reports / active_reporters if active_reporters > 0 else 0
+        # Cek apakah ada reporter dominan
+        top_reporter_counts = df['creator_nid'].value_counts()
+        if not top_reporter_counts.empty:
+            top_reporter_id = top_reporter_counts.index[0]
+            top_reporter_count = top_reporter_counts.iloc[0]
+            if top_reporter_count / total_reports > 0.15: # Jika satu orang membuat > 15% laporan
+                insight_text = (
+                    f"Reporter with ID '{top_reporter_id}' has submitted a disproportionately high number of findings ({top_reporter_count}). "
+                    f"They account for {top_reporter_count/total_reports*100:.1f}% of the total volume."
+                )
+                recommendation_text = (
+                    f"Recognize the active reporter. Also, ensure reporting is distributed across the team "
+                    f"to provide a more comprehensive view of risks across all areas and activities."
+                )
+                insight_recommendations.append({"insight": insight_text, "recommendation": recommendation_text})
+
+    return insight_recommendations
+
+# Panggil fungsi untuk mendapatkan insight dan rekomendasi
+ai_insights_and_recs = compute_ai_insights(df_filtered)
+
+# Tampilkan hasil
+
+if ai_insights_and_recs:
+    for i, item in enumerate(ai_insights_and_recs):
+        insight = item["insight"]
+        recommendation = item["recommendation"]
+        # Tampilkan Insight
+        st.markdown(f'<div class="ai-insight"><strong>Insight {i+1}:</strong> {insight}</div>', unsafe_allow_html=True)
+        # Tampilkan Recommendation
+        st.markdown(f'<div class="ai-recommendation"><strong>Recommendation {i+1}:</strong> {recommendation}</div>', unsafe_allow_html=True)
+else:
+    # Jika tidak ada insight yang dihasilkan, mungkin karena data kosong atau kolom tidak ditemukan
+    st.markdown('<div class="ai-insight">No significant AI insights could be generated. This might be due to insufficient data or missing required columns after filtering.</div>', unsafe_allow_html=True)
+
+# =================== FOOTER ===================
+st.markdown("---")
+st.markdown(
+    """
+    <div style="text-align:center; color:#757575; font-size:0.9em;">
+        <strong> Special Design for PLN </strong> •  © 2025 PT Bukit Technology
+    </div>
+    """,
+    unsafe_allow_html=True
+)

requirements.txt

@@ -1,3 +1,14 @@
 altair
-pandas
-streamlit
+streamlit>=1.38.0
+pandas>=2.2.2
+numpy>=1.26.4
+plotly>=5.24.1
+plotly-express>=0.4.1
+openpyxl>=3.1.5
+python-dateutil>=2.9.0
+# --- Tambahkan untuk WordCloud ---
+wordcloud>=1.9.3
+matplotlib>=3.8.0
+# --- Tambahkan untuk Analisis Prediktif (AI Insights) ---
+statsmodels>=0.14.0
+# -------------------------------