merapikan file, menambahkan komentar penting pada config.py, preprocessing.py, visualization.py, dan app.py

app.py

@@ -6,6 +6,8 @@ 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
@@ -36,41 +38,48 @@ from visualization import (
 from preprocessing import text_preprocessing_pipeline
 
 # Konfigurasi untuk chunked processing
-CHUNK_SIZE = 2500
-ENABLE_CHUNKED = True
-CACHE_EXPIRY_HOURS = 24
+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
 
+# Membuat direktori cache jika belum ada
 os.makedirs("chache_file", exist_ok=True)
 os.makedirs("chache_file/sessions", exist_ok=True)
 
-# Konfigurasi halaman
+# Konfigurasi halaman Streamlit
 st.set_page_config(
     page_title="ABSA IndoBERT",
     layout="wide",
     page_icon="💬"
 )
 
-# Load custom CSS
+# Load custom CSS untuk styling
 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"""
+    """
+    Generate atau retrieve session ID untuk user - PERSISTENT across refresh
+    Menggunakan query params agar session tetap konsisten saat 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
@@ -92,7 +101,10 @@ def get_session_chunks_dir():
 
 
 def cleanup_old_sessions():
-    """Hapus session cache yang sudah expired (> 24 jam)"""
+    """
+    Hapus session cache yang sudah expired (> 24 jam)
+    Membersihkan cache lama untuk menghemat storage
+    """
     sessions_dir = Path("chache_file/sessions")
     if not sessions_dir.exists():
         return
@@ -103,6 +115,7 @@ 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)
@@ -111,18 +124,24 @@ 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."""
+    """
+    Memuat model dan tokenizer IndoBERT
+    Menggunakan cache agar model tidak dimuat ulang setiap kali
+    """
     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)
@@ -130,7 +149,7 @@ success_placeholder.empty()
 
 
 def convert_df_to_excel(df):
-    """Mengubah DataFrame menjadi file Excel dalam bentuk byte stream."""
+    """Mengubah DataFrame menjadi file Excel dalam bentuk byte stream untuk download"""
     output = BytesIO()
     with pd.ExcelWriter(output, engine="openpyxl") as writer:
         df.to_excel(writer, index=False)
@@ -138,7 +157,7 @@ def convert_df_to_excel(df):
 
 
 def clear_memory():
-    """Clear memory cache"""
+    """Clear memory cache untuk menghemat RAM dan VRAM"""
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
@@ -146,8 +165,20 @@ 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.
-    Progress bar: Preprocessing 0-100%, lalu Predicting 0-100%
+    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
     """
     # STEP 1: Preprocessing (0-100%)
     cleaned_text_list = []
@@ -157,6 +188,7 @@ 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)
@@ -174,6 +206,7 @@ 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(
@@ -183,11 +216,13 @@ 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:
@@ -196,15 +231,18 @@ 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)
@@ -216,12 +254,14 @@ 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)
@@ -230,13 +270,17 @@ 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"""
+    """
+    Deteksi kolom-kolom yang tersedia dalam dataframe
+    Untuk menentukan visualisasi mana yang bisa ditampilkan
+    """
     available = {
         'has_tahun': 'tahun' in df.columns or 'tanggal' in df.columns,
         'has_semester': 'semester' in df.columns,
@@ -246,6 +290,8 @@ def get_available_columns(df):
     return available
 
 
+# ================== BAGIAN UI UTAMA ==================
+
 # Judul aplikasi
 st.markdown("""
     <h1 class='title-center'>ABSA IndoBERT</h1>
@@ -257,7 +303,7 @@ st.markdown(" ")
 st.markdown(" ")
 st.markdown(" ")
 
-# Panduan pengunaan
+# Panduan penggunaan aplikasi
 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`."},
@@ -269,6 +315,7 @@ 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):
@@ -284,18 +331,19 @@ for i, step in enumerate(steps):
 st.markdown("")
 st.markdown("")
 
-# Upload file
+# Upload file Excel
 uploaded_file = st.file_uploader(
     " Upload Data Kritik & Saran",
     type=["xlsx"],
     help="File maksimal 200MB dengan format .xlsx"
 )
 
-# Clear cache buttons - SESSION SPECIFIC
+# Tombol untuk menghapus cache (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()
@@ -303,6 +351,7 @@ 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:
@@ -314,6 +363,7 @@ 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"
@@ -334,13 +384,15 @@ 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')
@@ -350,14 +402,20 @@ 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')
@@ -365,11 +423,15 @@ 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
@@ -379,9 +441,11 @@ 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")
@@ -398,6 +462,7 @@ 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(
@@ -406,6 +471,7 @@ 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)
@@ -424,6 +490,7 @@ if uploaded_file:
                             time.sleep(0.3)
                             continue
 
+                        # Proses chunk baru
                         chunk_progress_bar.progress(0)
 
                         chunk_result = process_chunk_batch(
@@ -432,6 +499,7 @@ 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
@@ -446,6 +514,7 @@ if uploaded_file:
 
                         time.sleep(0.3)
 
+                    # Gabungkan semua chunk
                     chunk_status_text.empty()
                     overall_status.info("🔄 Menggabungkan semua chunks...")
                     df_session = pd.concat(
@@ -455,6 +524,7 @@ 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")
@@ -464,6 +534,7 @@ if uploaded_file:
                     progress_bar = st.progress(0)
                     status_text = st.empty()
 
+                    # Preprocessing
                     cleaned_text_list = []
                     total_preprocessing = len(df_uploaded)
 
@@ -481,6 +552,7 @@ 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)
@@ -520,6 +592,7 @@ 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()
@@ -539,16 +612,20 @@ 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"
@@ -568,14 +645,14 @@ if uploaded_file:
                         f"- Waktu: **{duration:.2f}** detik (~{items_per_second:.1f} prediksi/detik)"
                     )
 
-# Setelah prediksi selesai
+# ================== TAMPILAN HASIL & VISUALISASI ==================
 if st.session_state.df_predicted is not None:
     df_predicted = st.session_state.df_predicted
 
-    # Deteksi kolom yang tersedia
+    # Deteksi kolom yang tersedia dalam dataframe
     available_cols = get_available_columns(df_predicted)
 
-    # Sidebar filter dengan pengecekan kolom dinamis
+    # ============ SIDEBAR FILTER ============
     st.sidebar.header("Filter Data")
 
     df_clean = df_predicted.copy()
@@ -587,7 +664,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
+    # Filter Mata Kuliah (jika ada)
     selected_matkul = []
     if available_cols['has_matkul']:
         matkul_options = sorted(
@@ -596,7 +673,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
+    # Filter Program Studi (jika ada)
     selected_prodi = []
     if available_cols['has_prodi']:
         prodi_options = sorted(
@@ -605,9 +682,10 @@ if st.session_state.df_predicted is not None:
             selected_prodi = st.sidebar.multiselect(
                 "Program Studi", prodi_options, default=prodi_options)
 
-    # Filter Tahun
+    # Filter Tahun (jika ada)
     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
@@ -618,7 +696,7 @@ if st.session_state.df_predicted is not None:
                 selected_tahun = st.sidebar.multiselect(
                     "Tahun", tahun_options, default=tahun_options)
 
-    # Filter Semester
+    # Filter Semester (jika ada)
     selected_semester = []
     if available_cols['has_semester']:
         semester_options = sorted(
@@ -627,7 +705,7 @@ if st.session_state.df_predicted is not None:
             selected_semester = st.sidebar.multiselect(
                 "Semester", semester_options, default=semester_options)
 
-    # Apply filters
+    # Apply semua filter yang dipilih
     df_filtered = df_clean.copy()
 
     if selected_matkul and available_cols['has_matkul']:
@@ -636,123 +714,130 @@ 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_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."
-    )
-
-    # Ringkasan Cepat
-    st.markdown("")
-    st.markdown("### Ringkasan Cepat")
-    st.markdown("")
-
-    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()
-
-    # Hitung jumlah kolom yang tersedia untuk ringkasan
-    summary_cols = []
-
-    # 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')
-
-    # Buat kolom dinamis berdasarkan data yang tersedia
-    num_cols = len(summary_cols)
-    cols = st.columns(num_cols)
-
-    col_idx = 0
-
-    # 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
+            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')
 
-    # 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
+            # Buat kolom dinamis berdasarkan jumlah metrik
+            num_cols=len(summary_cols)
+            cols=st.columns(num_cols)
 
-    # 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
+            col_idx=0
 
-    # 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
+            # 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
 
-    st.markdown("")
+            # 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
 
-    # Baris kedua: Sentimen + info tambahan
-    summary_cols2 = ['positif', 'netral', 'negatif']
+            # 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
 
-    if available_cols['has_tahun']:
-        summary_cols2.append('tahun')
-    if 'kritik_saran' in df_filtered.columns:
-        summary_cols2.append('kata')
+            # 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
 
-    cols2 = st.columns(len(summary_cols2))
+            st.markdown("")
 
-    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
+            # Baris kedua: Sentimen + info tambahan
+            summary_cols2=['positif', 'netral', 'negatif']
 
-    # Rentang tahun (jika ada)
-    if available_cols['has_tahun']:
-        if 'tahun' in df_filtered.columns:
-            tahun_valid = df_filtered['tahun'].dropna()
+            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()
             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:
@@ -760,89 +845,95 @@ 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
 
-    # 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(
+            # 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(
                 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")
 
-    st.markdown("---")
-    st.markdown("### Visualisasi Data")
+            # ============ VISUALISASI DATA ============
+            st.markdown("---")
+            st.markdown("### Visualisasi Data")
 
-    # 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 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 berdasarkan kolom yang tersedia
-    viz_shown = False
+            # Visualisasi berdasarkan kolom yang tersedia
+            viz_shown=False
 
-    if available_cols['has_tahun'] or available_cols['has_semester']:
-        col1, col2 = st.columns(2)
-        with col1:
+            # 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']:
-                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
-
-    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:
+                    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:
             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
-
-    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("""
+                    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("""
     <div class='footer'>
-        © 2025 Darmawan Jiddan | Dibuat dengan ❤️ menggunakan Streamlit 
+        © 2025 Darmawan Jiddan | Dibuat dengan ❤️ menggunakan Streamlit
     </div>
 """, unsafe_allow_html=True)

config.py

@@ -12,7 +12,6 @@ CONFIG = {
     "hf_model_repo": "zdannn2808/absa_indobert",
     "hf_model_subfolder": "Indobert_Model/model",
     "hf_tokenizer_subfolder": "Indobert_Model/tokenizer",
-    # ✅ TAMBAHAN: Konfigurasi untuk batch processing
     "batch_size": 32,  # Ukuran batch untuk prediksi
     "num_workers": 0,  # Jumlah worker untuk DataLoader (0 = main process only)
 }

preprocessing.py

@@ -7,9 +7,11 @@ Modul untuk preprocessing teks sebelum prediksi ABSA
 import re
 import string
 
-# ✅ TAMBAHKAN INI - Download NLTK data jika diperlukan
+# === SETUP NLTK (OPTIONAL) ===
+# Download NLTK data jika diperlukan untuk tokenisasi advanced
 try:
     import nltk
+    # Cek apakah punkt tokenizer sudah terinstall
     try:
         nltk.data.find('tokenizers/punkt')
     except LookupError:
@@ -17,16 +19,18 @@ try:
         nltk.download('punkt', quiet=True)
         print("✅ NLTK punkt downloaded")
 
-    # Tambahan: cek punkt_tab kalau memang diperlukan oleh versi NLTK terbaru
+    # Cek punkt_tab untuk versi NLTK terbaru
     try:
         nltk.data.find('tokenizers/punkt_tab')
     except LookupError:
         nltk.download('punkt_tab', quiet=True)
 except ImportError:
+    # Jika NLTK tidak terinstall, gunakan tokenizer sederhana
     print("⚠️ NLTK tidak terinstall, menggunakan tokenizer sederhana")
 
 
-# Stopwords Indonesia
+# === STOPWORDS BAHASA INDONESIA ===
+# Daftar kata yang tidak memiliki makna signifikan dan dapat dihapus
 INDONESIAN_STOPWORDS = set([
     'ada', 'adalah', 'adanya', 'adapun', 'agak', 'agaknya', 'agar', 'akan', 'akankah', 'akhir',
     'akhiri', 'akhirnya', 'aku', 'akulah', 'amat', 'amatlah', 'anda', 'andalah', 'antar', 'antara',
@@ -124,20 +128,23 @@ INDONESIAN_STOPWORDS = set([
 
 def simple_tokenize(text):
     """
-    Tokenizer sederhana dengan split by whitespace
+    Tokenizer sederhana dengan split by whitespace.
+    Digunakan sebagai alternatif jika NLTK tidak tersedia.
     
     Args:
         text (str): Teks input
         
     Returns:
-        list: List of tokens
+        list: List of tokens (kata-kata)
     """
+    # Split teks berdasarkan spasi
     return text.split()
 
 
 def remove_emoji(text):
     """
-    Menghapus emoji dari teks
+    Menghapus emoji dari teks menggunakan regex pattern.
+    Emoji dapat mengganggu analisis sentimen karena tidak diproses model.
     
     Args:
         text (str): Teks input
@@ -145,23 +152,26 @@ def remove_emoji(text):
     Returns:
         str: Teks tanpa emoji
     """
+    # Pattern regex untuk mendeteksi berbagai range emoji Unicode
     emoji_pattern = re.compile(
         "["
-        "\U0001F600-\U0001F64F"  # emoticons
-        "\U0001F300-\U0001F5FF"  # symbols & pictographs
-        "\U0001F680-\U0001F6FF"  # transport & map symbols
-        "\U0001F1E0-\U0001F1FF"  # flags (iOS)
-        "\U00002702-\U000027B0"
-        "\U000024C2-\U0001F251"
+        "\U0001F600-\U0001F64F"  # Emoticons (😀-😯)
+        "\U0001F300-\U0001F5FF"  # Symbols & pictographs (🌀-🗿)
+        "\U0001F680-\U0001F6FF"  # Transport & map symbols (🚀-🛿)
+        "\U0001F1E0-\U0001F1FF"  # Flags (🇦-🇿)
+        "\U00002702-\U000027B0"  # Dingbats
+        "\U000024C2-\U0001F251"  # Enclosed characters
         "]+",
         flags=re.UNICODE,
     )
+    # Hapus semua emoji yang terdeteksi
     return emoji_pattern.sub(r"", text)
 
 
 def cleaning_text(text):
     """
-    Membersihkan teks dari karakter tidak perlu
+    Membersihkan teks dari berbagai elemen yang tidak diperlukan.
+    Proses: lowercase, hapus URL, mention, hashtag, email, angka, dan whitespace berlebih.
     
     Args:
         text (str): Teks input
@@ -169,36 +179,38 @@ def cleaning_text(text):
     Returns:
         str: Teks yang sudah dibersihkan
     """
+    # Pastikan input adalah string
     if not isinstance(text, str):
         text = str(text)
-    
-    # Lowercase
+
+    # Konversi ke lowercase untuk konsistensi
     text = text.lower()
-    
-    # Remove URL
+
+    # Hapus URL (http, https, www)
     text = re.sub(r'http\S+|www\S+|https\S+', '', text, flags=re.MULTILINE)
-    
-    # Remove mentions and hashtags
+
+    # Hapus mention (@username) dan hashtag (#topic)
     text = re.sub(r'@\w+|#\w+', '', text)
-    
-    # Remove email
+
+    # Hapus alamat email
     text = re.sub(r'\S+@\S+', '', text)
-    
-    # Remove numbers
+
+    # Hapus angka (bisa mengganggu analisis sentimen)
     text = re.sub(r'\d+', '', text)
-    
-    # Remove newlines and tabs
+
+    # Hapus newline, carriage return, dan tab
     text = text.replace('\n', ' ').replace('\r', ' ').replace('\t', ' ')
-    
-    # Remove extra whitespace
+
+    # Hapus extra whitespace (multiple spaces jadi single space)
     text = ' '.join(text.split())
-    
+
     return text
 
 
 def normalize_text(tokens):
     """
-    Normalisasi token: hapus punctuation dan stopwords
+    Normalisasi token: hapus punctuation, stopwords, dan filter token.
+    Token yang baik adalah yang bermakna dan membantu analisis sentimen.
     
     Args:
         tokens (list): List of tokens
@@ -206,42 +218,45 @@ def normalize_text(tokens):
     Returns:
         list: List of normalized tokens
     """
-    # Remove punctuation dari setiap token
-    tokens = [token.translate(str.maketrans('', '', string.punctuation)) for token in tokens]
-    
-    # Remove empty strings
+    # Hapus punctuation dari setiap token (.,!?;: dll)
+    tokens = [token.translate(str.maketrans(
+        '', '', string.punctuation)) for token in tokens]
+
+    # Hapus empty strings hasil penghapusan punctuation
     tokens = [token for token in tokens if token]
-    
-    # Remove stopwords
+
+    # Hapus stopwords (kata-kata umum yang tidak bermakna)
     tokens = [token for token in tokens if token not in INDONESIAN_STOPWORDS]
-    
-    # Remove single characters
+
+    # Hapus single character (biasanya tidak bermakna)
     tokens = [token for token in tokens if len(token) > 1]
-    
+
     return tokens
 
 
 def text_preprocessing_pipeline(text):
     """
-    Pipeline preprocessing lengkap: cleaning, emoji removal, tokenization, normalization
+    Pipeline preprocessing lengkap untuk teks sebelum prediksi ABSA.
+    Menggabungkan semua langkah preprocessing: cleaning -> emoji removal -> 
+    tokenization -> normalization.
     
     Args:
-        text (str): Teks input
+        text (str): Teks input mentah
         
     Returns:
-        str: Teks yang sudah dipreprocess
+        str: Teks yang sudah dipreprocess dan siap untuk model
     """
-    # Cleaning
+    # Step 1: Cleaning (lowercase, hapus URL, mention, dll)
     text = cleaning_text(text)
-    
-    # Remove emoji
+
+    # Step 2: Remove emoji
     text = remove_emoji(text)
-    
-    # Tokenize (simple split, no NLTK)
+
+    # Step 3: Tokenize (split menjadi kata-kata)
     tokens = simple_tokenize(text)
-    
-    # Normalize (remove stopwords, punctuation, etc)
+
+    # Step 4: Normalize (hapus stopwords, punctuation, dll)
     tokens = normalize_text(tokens)
-    
-    # Join back to string
-    return " ".join(tokens)
+
+    # Step 5: Join kembali menjadi string
+    return " ".join(tokens)

visualization.py

@@ -13,135 +13,241 @@ import plotly.express as px
 from config import ASPEK_COLUMNS
 
 
-# Palet warna kustom
+# Palet warna kustom untuk setiap kategori sentimen
 sentimen_palette = {
-    "netral": "#FFE24C",
-    "positif": "#4CFF72",
-    "negatif": "#FF4C4C"
+    "netral": "#FFE24C",    # Kuning untuk netral
+    "positif": "#4CFF72",   # Hijau untuk positif
+    "negatif": "#FF4C4C"    # Merah untuk negatif
 }
+
+# Urutan kategori sentimen untuk konsistensi visualisasi
 category_order = ["netral", "positif", "negatif"]
 
-# Konfigurasi Plotly
+# Konfigurasi Plotly untuk interaktivitas chart
 config_options = {
-    "scrollZoom": False,
-    "displayModeBar": False
+    "scrollZoom": False,      # Nonaktifkan zoom dengan scroll
+    "displayModeBar": False   # Sembunyikan toolbar Plotly
 }
 
 
 def show_sentiment_bar_chart(df_predicted, aspek_columns):
-    """Menampilkan bar chart distribusi sentimen per aspek."""
+    """
+    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
     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",
+        barmode="group",  # Bar dikelompokkan berdampingan
         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."""
+    """
+    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
     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)
-    fig = px.pie(sentimen_counts, names="sentimen", values="jumlah",
-                 color="sentimen", color_discrete_map=sentimen_palette,
-                 hole=0.3)
+
+    # 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.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."""
-    # Coba ekstrak dari kolom tanggal jika ada
+    """
+    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
     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 jika tidak ada kolom tahun
+        return None
 
+    # 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)
 
-    fig = px.bar(year_counts, x='tahun', y='jumlah',
-                 color='tahun', title="Distribusi Kritik/Saran per Tahun")
+    # 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.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."""
+    """
+    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
     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)
-    fig = px.bar(semester_counts, x='semester', y='jumlah',
-                 color='semester', title="Distribusi Kritik/Saran per Semester")
+
+    # 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.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."""
+    """
+    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
     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',
+        orientation='h',  # Horizontal orientation
         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."""
+    """
+    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
     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()
@@ -149,12 +255,17 @@ 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',
@@ -163,60 +274,124 @@ 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."""
-    # Coba ekstrak dari kolom tanggal jika ada
+    """
+    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
     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
 
-    df_long = df.melt(id_vars=['tahun'],
-                      value_vars=aspek_columns,
-                      var_name='aspek',
-                      value_name='sentimen')
+    # 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
     year_sentiment = df_long.groupby(
         ['tahun', 'sentimen'], observed=False
     ).size().reset_index(name='jumlah')
+
     year_sentiment = year_sentiment.sort_values('jumlah', ascending=False)
-    fig = px.bar(year_sentiment, x='tahun', y='jumlah', color='sentimen',
-                 barmode='group', color_discrete_map=sentimen_palette)
+
+    # 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.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."""
+    """
+    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
     if 'semester' not in df.columns:
         return None
 
-    df_long = df.melt(id_vars=['semester'],
-                      value_vars=aspek_columns,
-                      var_name='aspek',
-                      value_name='sentimen')
+    # 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
     semester_sentiment = df_long.groupby(
         ['semester', 'sentimen'], observed=False
     ).size().reset_index(name='jumlah')
+
     semester_sentiment = semester_sentiment.sort_values(
         'jumlah', ascending=False)
-    fig = px.bar(semester_sentiment, x='semester', y='jumlah', color='sentimen',
-                 barmode='group', color_discrete_map=sentimen_palette)
+
+    # 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.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."""
+    """
+    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
     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,
@@ -224,51 +399,72 @@ 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',
+        orientation='h',  # Horizontal orientation
         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 teratas."""
+    """
+    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
     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()
@@ -277,9 +473,11 @@ 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,
@@ -287,29 +485,36 @@ 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',
@@ -321,48 +526,11 @@ 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}
-    )
-    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
+        yaxis={
+            'categoryorder': 'array',
+            'categoryarray': ordered_labels
         }
     )
-    fig.update_layout(
-        yaxis_title="Persentase (%)",
-        xaxis_title="Aspek"
-    )
+
     st.plotly_chart(fig, use_container_width=True, config=config_options)
+    return True