perbaiki model_utils.py and back app.py, visualization.py

app.py

@@ -6,8 +6,6 @@ berbasis aspek dari kritik dan saran mahasiswa.
 UPDATED: Dengan Batch + Chunked Processing + Session-based Cache untuk multi-user
 UPDATED: Visualisasi dinamis yang menyesuaikan dengan kolom yang tersedia
 """
-
-# Import library yang diperlukan
 import os
 import time
 import gc
@@ -38,48 +36,41 @@ from visualization import (
 from preprocessing import text_preprocessing_pipeline
 
 # Konfigurasi untuk chunked processing
-CHUNK_SIZE = 2500  # Ukuran chunk untuk memproses data besar
-ENABLE_CHUNKED = True  # Aktifkan mode chunked processing
-CACHE_EXPIRY_HOURS = 24  # Durasi cache sebelum dihapus otomatis
+CHUNK_SIZE = 2500
+ENABLE_CHUNKED = True
+CACHE_EXPIRY_HOURS = 24
 
-# Membuat direktori cache jika belum ada
 os.makedirs("chache_file", exist_ok=True)
 os.makedirs("chache_file/sessions", exist_ok=True)
 
-# Konfigurasi halaman Streamlit
+# Konfigurasi halaman
 st.set_page_config(
     page_title="ABSA IndoBERT",
     layout="wide",
     page_icon="💬"
 )
 
-# Load custom CSS untuk styling
+# Load custom CSS
 with open(os.path.join("assets", "style.css"), encoding="utf-8") as f:
     st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
 st.markdown('<link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.11.3/font/bootstrap-icons.css" rel="stylesheet">', unsafe_allow_html=True)
 
 
 def get_session_id():
-    """
-    Generate atau retrieve session ID untuk user - PERSISTENT across refresh
-    Menggunakan query params agar session tetap konsisten saat refresh
-    """
+    """Generate atau retrieve session ID untuk user - PERSISTENT across refresh"""
     query_params = st.query_params
 
-    # Cek jika sudah ada session ID di URL
     if "sid" in query_params:
         sid = query_params["sid"]
         st.session_state.session_id = sid
         return sid
 
-    # Buat session ID baru jika belum ada
     if "session_id" not in st.session_state:
         new_session_id = str(uuid.uuid4())
         st.session_state.session_id = new_session_id
         st.query_params["sid"] = new_session_id
         return new_session_id
 
-    # Gunakan session ID yang sudah ada
     existing_id = st.session_state.session_id
     st.query_params["sid"] = existing_id
     return existing_id
@@ -101,10 +92,7 @@ def get_session_chunks_dir():
 
 
 def cleanup_old_sessions():
-    """
-    Hapus session cache yang sudah expired (> 24 jam)
-    Membersihkan cache lama untuk menghemat storage
-    """
+    """Hapus session cache yang sudah expired (> 24 jam)"""
     sessions_dir = Path("chache_file/sessions")
     if not sessions_dir.exists():
         return
@@ -115,7 +103,6 @@ def cleanup_old_sessions():
             mod_time = session_dir.stat().st_mtime
             age_hours = (current_time - mod_time) / 3600
 
-            # Hapus jika lebih dari 24 jam
             if age_hours > CACHE_EXPIRY_HOURS:
                 try:
                     shutil.rmtree(session_dir)
@@ -124,24 +111,18 @@ def cleanup_old_sessions():
                     print(f"Error deleting session {session_dir.name}: {e}")
 
 
-# Jalankan cleanup saat aplikasi dimulai
 cleanup_old_sessions()
 
 
 @st.cache_resource(show_spinner=False)
 def get_model_resources():
-    """
-    Memuat model dan tokenizer IndoBERT
-    Menggunakan cache agar model tidak dimuat ulang setiap kali
-    """
+    """Memuat model dan tokenizer IndoBERT."""
     return load_model_and_tokenizer()
 
 
-# Load model dengan spinner
 with st.spinner("Sedang memuat model IndoBERT dan tokenizer... Harap tunggu sebentar!"):
     model, tokenizer, le, device = get_model_resources()
 
-# Tampilkan notifikasi sukses sementara
 success_placeholder = st.empty()
 success_placeholder.success("Model dan tokenizer berhasil dimuat!")
 time.sleep(1)
@@ -149,7 +130,7 @@ success_placeholder.empty()
 
 
 def convert_df_to_excel(df):
-    """Mengubah DataFrame menjadi file Excel dalam bentuk byte stream untuk download"""
+    """Mengubah DataFrame menjadi file Excel dalam bentuk byte stream."""
     output = BytesIO()
     with pd.ExcelWriter(output, engine="openpyxl") as writer:
         df.to_excel(writer, index=False)
@@ -157,7 +138,7 @@ def convert_df_to_excel(df):
 
 
 def clear_memory():
-    """Clear memory cache untuk menghemat RAM dan VRAM"""
+    """Clear memory cache"""
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
@@ -165,20 +146,8 @@ def clear_memory():
 
 def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_bar, status_text):
     """
-    Memproses satu chunk data dengan batch processing
-    STEP 1: Preprocessing teks (cleaning, normalisasi)
-    STEP 2: Batch Prediction menggunakan model IndoBERT
-    STEP 3: Combine results dan simpan ke file CSV
-
-    Args:
-        chunk_dataframe: Data chunk yang akan diproses
-        chunk_num: Nomor chunk saat ini
-        total_chunk_count: Total jumlah chunk
-        progress_bar: Progress bar Streamlit
-        status_text: Text status Streamlit
-
-    Returns:
-        result_dataframe: DataFrame hasil prediksi untuk chunk ini
+    Memproses satu chunk data dengan batch processing.
+    Progress bar: Preprocessing 0-100%, lalu Predicting 0-100%
     """
     # STEP 1: Preprocessing (0-100%)
     cleaned_text_list = []
@@ -188,7 +157,6 @@ def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_
         clean_text = text_preprocessing_pipeline(str(raw_text))
         cleaned_text_list.append(clean_text)
 
-        # Update progress bar setiap 50 baris
         if idx % 50 == 0 or idx == total_rows - 1:
             progress = (idx + 1) / total_rows
             progress_bar.progress(progress)
@@ -206,7 +174,6 @@ def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_
     num_sents = len(cleaned_text_list)
     num_asps = len(ASPEK_COLUMNS)
 
-    # Buat dataset dan dataloader
     ds = ABSADataset(cleaned_text_list, ASPEK_COLUMNS,
                      tokenizer, CONFIG["max_len"])
     dl = DataLoader(
@@ -216,13 +183,11 @@ def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_
         num_workers=0
     )
 
-    # Matrix untuk menyimpan hasil prediksi
     predictions_matrix = [[None] * num_asps for _ in range(num_sents)]
 
     batch_counter = 0
     total_batch_count = len(dl)
 
-    # Lakukan prediksi batch demi batch
     model.eval()
     with torch.no_grad():
         for batch_data in dl:
@@ -231,18 +196,15 @@ def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_
             sent_idxs = batch_data['sent_idx'].numpy()
             asp_idxs = batch_data['aspect_idx'].numpy()
 
-            # Forward pass model
             model_outputs = model(inp_ids, attn_mask)
             probabilities = F.softmax(model_outputs, dim=1)
             predicted_indices = torch.argmax(
                 probabilities, dim=1).cpu().numpy()
             pred_labels = le.inverse_transform(predicted_indices)
 
-            # Simpan hasil prediksi ke matrix
             for s_idx, a_idx, lbl in zip(sent_idxs, asp_idxs, pred_labels):
                 predictions_matrix[s_idx][a_idx] = lbl
 
-            # Update progress bar
             batch_counter += 1
             progress = batch_counter / total_batch_count
             progress_bar.progress(progress)
@@ -254,14 +216,12 @@ def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_
     for idx, (_, data_row) in enumerate(chunk_dataframe.iterrows()):
         row_dict = data_row.to_dict()
         row_dict["kritik_saran"] = cleaned_text_list[idx]
-        # Tambahkan hasil prediksi untuk setiap aspek
         for asp_idx, asp_name in enumerate(ASPEK_COLUMNS):
             row_dict[asp_name] = predictions_matrix[idx][asp_idx]
         result_list.append(row_dict)
 
     result_dataframe = pd.DataFrame(result_list)
 
-    # Simpan chunk ke file CSV
     chunks_directory = get_session_chunks_dir()
     chunk_filepath = chunks_directory / f"chunk_{chunk_num}.csv"
     result_dataframe.to_csv(chunk_filepath, index=False)
@@ -270,17 +230,13 @@ def process_chunk_batch(chunk_dataframe, chunk_num, total_chunk_count, progress_
     progress_bar.progress(1.0)
     status_text.text(f"Chunk {chunk_num}/{total_chunk_count} | Selesai!")
 
-    # Bersihkan memory
     clear_memory()
 
     return result_dataframe
 
 
 def get_available_columns(df):
-    """
-    Deteksi kolom-kolom yang tersedia dalam dataframe
-    Untuk menentukan visualisasi mana yang bisa ditampilkan
-    """
+    """Deteksi kolom-kolom yang tersedia dalam dataframe"""
     available = {
         'has_tahun': 'tahun' in df.columns or 'tanggal' in df.columns,
         'has_semester': 'semester' in df.columns,
@@ -290,8 +246,6 @@ def get_available_columns(df):
     return available
 
 
-# ================== BAGIAN UI UTAMA ==================
-
 # Judul aplikasi
 st.markdown("""
     <h1 class='title-center'>ABSA IndoBERT</h1>
@@ -303,7 +257,7 @@ st.markdown(" ")
 st.markdown(" ")
 st.markdown(" ")
 
-# Panduan penggunaan aplikasi
+# Panduan pengunaan
 steps = [
     {"icon": "bi bi-cloud-arrow-up", "title": "1. Upload File Excel",
         "description": "Siapkan dan upload file Excel kritik dan saran yang wajib memiliki kolom `kritik_saran`."},
@@ -315,7 +269,6 @@ steps = [
         "description": "Unduh hasil analisis lengkap Anda dalam format file Excel untuk laporan lebih lanjut."}
 ]
 
-# Tampilkan panduan dalam 4 kolom
 cols = st.columns(len(steps))
 
 for i, step in enumerate(steps):
@@ -331,19 +284,18 @@ for i, step in enumerate(steps):
 st.markdown("")
 st.markdown("")
 
-# Upload file Excel
+# Upload file
 uploaded_file = st.file_uploader(
     " Upload Data Kritik & Saran",
     type=["xlsx"],
     help="File maksimal 200MB dengan format .xlsx"
 )
 
-# Tombol untuk menghapus cache (session-specific)
+# Clear cache buttons - SESSION SPECIFIC
 session_cache_dir = get_session_cache_dir()
 session_result_file = session_cache_dir / "temp_predicted.csv"
 session_chunks_dir = get_session_chunks_dir()
 
-# Tombol hapus cache data utama
 if session_result_file.exists():
     if st.button("Hapus Cache Data"):
         session_result_file.unlink()
@@ -351,7 +303,6 @@ if session_result_file.exists():
         time.sleep(1)
         st.rerun()
 
-# Tombol hapus cache chunks
 if session_chunks_dir.exists():
     chunk_files = list(session_chunks_dir.glob("*.csv"))
     if chunk_files:
@@ -363,7 +314,6 @@ if session_chunks_dir.exists():
             time.sleep(1)
             st.rerun()
 
-# Tampilkan info file yang di-cache
 if session_result_file.exists() or (session_chunks_dir.exists() and list(session_chunks_dir.glob("*.csv"))):
     if not uploaded_file:
         metadata_file = session_cache_dir / "metadata.txt"
@@ -384,15 +334,13 @@ if session_result_file.exists() or (session_chunks_dir.exists() and list(session
     else:
         st.caption(" ")
 
-# Inisialisasi session state untuk hasil prediksi
+
 if "df_predicted" not in st.session_state:
     st.session_state.df_predicted = None
 
-# Load cache jika ada
 if st.session_state.df_predicted is None and session_result_file.exists():
     try:
         df_cached = pd.read_csv(session_result_file)
-        # Konversi kolom tahun ke format yang benar
         if "tahun" in df_cached.columns:
             df_cached["tahun"] = pd.to_numeric(
                 df_cached["tahun"], errors='coerce').astype('Int64')
@@ -402,20 +350,14 @@ if st.session_state.df_predicted is None and session_result_file.exists():
         st.warning(f"Gagal memuat cache: {e}")
 
 
-# ================== PROSES UPLOAD & PREDIKSI ==================
 if uploaded_file:
     file_bytes = uploaded_file.getvalue()
-
-    # Cek apakah file baru atau sama dengan sebelumnya
     if "last_uploaded_file" not in st.session_state or st.session_state.last_uploaded_file != file_bytes:
         st.session_state.last_uploaded_file = file_bytes
         st.session_state.uploaded_filename = uploaded_file.name
-
         try:
-            # Baca file Excel
             df_uploaded = pd.read_excel(BytesIO(file_bytes))
 
-            # Konversi kolom tahun jika ada
             if "tahun" in df_uploaded.columns:
                 df_uploaded["tahun"] = pd.to_numeric(
                     df_uploaded["tahun"], errors='coerce').astype('Int64')
@@ -423,15 +365,11 @@ if uploaded_file:
         except ValueError as err:
             st.error(f"Gagal membaca file: {err}")
         else:
-            # Validasi kolom wajib
             if "kritik_saran" not in df_uploaded.columns:
                 st.error("Kolom 'kritik_saran' tidak ditemukan.")
             else:
-                # Hapus duplikat berdasarkan kolom kritik_saran
                 df_uploaded = df_uploaded.drop_duplicates(
                     subset=["kritik_saran"])
-
-                # Tambahkan kolom aspek jika belum ada
                 for aspect_col in ASPEK_COLUMNS:
                     if aspect_col not in df_uploaded.columns:
                         df_uploaded[aspect_col] = None
@@ -441,11 +379,9 @@ if uploaded_file:
                 total_rows = len(df_uploaded)
                 use_chunked = ENABLE_CHUNKED and total_rows > CHUNK_SIZE
 
-                # ============ MODE CHUNKED PROCESSING ============
                 if use_chunked:
                     num_chunks = (total_rows + CHUNK_SIZE - 1) // CHUNK_SIZE
 
-                    # Tampilkan info processing
                     info_col1, info_col2, info_col3 = st.columns(3)
                     with info_col1:
                         st.info(f"**Total data:** {total_rows:,} rows")
@@ -462,7 +398,6 @@ if uploaded_file:
                     chunk_status_text = st.empty()
                     overall_status = st.empty()
 
-                    # Proses setiap chunk
                     for start_idx in range(0, total_rows, CHUNK_SIZE):
                         current_chunk_number = (start_idx // CHUNK_SIZE) + 1
                         current_chunk_df = df_uploaded.iloc[start_idx:start_idx+CHUNK_SIZE].copy(
@@ -471,7 +406,6 @@ if uploaded_file:
                         current_chunk_file = session_chunks_dir / \
                             f"chunk_{current_chunk_number}.csv"
 
-                        # Cek apakah chunk sudah pernah diproses (ada di cache)
                         if current_chunk_file.exists():
                             chunk_result = pd.read_csv(current_chunk_file)
                             all_chunk_results.append(chunk_result)
@@ -490,7 +424,6 @@ if uploaded_file:
                             time.sleep(0.3)
                             continue
 
-                        # Proses chunk baru
                         chunk_progress_bar.progress(0)
 
                         chunk_result = process_chunk_batch(
@@ -499,7 +432,6 @@ if uploaded_file:
                         )
                         all_chunk_results.append(chunk_result)
 
-                        # Hitung estimasi waktu
                         processed = min(start_idx + CHUNK_SIZE, total_rows)
                         progress_pct = (processed / total_rows) * 100
                         elapsed = time.time() - start_time
@@ -514,7 +446,6 @@ if uploaded_file:
 
                         time.sleep(0.3)
 
-                    # Gabungkan semua chunk
                     chunk_status_text.empty()
                     overall_status.info("🔄 Menggabungkan semua chunks...")
                     df_session = pd.concat(
@@ -524,7 +455,6 @@ if uploaded_file:
                     end_time = time.time()
                     duration = end_time - start_time
 
-                # ============ MODE BATCH PROCESSING (tanpa chunk) ============
                 else:
                     st.info(
                         f"**Total data:** {total_rows:,} rows | **Mode:** Batch Processing")
@@ -534,7 +464,6 @@ if uploaded_file:
                     progress_bar = st.progress(0)
                     status_text = st.empty()
 
-                    # Preprocessing
                     cleaned_text_list = []
                     total_preprocessing = len(df_uploaded)
 
@@ -552,7 +481,6 @@ if uploaded_file:
                     status_text.text("Memulai prediksi...")
                     time.sleep(0.3)
 
-                    # Batch Prediction
                     batch_sz = CONFIG.get("batch_size", 32)
                     num_sents = len(cleaned_text_list)
                     num_asps = len(ASPEK_COLUMNS)
@@ -592,7 +520,6 @@ if uploaded_file:
                             status_text.text(
                                 f"Predicting: {batch_counter}/{total_batch_count} batches")
 
-                    # Combine results
                     result_list = []
                     for idx, (_, data_row) in enumerate(df_uploaded.iterrows()):
                         row_dict = data_row.to_dict()
@@ -612,20 +539,16 @@ if uploaded_file:
                     end_time = time.time()
                     duration = end_time - start_time
 
-                # Simpan hasil ke session state dan cache
                 st.session_state.df_predicted = df_session
                 df_session.to_csv(session_result_file, index=False)
 
-                # Simpan metadata file
                 metadata_file = session_cache_dir / "metadata.txt"
                 with open(metadata_file, "w", encoding="utf-8") as f:
                     f.write(uploaded_file.name)
 
-                # Hitung statistik processing
                 total_items = total_rows * len(ASPEK_COLUMNS)
                 items_per_second = total_items / duration if duration > 0 else 0
 
-                # Tampilkan hasil processing
                 if use_chunked:
                     st.success(
                         f"✅ **Chunked + Batch Processing selesai!**\n\n"
@@ -645,14 +568,14 @@ if uploaded_file:
                         f"- Waktu: **{duration:.2f}** detik (~{items_per_second:.1f} prediksi/detik)"
                     )
 
-# ================== TAMPILAN HASIL & VISUALISASI ==================
+# Setelah prediksi selesai
 if st.session_state.df_predicted is not None:
     df_predicted = st.session_state.df_predicted
 
-    # Deteksi kolom yang tersedia dalam dataframe
+    # Deteksi kolom yang tersedia
     available_cols = get_available_columns(df_predicted)
 
-    # ============ SIDEBAR FILTER ============
+    # Sidebar filter dengan pengecekan kolom dinamis
     st.sidebar.header("Filter Data")
 
     df_clean = df_predicted.copy()
@@ -664,7 +587,7 @@ if st.session_state.df_predicted is not None:
         st.sidebar.info(
             "Tidak ada kolom yang dapat difilter. Pastikan file memiliki kolom seperti: nama_matakuliah, nama_prodi, tahun/tanggal, atau semester.")
 
-    # Filter Mata Kuliah (jika ada)
+    # Filter Mata Kuliah
     selected_matkul = []
     if available_cols['has_matkul']:
         matkul_options = sorted(
@@ -673,7 +596,7 @@ if st.session_state.df_predicted is not None:
             selected_matkul = st.sidebar.multiselect(
                 "Nama Mata Kuliah", matkul_options, default=matkul_options)
 
-    # Filter Program Studi (jika ada)
+    # Filter Program Studi
     selected_prodi = []
     if available_cols['has_prodi']:
         prodi_options = sorted(
@@ -682,10 +605,9 @@ if st.session_state.df_predicted is not None:
             selected_prodi = st.sidebar.multiselect(
                 "Program Studi", prodi_options, default=prodi_options)
 
-    # Filter Tahun (jika ada)
+    # Filter Tahun
     selected_tahun = []
     if available_cols['has_tahun']:
-        # Konversi tanggal ke tahun jika perlu
         if 'tanggal' in df_clean.columns and 'tahun' not in df_clean.columns:
             df_clean['tahun'] = pd.to_datetime(
                 df_clean['tanggal'], errors='coerce').dt.year
@@ -696,7 +618,7 @@ if st.session_state.df_predicted is not None:
                 selected_tahun = st.sidebar.multiselect(
                     "Tahun", tahun_options, default=tahun_options)
 
-    # Filter Semester (jika ada)
+    # Filter Semester
     selected_semester = []
     if available_cols['has_semester']:
         semester_options = sorted(
@@ -705,7 +627,7 @@ if st.session_state.df_predicted is not None:
             selected_semester = st.sidebar.multiselect(
                 "Semester", semester_options, default=semester_options)
 
-    # Apply semua filter yang dipilih
+    # Apply filters
     df_filtered = df_clean.copy()
 
     if selected_matkul and available_cols['has_matkul']:
@@ -714,130 +636,123 @@ if st.session_state.df_predicted is not None:
 
     if selected_prodi and available_cols['has_prodi']:
         df_filtered = df_filtered[df_filtered["nama_prodi"].isin(
-            selected_prodi
-            if selected_prodi and available_cols['has_prodi']:
-            df_filtered=df_filtered[df_filtered["nama_prodi"].isin(
-                selected_prodi)]
-
-            if selected_tahun and available_cols['has_tahun']:
-            df_filtered=df_filtered[df_filtered["tahun"].isin(selected_tahun)]
-
-            if selected_semester and available_cols['has_semester']:
-            df_filtered=df_filtered[df_filtered["semester"].isin(
-                selected_semester)]
-
-            # ============ TAMPILAN TABEL HASIL ============
-            st.markdown("### Tabel Data Hasil Prediksi")
-            st.dataframe(df_filtered, width='stretch')
-
-            # ============ TOMBOL DOWNLOAD ============
-            col_dl1, col_dl2=st.columns(2)
-            with col_dl1:
-            # Download data terfilter
-            st.download_button(
-                label="Unduh Data Terfilter",
-                data=convert_df_to_excel(df_filtered),
-                file_name="hasil_prediksi_absa_filtered.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                use_container_width=True
-            )
-
-            with col_dl2:
-            # Download semua data tanpa filter
-            st.download_button(
-                label="Unduh Semua Data",
-                data=convert_df_to_excel(df_predicted),
-                file_name="hasil_prediksi_absa_all.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                use_container_width=True
-            )
-
-            st.info(
-                f"Menampilkan {len(df_filtered):,} dari {len(df_predicted):,} data ulasan setelah difilter."
-            )
-
-            # ============ RINGKASAN CEPAT ============
-            st.markdown("")
-            st.markdown("### Ringkasan Cepat")
-            st.markdown("")
-
-            # Hitung total sentimen dari semua aspek
-            total_pos=(df_filtered[ASPEK_COLUMNS] == "positif").sum().sum()
-            total_net=(df_filtered[ASPEK_COLUMNS] == "netral").sum().sum()
-            total_neg=(df_filtered[ASPEK_COLUMNS] == "negatif").sum().sum()
-
-            # Tentukan kolom mana yang tersedia untuk ditampilkan
-            summary_cols=[]
-
-            # Kolom dasar (selalu ada)
-            summary_cols.extend(['ulasan', 'aspek'])
-
-            # Kolom opsional berdasarkan data yang tersedia
-            if available_cols['has_matkul']:
-            summary_cols.append('matkul')
-            if available_cols['has_prodi']:
-            summary_cols.append('prodi')
-            if available_cols['has_semester']:
-            summary_cols.append('semester')
+            selected_prodi)]
+
+    if selected_tahun and available_cols['has_tahun']:
+        df_filtered = df_filtered[df_filtered["tahun"].isin(selected_tahun)]
+
+    if selected_semester and available_cols['has_semester']:
+        df_filtered = df_filtered[df_filtered["semester"].isin(
+            selected_semester)]
+
+    # Tampilkan tabel hasil prediksi
+    st.markdown("### Tabel Data Hasil Prediksi")
+    st.dataframe(df_filtered, width='stretch')
+
+    # Download buttons
+    col_dl1, col_dl2 = st.columns(2)
+    with col_dl1:
+        st.download_button(
+            label="Unduh Data Terfilter",
+            data=convert_df_to_excel(df_filtered),
+            file_name="hasil_prediksi_absa_filtered.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            use_container_width=True
+        )
+
+    with col_dl2:
+        st.download_button(
+            label="Unduh Semua Data",
+            data=convert_df_to_excel(df_predicted),
+            file_name="hasil_prediksi_absa_all.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            use_container_width=True
+        )
+
+    st.info(
+        f"Menampilkan {len(df_filtered):,} dari {len(df_predicted):,} data ulasan setelah difilter."
+    )
 
-            # Buat kolom dinamis berdasarkan jumlah metrik
-            num_cols=len(summary_cols)
-            cols=st.columns(num_cols)
+    # Ringkasan Cepat
+    st.markdown("")
+    st.markdown("### Ringkasan Cepat")
+    st.markdown("")
 
-            col_idx=0
+    total_pos = (df_filtered[ASPEK_COLUMNS] == "positif").sum().sum()
+    total_net = (df_filtered[ASPEK_COLUMNS] == "netral").sum().sum()
+    total_neg = (df_filtered[ASPEK_COLUMNS] == "negatif").sum().sum()
 
-            # Metrik: Ulasan & Aspek (selalu ada)
-            cols[col_idx].metric("Jumlah Ulasan", f"{len(df_filtered):,}")
-            col_idx += 1
-            cols[col_idx].metric("Jumlah Aspek", len(ASPEK_COLUMNS))
-            col_idx += 1
+    # Hitung jumlah kolom yang tersedia untuk ringkasan
+    summary_cols = []
 
-            # Metrik: Mata Kuliah (jika ada)
-            if available_cols['has_matkul']:
-            matkul_count=df_filtered['nama_matakuliah'].nunique()
-            cols[col_idx].metric("Jumlah Mata Kuliah", f"{matkul_count:,}")
-            col_idx += 1
+    # Kolom dasar (selalu ada)
+    summary_cols.extend(['ulasan', 'aspek'])
+
+    # Kolom opsional
+    if available_cols['has_matkul']:
+        summary_cols.append('matkul')
+    if available_cols['has_prodi']:
+        summary_cols.append('prodi')
+    if available_cols['has_semester']:
+        summary_cols.append('semester')
 
-            # Metrik: Prodi (jika ada)
-            if available_cols['has_prodi']:
-            prodi_count=df_filtered['nama_prodi'].nunique()
-            cols[col_idx].metric("Jumlah Prodi", f"{prodi_count:,}")
-            col_idx += 1
+    # Buat kolom dinamis berdasarkan data yang tersedia
+    num_cols = len(summary_cols)
+    cols = st.columns(num_cols)
 
-            # Metrik: Semester (jika ada)
-            if available_cols['has_semester']:
-            semester_count=df_filtered['semester'].nunique()
-            cols[col_idx].metric("Jumlah Semester", f"{semester_count:,}")
-            col_idx += 1
+    col_idx = 0
 
-            st.markdown("")
+    # Ulasan & Aspek (selalu ada)
+    cols[col_idx].metric("Jumlah Ulasan", f"{len(df_filtered):,}")
+    col_idx += 1
+    cols[col_idx].metric("Jumlah Aspek", len(ASPEK_COLUMNS))
+    col_idx += 1
 
-            # Baris kedua: Sentimen + info tambahan
-            summary_cols2=['positif', 'netral', 'negatif']
+    # Mata Kuliah (jika ada)
+    if available_cols['has_matkul']:
+        matkul_count = df_filtered['nama_matakuliah'].nunique()
+        cols[col_idx].metric("Jumlah Mata Kuliah", f"{matkul_count:,}")
+        col_idx += 1
 
-            if available_cols['has_tahun']:
-            summary_cols2.append('tahun')
-            if 'kritik_saran' in df_filtered.columns:
-            summary_cols2.append('kata')
-
-            cols2=st.columns(len(summary_cols2))
-
-            col_idx2=0
-            # Metrik: Sentimen Positif, Netral, Negatif
-            cols2[col_idx2].metric("Sentimen Positif", f"{total_pos:,}")
-            col_idx2 += 1
-            cols2[col_idx2].metric("Sentimen Netral", f"{total_net:,}")
-            col_idx2 += 1
-            cols2[col_idx2].metric("Sentimen Negatif", f"{total_neg:,}")
-            col_idx2 += 1
-
-            # Metrik: Rentang tahun (jika ada)
-            if available_cols['has_tahun']:
-            if 'tahun' in df_filtered.columns:
-            tahun_valid=df_filtered['tahun'].dropna()
+    # Prodi (jika ada)
+    if available_cols['has_prodi']:
+        prodi_count = df_filtered['nama_prodi'].nunique()
+        cols[col_idx].metric("Jumlah Prodi", f"{prodi_count:,}")
+        col_idx += 1
+
+    # Semester (jika ada)
+    if available_cols['has_semester']:
+        semester_count = df_filtered['semester'].nunique()
+        cols[col_idx].metric("Jumlah Semester", f"{semester_count:,}")
+        col_idx += 1
+
+    st.markdown("")
+
+    # Baris kedua: Sentimen + info tambahan
+    summary_cols2 = ['positif', 'netral', 'negatif']
+
+    if available_cols['has_tahun']:
+        summary_cols2.append('tahun')
+    if 'kritik_saran' in df_filtered.columns:
+        summary_cols2.append('kata')
+
+    cols2 = st.columns(len(summary_cols2))
+
+    col_idx2 = 0
+    cols2[col_idx2].metric("Sentimen Positif", f"{total_pos:,}")
+    col_idx2 += 1
+    cols2[col_idx2].metric("Sentimen Netral", f"{total_net:,}")
+    col_idx2 += 1
+    cols2[col_idx2].metric("Sentimen Negatif", f"{total_neg:,}")
+    col_idx2 += 1
+
+    # Rentang tahun (jika ada)
+    if available_cols['has_tahun']:
+        if 'tahun' in df_filtered.columns:
+            tahun_valid = df_filtered['tahun'].dropna()
             if len(tahun_valid) > 0:
-                tahun_min=int(tahun_valid.min())
-                tahun_max=int(tahun_valid.max())
+                tahun_min = int(tahun_valid.min())
+                tahun_max = int(tahun_valid.max())
                 if tahun_min == tahun_max:
                     cols2[col_idx2].metric("Tahun", f"{tahun_min}")
                 else:
@@ -845,95 +760,89 @@ if st.session_state.df_predicted is not None:
                         "Rentang Tahun", f"{tahun_min} - {tahun_max}")
             else:
                 cols2[col_idx2].metric("Rentang Tahun", "N/A")
-            else:
+        else:
             cols2[col_idx2].metric("Rentang Tahun", "N/A")
-            col_idx2 += 1
+        col_idx2 += 1
 
-            # Metrik: Rata-rata panjang kata (jika kolom kritik_saran ada)
-            if 'kritik_saran' in df_filtered.columns and len(df_filtered) > 0:
-            try:
-            word_counts=df_filtered['kritik_saran'].astype(
+    # Rata-rata panjang kata (jika ada)
+    if 'kritik_saran' in df_filtered.columns and len(df_filtered) > 0:
+        try:
+            word_counts = df_filtered['kritik_saran'].astype(
                 str).str.split().str.len()
-            avg_word_count=round(word_counts.mean(), 1)
+            avg_word_count = round(word_counts.mean(), 1)
             cols2[col_idx2].metric(
                 "Rata-rata Panjang Kata", f"{avg_word_count} kata")
-            except Exception:
+        except Exception:
             cols2[col_idx2].metric("Rata-rata Panjang Kata", "N/A")
 
-            # ============ VISUALISASI DATA ============
-            st.markdown("---")
-            st.markdown("### Visualisasi Data")
+    st.markdown("---")
+    st.markdown("### Visualisasi Data")
 
-            # Visualisasi Sentimen Dasar (selalu ditampilkan)
-            col1, col2=st.columns(2)
-            with col1:
-            show_sentiment_bar_chart(df_filtered, ASPEK_COLUMNS)
-            with col2:
-            show_sentiment_pie_chart(df_filtered, ASPEK_COLUMNS)
+    # Visualisasi Sentimen (selalu ditampilkan)
+    col1, col2 = st.columns(2)
+    with col1:
+        show_sentiment_bar_chart(df_filtered, ASPEK_COLUMNS)
+    with col2:
+        show_sentiment_pie_chart(df_filtered, ASPEK_COLUMNS)
 
-            # Visualisasi berdasarkan kolom yang tersedia
-            viz_shown=False
+    # Visualisasi berdasarkan kolom yang tersedia
+    viz_shown = False
 
-            # Visualisasi: Distribusi Tahun & Semester
-            if available_cols['has_tahun'] or available_cols['has_semester']:
-            col1, col2=st.columns(2)
-            with col1:
+    if available_cols['has_tahun'] or available_cols['has_semester']:
+        col1, col2 = st.columns(2)
+        with col1:
             if available_cols['has_tahun']:
-                result=show_year_distribution(df_filtered)
+                result = show_year_distribution(df_filtered)
                 if result:
-                    viz_shown=True
-            with col2:
+                    viz_shown = True
+        with col2:
             if available_cols['has_semester']:
-                result=show_semester_distribution(df_filtered)
+                result = show_semester_distribution(df_filtered)
                 if result:
-                    viz_shown=True
-
-            # Visualisasi: Distribusi Prodi
-            if available_cols['has_prodi']:
-            st.markdown("---")
-            result=show_prodi_distribution(df_filtered)
-            if result:
-            viz_shown=True
-
-            # Visualisasi: Distribusi Top 10 Mata Kuliah
-            if available_cols['has_matkul']:
-            st.markdown("---")
-            result=show_top10_matkul_distribution(df_filtered)
-            if result:
-            viz_shown=True
-
-            # Visualisasi: Sentimen per Tahun/Semester
-            if available_cols['has_tahun'] or available_cols['has_semester']:
-            st.markdown("---")
-            col1, col2=st.columns(2)
-            with col1:
+                    viz_shown = True
+
+    if available_cols['has_prodi']:
+        st.markdown("---")
+        result = show_prodi_distribution(df_filtered)
+        if result:
+            viz_shown = True
+
+    if available_cols['has_matkul']:
+        st.markdown("---")
+        result = show_top10_matkul_distribution(df_filtered)
+        if result:
+            viz_shown = True
+
+    # Sentimen per tahun/semester
+    if available_cols['has_tahun'] or available_cols['has_semester']:
+        st.markdown("---")
+        col1, col2 = st.columns(2)
+        with col1:
             if available_cols['has_tahun']:
-                result=show_sentiment_by_year(df_filtered, ASPEK_COLUMNS)
+                result = show_sentiment_by_year(df_filtered, ASPEK_COLUMNS)
                 if result:
-                    viz_shown=True
-            with col2:
+                    viz_shown = True
+        with col2:
             if available_cols['has_semester']:
-                result=show_sentiment_by_semester(df_filtered, ASPEK_COLUMNS)
+                result = show_sentiment_by_semester(df_filtered, ASPEK_COLUMNS)
                 if result:
-                    viz_shown=True
-
-            # Visualisasi: Sentimen per Prodi
-            if available_cols['has_prodi']:
-            st.markdown("---")
-            result=show_sentiment_by_prodi(df_filtered, ASPEK_COLUMNS)
-            if result:
-            viz_shown=True
-
-            # Visualisasi: Sentimen per Top 10 Mata Kuliah
-            if available_cols['has_matkul']:
-            st.markdown("---")
-            result=show_sentiment_by_top10_matkul(df_filtered, ASPEK_COLUMNS)
-            if result:
-            viz_shown=True
-
-            # ============ FOOTER ============
-            st.caption("""
+                    viz_shown = True
+
+    if available_cols['has_prodi']:
+        st.markdown("---")
+        result = show_sentiment_by_prodi(df_filtered, ASPEK_COLUMNS)
+        if result:
+            viz_shown = True
+
+    if available_cols['has_matkul']:
+        st.markdown("---")
+        result = show_sentiment_by_top10_matkul(df_filtered, ASPEK_COLUMNS)
+        if result:
+            viz_shown = True
+
+# Footer
+st.caption("""
     <div class='footer'>
-        © 2025 Darmawan Jiddan | Dibuat dengan ❤️ menggunakan Streamlit
+        © 2025 Darmawan Jiddan | Dibuat dengan ❤️ menggunakan Streamlit 
     </div>
 """, unsafe_allow_html=True)

model_utils.py

@@ -17,7 +17,7 @@ except ImportError:
     subprocess.check_call(['pip', 'install', 'scikit-learn'])
     from sklearn.preprocessing import LabelEncoder
 
-# Custom Dataset untuk batch processing
+
 class ABSADataset(Dataset):
     """
     Custom Dataset untuk ABSA batch processing.
@@ -294,4 +294,87 @@ def predict_multi_aspect(model, tokenizer, sentence, aspek_list, label_encoder,
         # Prediksi tanpa menghitung gradient (inference mode)
         with torch.no_grad():
             # Forward pass
-            outputs = model( in
+            outputs = model(input_ids, attention_mask)
+            # Konversi logits ke probabilitas dengan softmax
+            probs = F.softmax(outputs, dim=1).squeeze()
+            # Ambil indeks dengan probabilitas tertinggi
+            idx = torch.argmax(probs).item()
+            # Konversi indeks ke label sentimen
+            label = label_encoder.inverse_transform([idx])[0]
+            # Simpan hasil
+            results[aspek] = label
+
+    return results
+
+
+def predict_multi_aspect_batch(model, tokenizer, sentences, aspek_list, label_encoder, device, max_len, batch_size=None):
+    """
+    Melakukan prediksi sentimen untuk setiap aspek pada multiple kalimat menggunakan batch processing.
+    Lebih efisien untuk memproses banyak kalimat sekaligus.
+
+    Args:
+        model (nn.Module): Model ABSA yang sudah diload.
+        tokenizer (AutoTokenizer): Tokenizer IndoBERT.
+        sentences (list): List kalimat input.
+        aspek_list (list): Daftar aspek yang ingin diprediksi.
+        label_encoder (LabelEncoder): Encoder label.
+        device (torch.device): Device (cuda/cpu).
+        max_len (int): Panjang maksimum token.
+        batch_size (int, optional): Ukuran batch. Jika None, gunakan dari CONFIG.
+
+    Returns:
+        list: List of dict hasil prediksi [{aspek: label_sentimen}, ...].
+    """
+    # Set batch size dari CONFIG jika tidak diberikan
+    if batch_size is None:
+        batch_size = CONFIG.get("batch_size", 32)
+
+    # === BUAT DATASET DAN DATALOADER ===
+    # Dataset akan membuat kombinasi semua kalimat × semua aspek
+    dataset = ABSADataset(sentences, aspek_list, tokenizer, max_len)
+    dataloader = DataLoader(
+        dataset,
+        batch_size=batch_size,  # Process dalam batch untuk efisiensi
+        shuffle=False,          # Jangan shuffle untuk maintain urutan
+        num_workers=CONFIG.get("num_workers", 0)
+    )
+
+    # === INISIALISASI CONTAINER HASIL ===
+    num_sentences = len(sentences)
+    num_aspects = len(aspek_list)
+    # Buat matrix untuk menyimpan prediksi [num_sentences x num_aspects]
+    all_predictions = [[None] * num_aspects for _ in range(num_sentences)]
+
+    # === BATCH PREDICTION ===
+    model.eval()  # Set model ke evaluation mode
+    with torch.no_grad():  # Nonaktifkan gradient calculation
+        for batch in dataloader:
+            # Pindahkan batch ke device
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            sent_indices = batch['sent_idx'].numpy()
+            aspect_indices = batch['aspect_idx'].numpy()
+
+            # Forward pass untuk seluruh batch
+            outputs = model(input_ids, attention_mask)
+            # Konversi logits ke probabilitas
+            probs = F.softmax(outputs, dim=1)
+            # Ambil indeks prediksi tertinggi
+            pred_indices = torch.argmax(probs, dim=1).cpu().numpy()
+
+            # Konversi indeks ke label sentimen
+            labels = label_encoder.inverse_transform(pred_indices)
+
+            # Simpan hasil ke matrix sesuai indeks aslinya
+            for i, (sent_idx, aspect_idx, label) in enumerate(zip(sent_indices, aspect_indices, labels)):
+                all_predictions[sent_idx][aspect_idx] = label
+
+    # === KONVERSI KE FORMAT DICTIONARY ===
+    results = []
+    for predictions in all_predictions:
+        # Buat dict {aspek: label} untuk setiap kalimat
+        result_dict = {aspek: label for aspek,
+                       label in zip(aspek_list, predictions)}
+        results.append(result_dict)
+
+    return results

visualization.py

@@ -13,241 +13,135 @@ import plotly.express as px
 from config import ASPEK_COLUMNS
 
 
-# Palet warna kustom untuk setiap kategori sentimen
+# Palet warna kustom
 sentimen_palette = {
-    "netral": "#FFE24C",    # Kuning untuk netral
-    "positif": "#4CFF72",   # Hijau untuk positif
-    "negatif": "#FF4C4C"    # Merah untuk negatif
+    "netral": "#FFE24C",
+    "positif": "#4CFF72",
+    "negatif": "#FF4C4C"
 }
-
-# Urutan kategori sentimen untuk konsistensi visualisasi
 category_order = ["netral", "positif", "negatif"]
 
-# Konfigurasi Plotly untuk interaktivitas chart
+# Konfigurasi Plotly
 config_options = {
-    "scrollZoom": False,      # Nonaktifkan zoom dengan scroll
-    "displayModeBar": False   # Sembunyikan toolbar Plotly
+    "scrollZoom": False,
+    "displayModeBar": False
 }
 
 
 def show_sentiment_bar_chart(df_predicted, aspek_columns):
-    """
-    Menampilkan bar chart distribusi sentimen per aspek.
-    Chart menampilkan jumlah setiap sentimen (positif/netral/negatif) untuk setiap aspek.
-    
-    Args:
-        df_predicted (pd.DataFrame): DataFrame dengan hasil prediksi sentimen
-        aspek_columns (list): List nama kolom aspek yang akan divisualisasikan
-    """
-    # Validasi: cek apakah data dan kolom aspek tersedia
+    """Menampilkan bar chart distribusi sentimen per aspek."""
     if df_predicted.empty or not set(aspek_columns).issubset(df_predicted.columns):
         st.warning("Data atau kolom aspek tidak tersedia untuk ditampilkan.")
         return
 
-    # Transform data dari wide format ke long format untuk visualisasi
     df_long = df_predicted.melt(
         value_vars=aspek_columns,
         var_name="aspek",
         value_name="sentimen"
     )
-
-    # Konversi sentimen ke categorical untuk sorting yang konsisten
     df_long["sentimen"] = pd.Categorical(
         df_long["sentimen"],
         categories=category_order,
         ordered=True
     )
-
-    # Hitung jumlah setiap kombinasi aspek-sentimen
     count_data = df_long.groupby(
         ["aspek", "sentimen"], observed=False
     ).size().reset_index(name="jumlah")
-
-    # Buat bar chart dengan Plotly
     fig = px.bar(
         count_data,
         x="aspek",
         y="jumlah",
         color="sentimen",
-        barmode="group",  # Bar dikelompokkan berdampingan
+        barmode="group",
         color_discrete_map=sentimen_palette,
         category_orders={"sentimen": category_order}
     )
     fig.update_layout(title="Distribusi Sentimen per Aspek")
-
-    # Tampilkan chart di Streamlit
     st.plotly_chart(fig, use_container_width=True, config=config_options)
 
 
 def show_sentiment_pie_chart(df_predicted, aspek_columns):
-    """
-    Menampilkan pie chart distribusi total sentimen dari semua aspek.
-    Chart menampilkan proporsi keseluruhan sentimen dalam bentuk donut chart.
-    
-    Args:
-        df_predicted (pd.DataFrame): DataFrame dengan hasil prediksi sentimen
-        aspek_columns (list): List nama kolom aspek
-    """
-    # Flatten semua nilai sentimen dari semua aspek menjadi satu array
+    """Menampilkan pie chart distribusi total sentimen."""
     sentimen_total = df_predicted[aspek_columns].values.ravel()
-
-    # Hitung frekuensi setiap sentimen
     sentimen_counts = pd.Series(sentimen_total).value_counts().reset_index()
     sentimen_counts.columns = ["sentimen", "jumlah"]
     sentimen_counts = sentimen_counts.sort_values("jumlah", ascending=False)
-
-    # Buat pie chart (donut chart dengan hole=0.3)
-    fig = px.pie(
-        sentimen_counts,
-        names="sentimen",
-        values="jumlah",
-        color="sentimen",
-        color_discrete_map=sentimen_palette,
-        hole=0.3  # Buat donut chart
-    )
+    fig = px.pie(sentimen_counts, names="sentimen", values="jumlah",
+                 color="sentimen", color_discrete_map=sentimen_palette,
+                 hole=0.3)
     fig.update_layout(title="Total Komposisi Sentimen")
-
-    # Tampilkan persentase dan label di dalam chart
     fig.update_traces(textposition='inside', textinfo='percent+label')
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
 
 
 def show_year_distribution(df):
-    """
-    Menampilkan distribusi jumlah kritik/saran per tahun.
-    Jika kolom 'tahun' tidak ada, akan mencoba ekstrak dari kolom 'tanggal'.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Coba ekstrak tahun dari kolom tanggal jika kolom tahun tidak ada
+    """Menampilkan distribusi jumlah kritik/saran per tahun."""
+    # Coba ekstrak dari kolom tanggal jika ada
     if 'tanggal' in df.columns and 'tahun' not in df.columns:
         df['tahun'] = pd.to_datetime(df['tanggal'], errors='coerce').dt.year
 
-    # Validasi: return None jika tidak ada kolom tahun
     if 'tahun' not in df.columns:
-        return None
+        return None  # Return None jika tidak ada kolom tahun
 
-    # Filter data yang memiliki nilai tahun valid
     df_tahun = df.dropna(subset=['tahun']).copy()
     if df_tahun.empty:
         return None
 
-    # Konversi tahun ke integer
     df_tahun['tahun'] = df_tahun['tahun'].astype(int)
-
-    # Hitung frekuensi per tahun
     year_counts = df_tahun['tahun'].value_counts().reset_index()
     year_counts.columns = ['tahun', 'jumlah']
     year_counts = year_counts.sort_values('jumlah', ascending=False)
 
-    # Buat bar chart
-    fig = px.bar(
-        year_counts,
-        x='tahun',
-        y='jumlah',
-        color='tahun',
-        title="Distribusi Kritik/Saran per Tahun"
-    )
-    # Treat tahun sebagai kategori untuk menghindari interpolasi
+    fig = px.bar(year_counts, x='tahun', y='jumlah',
+                 color='tahun', title="Distribusi Kritik/Saran per Tahun")
     fig.update_layout(xaxis=dict(type='category'))
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_semester_distribution(df):
-    """
-    Menampilkan distribusi jumlah kritik/saran per semester.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Validasi: cek apakah kolom semester ada
+    """Menampilkan distribusi jumlah kritik/saran per semester."""
     if 'semester' not in df.columns:
         return None
 
-    # Hitung frekuensi per semester
     semester_counts = df['semester'].value_counts().reset_index()
     semester_counts.columns = ['semester', 'jumlah']
     semester_counts = semester_counts.sort_values('jumlah', ascending=False)
-
-    # Buat bar chart
-    fig = px.bar(
-        semester_counts,
-        x='semester',
-        y='jumlah',
-        color='semester',
-        title="Distribusi Kritik/Saran per Semester"
-    )
-    # Sort berdasarkan total descending
+    fig = px.bar(semester_counts, x='semester', y='jumlah',
+                 color='semester', title="Distribusi Kritik/Saran per Semester")
     fig.update_layout(xaxis=dict(categoryorder='total descending'))
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_prodi_distribution(df):
-    """
-    Menampilkan jumlah kritik/saran per program studi dalam bentuk horizontal bar chart.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Validasi: cek apakah kolom nama_prodi ada
+    """Menampilkan jumlah kritik/saran per program studi."""
     if 'nama_prodi' not in df.columns:
         return None
 
-    # Hitung frekuensi per program studi
     prodi_counts = df['nama_prodi'].value_counts().reset_index()
     prodi_counts.columns = ['nama_prodi', 'jumlah']
-
-    # Sort ascending untuk horizontal bar (terbanyak di atas)
     prodi_counts = prodi_counts.sort_values(by='jumlah', ascending=True)
-
-    # Buat horizontal bar chart
     fig = px.bar(
         prodi_counts,
         x='jumlah',
         y='nama_prodi',
-        orientation='h',  # Horizontal orientation
+        orientation='h',
         color='jumlah',
         title="Jumlah Kritik/Saran per Program Studi"
     )
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_top10_matkul_distribution(df):
-    """
-    Menampilkan 10 mata kuliah dengan jumlah kritik/saran terbanyak.
-    Format: [kode_matakuliah] - [nama_matakuliah]
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Validasi: cek apakah kolom yang diperlukan ada
+    """Menampilkan 10 mata kuliah dengan jumlah kritik/saran terbanyak."""
     required_cols = ['nama_matakuliah', 'kode_matakuliah']
     missing_cols = [col for col in required_cols if col not in df.columns]
 
     if missing_cols:
         return None
 
-    # Group by kode dan nama mata kuliah, ambil 10 teratas
     matkul_counts = (
         df.groupby(['kode_matakuliah', 'nama_matakuliah'], observed=False)
         .size()
@@ -255,17 +149,12 @@ def show_top10_matkul_distribution(df):
         .sort_values(by='jumlah', ascending=False)
         .head(10)
     )
-
-    # Buat label gabungan: "kode - nama"
     matkul_counts['label'] = (
         matkul_counts['kode_matakuliah'] + " - " +
         matkul_counts['nama_matakuliah']
     )
-
-    # Sort ascending untuk horizontal bar (terbanyak di atas)
     matkul_counts = matkul_counts.sort_values(by='jumlah', ascending=True)
 
-    # Buat horizontal bar chart
     fig = px.bar(
         matkul_counts,
         x='jumlah',
@@ -274,124 +163,60 @@ def show_top10_matkul_distribution(df):
         title="Top 10 Mata Kuliah Berdasarkan Kritik/Saran",
         color='jumlah'
     )
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_sentiment_by_year(df, aspek_columns):
-    """
-    Menampilkan distribusi sentimen per tahun dalam bentuk grouped bar chart.
-    Menunjukkan bagaimana sentimen berubah dari tahun ke tahun.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        aspek_columns (list): List nama kolom aspek
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Coba ekstrak tahun dari kolom tanggal jika kolom tahun tidak ada
+    """Menampilkan distribusi sentimen per tahun."""
+    # Coba ekstrak dari kolom tanggal jika ada
     if 'tanggal' in df.columns and 'tahun' not in df.columns:
         df['tahun'] = pd.to_datetime(df['tanggal'], errors='coerce').dt.year
 
-    # Validasi: return None jika tidak ada kolom tahun
     if 'tahun' not in df.columns:
         return None
 
-    # Transform data dari wide ke long format, keep tahun sebagai ID variable
-    df_long = df.melt(
-        id_vars=['tahun'],
-        value_vars=aspek_columns,
-        var_name='aspek',
-        value_name='sentimen'
-    )
-
-    # Group by tahun dan sentimen, hitung frekuensi
+    df_long = df.melt(id_vars=['tahun'],
+                      value_vars=aspek_columns,
+                      var_name='aspek',
+                      value_name='sentimen')
     year_sentiment = df_long.groupby(
         ['tahun', 'sentimen'], observed=False
     ).size().reset_index(name='jumlah')
-
     year_sentiment = year_sentiment.sort_values('jumlah', ascending=False)
-
-    # Buat grouped bar chart
-    fig = px.bar(
-        year_sentiment,
-        x='tahun',
-        y='jumlah',
-        color='sentimen',
-        barmode='group',  # Bars dikelompokkan per tahun
-        color_discrete_map=sentimen_palette
-    )
+    fig = px.bar(year_sentiment, x='tahun', y='jumlah', color='sentimen',
+                 barmode='group', color_discrete_map=sentimen_palette)
     fig.update_layout(title="Distribusi Sentimen Kritik/Saran per Tahun")
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_sentiment_by_semester(df, aspek_columns):
-    """
-    Menampilkan distribusi sentimen per semester dalam bentuk grouped bar chart.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        aspek_columns (list): List nama kolom aspek
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Validasi: cek apakah kolom semester ada
+    """Menampilkan distribusi sentimen per semester."""
     if 'semester' not in df.columns:
         return None
 
-    # Transform data dari wide ke long format, keep semester sebagai ID variable
-    df_long = df.melt(
-        id_vars=['semester'],
-        value_vars=aspek_columns,
-        var_name='aspek',
-        value_name='sentimen'
-    )
-
-    # Group by semester dan sentimen, hitung frekuensi
+    df_long = df.melt(id_vars=['semester'],
+                      value_vars=aspek_columns,
+                      var_name='aspek',
+                      value_name='sentimen')
     semester_sentiment = df_long.groupby(
         ['semester', 'sentimen'], observed=False
     ).size().reset_index(name='jumlah')
-
     semester_sentiment = semester_sentiment.sort_values(
         'jumlah', ascending=False)
-
-    # Buat grouped bar chart
-    fig = px.bar(
-        semester_sentiment,
-        x='semester',
-        y='jumlah',
-        color='sentimen',
-        barmode='group',  # Bars dikelompokkan per semester
-        color_discrete_map=sentimen_palette
-    )
+    fig = px.bar(semester_sentiment, x='semester', y='jumlah', color='sentimen',
+                 barmode='group', color_discrete_map=sentimen_palette)
     fig.update_layout(title="Distribusi Sentimen Kritik/Saran per Semester")
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_sentiment_by_prodi(df, aspek_columns):
-    """
-    Menampilkan distribusi sentimen per program studi dalam horizontal grouped bar chart.
-    Program studi diurutkan berdasarkan total jumlah kritik/saran.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        aspek_columns (list): List nama kolom aspek
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Validasi: cek apakah kolom nama_prodi ada
+    """Menampilkan distribusi sentimen per program studi."""
     if 'nama_prodi' not in df.columns:
         return None
 
-    # Transform data dari wide ke long format
     df_long = df.melt(
         id_vars=['nama_prodi'],
         value_vars=aspek_columns,
@@ -399,72 +224,51 @@ def show_sentiment_by_prodi(df, aspek_columns):
         value_name='sentimen'
     )
 
-    # Group by prodi dan sentimen, hitung frekuensi
     prodi_sentiment = (
         df_long.groupby(['nama_prodi', 'sentimen'], observed=False)
         .size()
         .reset_index(name='jumlah')
     )
 
-    # Hitung total per prodi untuk sorting
     total_per_prodi = (
         prodi_sentiment.groupby('nama_prodi')['jumlah']
         .sum()
         .sort_values(ascending=False)
     )
-
-    # Reverse order untuk horizontal bar (terbanyak di atas)
     ordered_categories = total_per_prodi.index.tolist()[::-1]
 
-    # Konversi ke categorical untuk maintain order
     prodi_sentiment['nama_prodi'] = pd.Categorical(
         prodi_sentiment['nama_prodi'],
         categories=ordered_categories,
         ordered=True
     )
 
-    # Buat horizontal grouped bar chart
     fig = px.bar(
         prodi_sentiment,
         y='nama_prodi',
         x='jumlah',
         color='sentimen',
         barmode='group',
-        orientation='h',  # Horizontal orientation
+        orientation='h',
         color_discrete_map=sentimen_palette
     )
     fig.update_layout(
         title="Distribusi Sentimen per Program Studi",
-        yaxis={
-            'categoryorder': 'array',
-            'categoryarray': ordered_categories
-        }
+        yaxis={'categoryorder': 'array',
+               'categoryarray': ordered_categories}
     )
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
 
 
 def show_sentiment_by_top10_matkul(df, aspek_columns):
-    """
-    Menampilkan distribusi sentimen pada 10 mata kuliah dengan kritik/saran terbanyak.
-    Chart menggunakan horizontal grouped bar, diurutkan berdasarkan total kritik/saran.
-    
-    Args:
-        df (pd.DataFrame): DataFrame input
-        aspek_columns (list): List nama kolom aspek
-        
-    Returns:
-        bool/None: True jika berhasil, None jika kolom tidak tersedia
-    """
-    # Validasi: cek apakah kolom yang diperlukan ada
+    """Menampilkan distribusi sentimen pada 10 mata kuliah teratas."""
     required_cols = ['kode_matakuliah', 'nama_matakuliah']
     missing_cols = [col for col in required_cols if col not in df.columns]
 
     if missing_cols:
         return None
 
-    # Identifikasi top 10 mata kuliah berdasarkan jumlah kritik/saran
     df_top10 = (
         df.groupby(['kode_matakuliah', 'nama_matakuliah'], observed=False)
         .size()
@@ -473,11 +277,9 @@ def show_sentiment_by_top10_matkul(df, aspek_columns):
         .index
     )
 
-    # Filter data hanya untuk top 10 mata kuliah
     df_filtered = df[df.set_index(
         ['kode_matakuliah', 'nama_matakuliah']).index.isin(df_top10)]
 
-    # Transform data dari wide ke long format
     df_long = df_filtered.melt(
         id_vars=['kode_matakuliah', 'nama_matakuliah'],
         value_vars=aspek_columns,
@@ -485,36 +287,29 @@ def show_sentiment_by_top10_matkul(df, aspek_columns):
         value_name='sentimen'
     )
 
-    # Buat label gabungan: "kode - nama"
     df_long['label'] = (
         df_long['kode_matakuliah'] + " - " + df_long['nama_matakuliah']
     )
 
-    # Group by label dan sentimen, hitung frekuensi
     matkul_sentiment = (
         df_long.groupby(['label', 'sentimen'], observed=False)
         .size()
         .reset_index(name='jumlah')
     )
 
-    # Hitung total per label untuk sorting
     total_per_label = (
         matkul_sentiment.groupby('label')['jumlah']
         .sum()
         .sort_values(ascending=False)
     )
-
-    # Reverse order untuk horizontal bar (terbanyak di atas)
     ordered_labels = total_per_label.index.tolist()[::-1]
 
-    # Konversi ke categorical untuk maintain order
     matkul_sentiment['label'] = pd.Categorical(
         matkul_sentiment['label'],
         categories=ordered_labels,
         ordered=True
     )
 
-    # Buat horizontal grouped bar chart
     fig = px.bar(
         matkul_sentiment,
         y='label',
@@ -526,11 +321,48 @@ def show_sentiment_by_top10_matkul(df, aspek_columns):
     )
     fig.update_layout(
         title="Distribusi Sentimen pada Top 10 Mata Kuliah",
-        yaxis={
-            'categoryorder': 'array',
-            'categoryarray': ordered_labels
-        }
+        yaxis={'categoryorder': 'array', 'categoryarray': ordered_labels}
     )
-
     st.plotly_chart(fig, use_container_width=True, config=config_options)
     return True
+
+
+def show_sentiment_stacked_percentage(df, aspek_columns):
+    """Menampilkan stacked bar chart dengan persentase sentimen per aspek."""
+
+    if df.empty or not set(aspek_columns).issubset(df.columns):
+        st.warning("Data atau kolom aspek tidak tersedia.")
+        return
+
+    df_long = df.melt(
+        value_vars=aspek_columns,
+        var_name="aspek",
+        value_name="sentimen"
+    )
+
+    # Hitung persentase
+    count_data = df_long.groupby(
+        ['aspek', 'sentimen']).size().reset_index(name='jumlah')
+    total_per_aspek = count_data.groupby('aspek')['jumlah'].sum().reset_index()
+    total_per_aspek.columns = ['aspek', 'total']
+    count_data = count_data.merge(total_per_aspek, on='aspek')
+    count_data['persentase'] = (
+        count_data['jumlah'] / count_data['total']) * 100
+
+    fig = px.bar(
+        count_data,
+        x="aspek",
+        y="persentase",
+        color="sentimen",
+        title="Persentase Distribusi Sentimen per Aspek",
+        color_discrete_map=sentimen_palette,
+        category_orders={
+            "sentimen": category_order,
+            "aspek": aspek_columns
+        }
+    )
+    fig.update_layout(
+        yaxis_title="Persentase (%)",
+        xaxis_title="Aspek"
+    )
+    st.plotly_chart(fig, use_container_width=True, config=config_options)