Upload 7 files

.gitattributes

@@ -0,0 +1 @@
+tools/isolation_forest.pkl filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.9-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN useradd -m -u 1000 user
+
+WORKDIR /home/user/app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user:user . .
+
+EXPOSE 7860
+
+USER user
+
+CMD ["python", "-m", "streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--browser.gatherUsageStats=false"]

app.py

@@ -0,0 +1,612 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import io
+import json
+from pathlib import Path
+import joblib
+import altair as alt
+
+# ── Setup ────────────────────────────────────────────────────────────────────
+st.set_page_config(page_title="THC Konsolidasi", layout="wide")
+st.title('📊 THC Konsolidasi - Proses Gabungan & Analisa Simpanan')
+st.divider()
+
+MODELS_DIR = Path(__file__).parent / 'tools'
+TOOLS_DIR = Path(__file__).parent / 'tools'
+
+# ── Define Column Structure ──────────────────────────────────────────────────
+DESIRED_ORDER = [
+    'ID ANGGOTA', 'NAMA', 'CENTER', 'KEL', 'HARI', 'JAM', 'SL', 'TRANS. DATE',
+    'Db Qurban', 'Cr Qurban', 'Db Khusus', 'Cr Khusus', 'Db HariRaya', 'Cr HariRaya',
+    'Db Pensiun', 'Cr Pensiun', 'Db Pokok', 'Cr Pokok', 'Db SIPADAN', 'Cr SIPADAN',
+    'Db Sukarela', 'Cr Sukarela', 'Db Wajib', 'Cr Wajib', 'Db Total', 'Cr Total',
+    'Db PTN', 'Cr PTN', 'Db PRT', 'Cr PRT', 'Db DTP', 'Cr DTP', 'Db PMB', 'Cr PMB',
+    'Db PRR', 'Cr PRR', 'Db PSA', 'Cr PSA', 'Db PU', 'Cr PU', 'Db Total2', 'Cr Total2'
+]
+
+ESTIMASI_COLS = [
+    'Estimasi Nominal Kecil Menabung', 'Estimasi Nominal Kecil Penarikan',
+    'Estimasi Uang', 'Estimasi Nabung 1', 'Estimasi Nabung 2', 'Estimasi Nabung 3',
+    'Estimasi Penarikan 1', 'Estimasi Penarikan 2', 'T/F 1', 'T/F2', 'Final Filter'
+]
+
+# ── Helper Functions ─────────────────────────────────────────────────────────
+
+@st.cache_data
+def load_models_and_metadata():
+    """Load scaler dan Isolation Forest model"""
+    try:
+        scaler_path = MODELS_DIR / 'scaler.pkl'
+        iso_path = MODELS_DIR / 'isolation_forest.pkl'
+        meta_path = TOOLS_DIR / 'metadata.json'
+        
+        if not scaler_path.exists() or not iso_path.exists():
+            return None, None, None
+        
+        scaler = joblib.load(scaler_path)
+        iso_forest = joblib.load(iso_path)
+        metadata = json.loads(meta_path.read_text()) if meta_path.exists() else {}
+        
+        return scaler, iso_forest, metadata
+    except Exception as e:
+        return None, None, None
+
+@st.cache_data
+def load_excel(file):
+    return pd.read_excel(file, engine='openpyxl')
+
+def process_dataframe(df, new_columns, rename_dict):
+    """Standardisasi nama dan kolom DataFrame"""
+    # Add missing columns
+    for col in new_columns:
+        if col not in df.columns:
+            df[col] = 0
+    
+    # Rename columns
+    df = df.rename(columns=rename_dict)
+    
+    # Standardize ID column
+    if 'ID ANGGOTA' not in df.columns and 'ID' in df.columns:
+        df = df.rename(columns={'ID': 'ID ANGGOTA'})
+    
+    # Standardize KEL column
+    if 'KEL' not in df.columns and 'KELOMPOK' in df.columns:
+        df = df.rename(columns={'KELOMPOK': 'KEL'})
+    
+    # Hilangkan duplikasi kolom
+    df = df.loc[:, ~df.columns.duplicated()]
+    
+    return df
+
+def detect_delimiter(buffer: io.BytesIO) -> str:
+    """Detect CSV delimiter"""
+    pos = buffer.tell()
+    first_line = buffer.readline().decode('utf-8', errors='ignore')
+    buffer.seek(pos)
+    counts = {'\t': first_line.count('\t'), ';': first_line.count(';'), ',': first_line.count(',')}
+    return max(counts, key=counts.get)
+
+def load_data(uploaded_file) -> pd.DataFrame:
+    """Load CSV/Excel file"""
+    try:
+        if uploaded_file.name.endswith(('.xlsx', '.xls')):
+            df = pd.read_excel(uploaded_file, engine='openpyxl')
+        else:
+            sep = detect_delimiter(uploaded_file)
+            df = pd.read_csv(uploaded_file, sep=sep)
+        return df
+    except Exception as e:
+        st.error(f"❌ Error loading file: {str(e)}")
+        return None
+
+# ── TAB 1 FUNCTIONS: PROSES GABUNGAN & FINAL ─────────────────────────────────
+
+def ambil_3_digit_akhir(val):
+    try:
+        if pd.isna(val):
+            return 0
+        return int(str(int(val))[-3:])
+    except Exception:
+        return 0
+
+def estimasi_uang(val):
+    try:
+        if pd.isna(val):
+            return 0
+        return int(np.ceil(val / 1000.0) * 1000)
+    except Exception:
+        return 0
+
+def estimasi_nabung_2(x):
+    return x - 500 if x > 500 else 0
+
+def estimasi_nabung_3(x):
+    return x + 500 if x < 500 else 0
+
+def tf_1(row):
+    if row["Estimasi Nabung 1"] < 500:
+        return (
+            (row["Estimasi Nabung 1"] == row["Estimasi Nominal Kecil Menabung"])
+            or (row["Estimasi Nabung 3"] == row["Estimasi Nominal Kecil Menabung"])
+        )
+    else:
+        return (
+            (row["Estimasi Nominal Kecil Menabung"] == row["Estimasi Nabung 1"])
+            or (row["Estimasi Nominal Kecil Menabung"] == row["Estimasi Nabung 2"])
+        )
+
+def estimasi_penarikan_2(x):
+    return x - 500 if x > 500 else 0
+
+def tf2(row):
+    if row["Estimasi Penarikan 1"] < 500:
+        return row["Estimasi Penarikan 1"] == row["Estimasi Nominal Kecil Penarikan"]
+    else:
+        return (
+            (row["Estimasi Nominal Kecil Penarikan"] == row["Estimasi Penarikan 1"])
+            or (row["Estimasi Nominal Kecil Penarikan"] == row["Estimasi Penarikan 2"])
+        )
+
+def final_filter(row):
+    return bool(row["T/F 1"] or row["T/F2"])
+
+def tambah_kolom_estimasi(df):
+    """Tambah kolom estimasi untuk anomali detection"""
+    df["Estimasi Nominal Kecil Menabung"] = df["Db Total"].apply(ambil_3_digit_akhir)
+    df["Estimasi Nominal Kecil Penarikan"] = df["Cr Total"].apply(ambil_3_digit_akhir)
+    df["Estimasi Uang"] = df["Db Total2"].apply(estimasi_uang)
+    df["Estimasi Nabung 1"] = df["Estimasi Uang"] - df["Db Total2"]
+    df["Estimasi Nabung 2"] = df["Estimasi Nabung 1"].apply(estimasi_nabung_2)
+    df["Estimasi Nabung 3"] = df["Estimasi Nabung 1"].apply(estimasi_nabung_3)
+    df["Estimasi Penarikan 1"] = df["Db Total2"].apply(ambil_3_digit_akhir)
+    df["Estimasi Penarikan 2"] = df["Estimasi Penarikan 1"].apply(estimasi_penarikan_2)
+    df["T/F 1"] = df.apply(tf_1, axis=1)
+    df["T/F2"] = df.apply(tf2, axis=1)
+    df["Final Filter"] = df.apply(final_filter, axis=1)
+    return df
+
+# ── TAB 2 FUNCTIONS: ANALISA SIMPANAN ────────────────────────────────────────
+
+def prepare_data_analisa(df_raw: pd.DataFrame) -> pd.DataFrame:
+    """Prepare data untuk analisa simpanan"""
+    try:
+        df = df_raw.copy()
+        col_mapping = {
+            'ID': 'ID ANGGOTA',
+            'KELOMPOK': 'KEL',
+            'Db Hariraya': 'Db HariRaya',
+            'Cr Hariraya': 'Cr HariRaya'
+        }
+        df = df.rename(columns=col_mapping)
+        
+        # Validasi kolom minimal
+        required_cols = ['ID ANGGOTA', 'NAMA', 'CENTER', 'Db Sukarela', 'Cr Sukarela', 'TRANS. DATE']
+        missing = [c for c in required_cols if c not in df.columns]
+        if missing:
+            raise ValueError(f"Kolom tidak ditemukan: {missing}")
+        
+        # Clean & convert
+        df['TRANS. DATE'] = pd.to_datetime(df['TRANS. DATE'], format='%d/%m/%Y', errors='coerce')
+        
+        # Extract date features
+        df['MINGGU'] = df['TRANS. DATE'].dt.isocalendar().week.astype(int)
+        df['TAHUN'] = df['TRANS. DATE'].dt.year
+        df['YEAR_WEEK'] = df['TAHUN'].astype(str) + '-W' + df['MINGGU'].astype(str).str.zfill(2)
+        
+        return df
+    except Exception as e:
+        st.error(f"❌ Error preparing data: {str(e)}")
+        return None
+
+def detect_hariraya_anomaly(df: pd.DataFrame, window: int = 3, threshold: float = 1.0) -> pd.DataFrame:
+    """Detect HariRaya savings anomalies using Rolling Z-Score"""
+    try:
+        weekly = (
+            df.groupby(['ID ANGGOTA', 'NAMA', 'CENTER', 'YEAR_WEEK'], as_index=False)
+            .agg({'Db HariRaya': 'sum', 'TRANS. DATE': 'first'})
+            .sort_values(['ID ANGGOTA', 'YEAR_WEEK'])
+            .reset_index(drop=True)
+        )
+        
+        records = []
+        for id_val, group in weekly.groupby('ID ANGGOTA', sort=False):
+            g = group.sort_values('YEAR_WEEK').copy()
+            g['Rolling_Mean'] = g['Db HariRaya'].rolling(window=window, min_periods=1).mean()
+            g['Rolling_Std'] = g['Db HariRaya'].rolling(window=window, min_periods=1).std().fillna(0)
+            g['Z_Score'] = np.where(
+                g['Rolling_Std'] > 0,
+                (g['Db HariRaya'] - g['Rolling_Mean']) / g['Rolling_Std'],
+                0
+            )
+            g['Anomaly_HariRaya'] = (np.abs(g['Z_Score']) > threshold).astype(int)
+            records.append(g)
+        
+        return pd.concat(records, ignore_index=True) if records else pd.DataFrame()
+    except Exception as e:
+        st.warning(f"⚠️ Error detecting HariRaya anomalies: {str(e)}")
+        return pd.DataFrame()
+
+def detect_sukarela_anomaly(df: pd.DataFrame, scaler, iso_forest, feature_cols: list) -> pd.DataFrame:
+    """Detect Sukarela savings anomalies using Isolation Forest"""
+    try:
+        # Check if columns exist
+        if 'Db Sukarela' not in df.columns or 'Cr Sukarela' not in df.columns:
+            st.error("❌ Kolom 'Db Sukarela' atau 'Cr Sukarela' tidak ditemukan")
+            return pd.DataFrame()
+        
+        # Aggregate dengan named aggregation (syntax pandas yang benar)
+        agg = (
+            df.groupby(['ID ANGGOTA', 'NAMA', 'CENTER'], as_index=False)
+            .agg(
+                Db_Sukarela_Total=('Db Sukarela', 'sum'),
+                Db_Sukarela_Avg=('Db Sukarela', 'mean'),
+                Db_Sukarela_Std=('Db Sukarela', 'std'),
+                Db_Sukarela_Max=('Db Sukarela', 'max'),
+                Cr_Sukarela_Total=('Cr Sukarela', 'sum'),
+                Cr_Sukarela_Avg=('Cr Sukarela', 'mean'),
+                Cr_Sukarela_Std=('Cr Sukarela', 'std'),
+                Cr_Sukarela_Max=('Cr Sukarela', 'max'),
+            )
+            .fillna(0)
+        )
+        
+        # Feature columns untuk ML model
+        feature_cols_actual = [
+            'Db_Sukarela_Total', 'Db_Sukarela_Avg', 'Db_Sukarela_Std', 'Db_Sukarela_Max',
+            'Cr_Sukarela_Total', 'Cr_Sukarela_Avg', 'Cr_Sukarela_Std', 'Cr_Sukarela_Max'
+        ]
+        
+        # Scale features
+        features_scaled = scaler.transform(agg[feature_cols_actual])
+        
+        # Predict anomalies
+        agg['Anomaly_Sukarela'] = iso_forest.predict(features_scaled)
+        agg['Anomaly_Sukarela'] = (agg['Anomaly_Sukarela'] == -1).astype(int)
+        
+        return agg
+    except Exception as e:
+        st.warning(f"⚠️ Error detecting Sukarela anomalies: {str(e)}")
+        import traceback
+        st.error(f"Debug info: {traceback.format_exc()}")
+        return pd.DataFrame()
+
+# ── MAIN APP ─────────────────────────────────────────────────────────────────
+
+tab1, tab2 = st.tabs(["📊 Proses Gabungan & Final", "📋 Analisa Simpanan"])
+
+# ── TAB 1: PROSES GABUNGAN & FINAL ───────────────────────────────────────────
+with tab1:
+    st.subheader("🔄 Tahap 1: Merge File")
+    st.write("1️⃣ Upload 4 file Excel (THC FINAL, TAK, TLP, KDP) ini ambil dari hasil penarikan database")
+    st.write("2️⃣ Proses Gabungan (Merge semua file dari penarikan Database)")
+    st.write("3️⃣ Proses Final (Estimasi & Anomali Detection)")
+    st.divider()
+    
+    uploaded_files = st.file_uploader(
+        "📤 Unggah 4 file Excel THC FINAL.xlsx, TAK.xlsx, TLP.xlsx, KDP.xlsx",
+        accept_multiple_files=True,
+        type=["xlsx"],
+        key="tab1_upload"
+    )
+    
+    if uploaded_files:
+        try:
+            dfs = {file.name: load_excel(file) for file in uploaded_files}
+            combined_df_list = []
+            
+            # Process THC FINAL
+            if 'THC FINAL.xlsx' in dfs:
+                df_thc = dfs['THC FINAL.xlsx']
+                df_thc = process_dataframe(df_thc, [], {})
+                combined_df_list.append(df_thc)
+                st.success("✓ THC FINAL.xlsx diproses")
+                
+            if 'TAK.xlsx' in dfs:
+                df_tak = dfs['TAK.xlsx']
+                rename_dict_tak = {
+                    'KELOMPOK': 'KEL', 'DEBIT_PINJAMAN ARTA': 'Db PRT', 'DEBIT_PINJAMAN DT. PENDIDIKAN': 'Db DTP',
+                    'DEBIT_PINJAMAN MIKROBISNIS': 'Db PMB', 'DEBIT_PINJAMAN SANITASI': 'Db PSA',
+                    'DEBIT_PINJAMAN UMUM': 'Db PU', 'DEBIT_PINJAMAN RENOVASI RUMAH': 'Db PRR',
+                    'DEBIT_PINJAMAN PERTANIAN': 'Db PTN', 'DEBIT_TOTAL': 'Db Total2',
+                    'CREDIT_PINJAMAN ARTA': 'Cr PRT', 'CREDIT_PINJAMAN DT. PENDIDIKAN': 'Cr DTP',
+                    'CREDIT_PINJAMAN MIKROBISNIS': 'Cr PMB', 'CREDIT_PINJAMAN SANITASI': 'Cr PSA',
+                    'CREDIT_PINJAMAN UMUM': 'Cr PU', 'CREDIT_PINJAMAN RENOVASI RUMAH': 'Cr PRR',
+                    'CREDIT_PINJAMAN PERTANIAN': 'Cr PTN', 'CREDIT_TOTAL': 'Cr Total2'
+                }
+                df_tak = process_dataframe(df_tak, list(rename_dict_tak.keys()), rename_dict_tak)
+                combined_df_list.append(df_tak)
+                st.success("✓ TAK.xlsx diproses")
+
+            if 'TLP.xlsx' in dfs:
+                df_tlp = dfs['TLP.xlsx']
+                rename_dict_tlp = {
+                    'KELOMPOK': 'KEL', 'DEBIT_Simpanan Hari Raya': 'Db HariRaya',
+                    'DEBIT_Simpanan Pensiun': 'Db Pensiun', 'DEBIT_Simpanan Pokok': 'Db Pokok',
+                    'DEBIT_Simpanan Sukarela': 'Db Sukarela', 'DEBIT_Simpanan Wajib': 'Db Wajib',
+                    'DEBIT_Simpanan Qurban': 'Db Qurban', 'DEBIT_Simpanan Sipadan': 'Db SIPADAN',
+                    'DEBIT_Simpanan Khusus': 'Db Khusus', 'DEBIT_TOTAL': 'Db Total',
+                    'CREDIT_Simpanan Hari Raya': 'Cr HariRaya', 'CREDIT_Simpanan Pensiun': 'Cr Pensiun',
+                    'CREDIT_Simpanan Pokok': 'Cr Pokok', 'CREDIT_Simpanan Sukarela': 'Cr Sukarela',
+                    'CREDIT_Simpanan Wajib': 'Cr Wajib', 'CREDIT_Simpanan Qurban': 'Cr Qurban',
+                    'CREDIT_Simpanan Sipadan': 'Cr SIPADAN', 'CREDIT_Simpanan Khusus': 'Cr Khusus',
+                    'CREDIT_TOTAL': 'Cr Total'
+                }
+                df_tlp = process_dataframe(df_tlp, list(rename_dict_tlp.keys()), rename_dict_tlp)
+                combined_df_list.append(df_tlp)
+                st.success("✓ TLP.xlsx diproses")
+
+            if 'KDP.xlsx' in dfs:
+                df_kdp = dfs['KDP.xlsx']
+                rename_dict_kdp = {
+                    'KELOMPOK': 'KEL', 'DEBIT_Simpanan Hari Raya': 'Db HariRaya',
+                    'DEBIT_Simpanan Pensiun': 'Db Pensiun', 'DEBIT_Simpanan Pokok': 'Db Pokok',
+                    'DEBIT_Simpanan Sukarela': 'Db Sukarela', 'DEBIT_Simpanan Wajib': 'Db Wajib',
+                    'DEBIT_Simpanan Qurban': 'Db Qurban', 'DEBIT_Simpanan Sipadan': 'Db SIPADAN',
+                    'DEBIT_Simpanan Khusus': 'Db Khusus', 'DEBIT_TOTAL': 'Db Total',
+                    'CREDIT_Simpanan Hari Raya': 'Cr HariRaya', 'CREDIT_Simpanan Pensiun': 'Cr Pensiun',
+                    'CREDIT_Simpanan Pokok': 'Cr Pokok', 'CREDIT_Simpanan Sukarela': 'Cr Sukarela',
+                    'CREDIT_Simpanan Wajib': 'Cr Wajib', 'CREDIT_Simpanan Qurban': 'Cr Qurban',
+                    'CREDIT_Simpanan Sipadan': 'Cr SIPADAN', 'CREDIT_Simpanan Khusus': 'Cr Khusus',
+                    'CREDIT_TOTAL': 'Cr Total', 'DEBIT_PU': 'Db PU', 'CREDIT_PU': 'Cr PU',
+                    'DEBIT_TOTAL2': 'Db Total2', 'CREDIT_TOTAL2': 'Cr Total2'
+                }
+                df_kdp = process_dataframe(df_kdp, list(rename_dict_kdp.keys()), rename_dict_kdp)
+                combined_df_list.append(df_kdp)
+                st.success("✓ KDP.xlsx diproses")
+
+                    # --- PROSES GABUNGAN ---
+                    # 1. Bersihkan setiap dataframe di awal
+                    cleaned_list = []
+                    for name, df in dfs.items():
+                        df = df.loc[:, ~df.columns.duplicated()].copy()
+                        df = df.reset_index(drop=True)
+                        cleaned_list.append(df)
+                    
+                    # 2. Gabungkan (Concat)
+                    combined_df = pd.concat(cleaned_list, ignore_index=True, sort=False)
+                    combined_df = combined_df.reset_index(drop=True)
+                    combined_df = combined_df.loc[:, ~combined_df.columns.duplicated()].copy()
+                    
+                    # 3. Rename & Standarisasi
+                    col_mapping = {
+                        'ID': 'ID ANGGOTA', 'KELOMPOK': 'KEL',
+                        'Db Sihara': 'Db HariRaya', 'Cr Sihara': 'Cr HariRaya',
+                        'Db Hariraya': 'Db HariRaya', 'Cr Hariraya': 'Cr HariRaya',
+                        'Db Total 2': 'Db Total2', 'Cr Total 2': 'Cr Total2',
+                        'Db Total Simpanan': 'Db Total', 'Cr Total Simpanan': 'Cr Total',
+                        'Db Total Pinjaman': 'Db Total2', 'Cr Total Pinjaman': 'Cr Total2'
+                    }
+                    combined_df = combined_df.rename(columns=col_mapping)
+                    # Penting: Buang duplikat SETELAH rename
+                    combined_df = combined_df.loc[:, ~combined_df.columns.duplicated()].copy()
+                    
+                    # 4. Susun Kolom (Metode Rekonstruksi - Anti Reindex Error)
+                    final_df = pd.DataFrame(index=combined_df.index)
+                    
+                    # Tentukan daftar kolom yang diinginkan (Desired + Others)
+                    existing_cols = [c for c in DESIRED_ORDER if c in combined_df.columns]
+                    other_cols = [c for c in combined_df.columns if c not in DESIRED_ORDER]
+                    all_target_cols = list(dict.fromkeys(DESIRED_ORDER + other_cols))
+                    
+                    for col in all_target_cols:
+                        if col in combined_df.columns:
+                            col_data = combined_df[col]
+                            # Jika masih ada duplikat (kemungkinan kecil), ambil kolom pertama
+                            if isinstance(col_data, pd.DataFrame):
+                                final_df[col] = col_data.iloc[:, 0]
+                            else:
+                                final_df[col] = col_data
+                        else:
+                            # Jika kolom tidak ada di file asli, isi 0
+                            final_df[col] = 0
+                    
+                    combined_df = final_df.copy()
+                    
+                    st.divider()
+                    st.subheader("🔍 Tahap 2: Proses Final (Estimasi & Anomali)")
+                    
+                    # 5. Tambah Estimasi
+                    df_hasil_raw = tambah_kolom_estimasi(combined_df.copy())
+                    
+                    # 6. Susun Kolom Akhir (Metode Rekonstruksi)
+                    final_col_order = list(dict.fromkeys(DESIRED_ORDER + ESTIMASI_COLS))
+                    df_final = pd.DataFrame(index=df_hasil_raw.index)
+                    
+                    for col in final_col_order:
+                        if col in df_hasil_raw.columns:
+                            col_data = df_hasil_raw[col]
+                            if isinstance(col_data, pd.DataFrame):
+                                df_final[col] = col_data.iloc[:, 0]
+                            else:
+                                df_final[col] = col_data
+                        else:
+                            df_final[col] = 0
+                    
+                    df_hasil = df_final.copy()
+                    
+                    # Metrics
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.metric("📊 Total Baris Data", len(df_hasil))
+                    with col2:
+                        anomali_count = df_hasil["Final Filter"].sum()
+                        st.metric("⚠️ Anomali Terdeteksi", int(anomali_count))
+                    
+                    st.divider()
+                    st.write("📋 Preview hasil akhir (20 baris pertama):")
+                    st.dataframe(df_hasil.head(20), use_container_width=True)
+                    
+                    # Download
+                    output = io.BytesIO()
+                    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+                        df_hasil.to_excel(writer, index=False, sheet_name='THC Hasil')
+                    output.seek(0)
+                    
+                    st.download_button(
+                        label="📥 Download Data Lengkap (Estimasi + Final Filter)",
+                        data=output.getvalue(),
+                        file_name="THC_Gabungan_dan_Final_Hasil.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+                    
+        except Exception as e:
+            import traceback
+            st.error(f"❌ Error: {str(e)}")
+            st.code(traceback.format_exc())
+            # Debug: Cek kolom duplikat
+            if 'duplicate labels' in str(e).lower():
+                st.warning("⚠️ Terdeteksi kolom ganda. Cek daftar kolom ini:")
+                st.write(combined_df.columns[combined_df.columns.duplicated()].tolist())
+
+# ── TAB 2: ANALISA SIMPANAN ──────────────────────────────────────────────────
+with tab2:
+    st.subheader("🔍 Analisa Simpanan - Anomali Detection")
+    st.write("Upload data dari Proses Gabungan & Final")
+    st.divider()
+    
+    # Load models
+    scaler, iso_forest, metadata = load_models_and_metadata()
+    
+    if scaler is None or iso_forest is None:
+        st.error("❌ Model tidak tersedia di tools/. Pastikan scaler.pkl dan isolation_forest.pkl ada.")
+    else:
+        feature_cols = metadata.get('feature_cols', [
+            'Db_Sukarela_Total', 'Db_Sukarela_Avg', 'Db_Sukarela_Std', 'Db_Sukarela_Max',
+            'Cr_Sukarela_Total', 'Cr_Sukarela_Avg', 'Cr_Sukarela_Std', 'Cr_Sukarela_Max'
+        ])
+        
+        # File upload
+        uploaded_file = st.file_uploader(
+            "📤 Upload File (CSV/Excel)",
+            type=['csv', 'xlsx', 'xls'],
+            key="tab2_upload"
+        )
+        
+        if uploaded_file is not None:
+            df_raw = load_data(uploaded_file)
+            if df_raw is None:
+                st.stop()
+            
+            df_prep = prepare_data_analisa(df_raw)
+            if df_prep is None:
+                st.stop()
+            
+            st.success(f"✓ Data berhasil dimuat: {len(df_prep)} transaksi dari {df_prep['ID ANGGOTA'].nunique()} anggota")
+            
+            # Anomaly detection
+            st.subheader("🔍 Menjalankan Anomali Deteksi...")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("🔹 HariRaya Anomaly (Rolling Z-Score)...")
+                hariraya_results = detect_hariraya_anomaly(df_prep, window=3, threshold=1.0)
+                hariraya_anomalies = hariraya_results[hariraya_results['Anomaly_HariRaya'] == 1] if len(hariraya_results) > 0 else pd.DataFrame()
+                st.metric("Anomali HariRaya", len(hariraya_anomalies))
+            
+            with col2:
+                st.write("🔹 Sukarela Anomaly (Isolation Forest)...")
+                sukarela_results = detect_sukarela_anomaly(df_prep, scaler, iso_forest, [])
+                sukarela_anomalies = sukarela_results[sukarela_results['Anomaly_Sukarela'] == 1] if len(sukarela_results) > 0 else pd.DataFrame()
+                st.metric("Anomali Sukarela", len(sukarela_anomalies))
+            
+            st.divider()
+            
+            # Results tabs
+            st.subheader("📊 Detail Hasil Anomali")
+            
+            tab2_1, tab2_2, tab2_3 = st.tabs(["🔴 HariRaya Anomalies", "🟡 Sukarela Anomalies", "📋 Summary"])
+            
+            with tab2_1:
+                if len(hariraya_anomalies) > 0:
+                    display_cols = [col for col in ['ID ANGGOTA', 'NAMA', 'CENTER', 'Db HariRaya', 'Z_Score', 'YEAR_WEEK'] 
+                                   if col in hariraya_anomalies.columns]
+                    st.dataframe(
+                        hariraya_anomalies[display_cols].sort_values('Z_Score', ascending=False),
+                        use_container_width=True
+                    )
+                    
+                    # Chart
+                    if len(hariraya_anomalies) > 0:
+                        chart = alt.Chart(hariraya_anomalies).mark_bar().encode(
+                            x='ID ANGGOTA:N',
+                            y='Db HariRaya:Q',
+                            color=alt.value('red')
+                        ).properties(height=400, title="HariRaya Anomalies")
+                        st.altair_chart(chart, use_container_width=True)
+                else:
+                    st.info("✓ Tidak ada anomali HariRaya terdeteksi")
+            
+            with tab2_2:
+                if len(sukarela_anomalies) > 0:
+                    st.dataframe(
+                        sukarela_anomalies[[
+                            'ID ANGGOTA', 'NAMA', 'CENTER',
+                            'Db_Sukarela_Total', 'Cr_Sukarela_Total',
+                            'Db_Sukarela_Avg', 'Cr_Sukarela_Avg'
+                        ]].sort_values('Db_Sukarela_Total', ascending=False),
+                        use_container_width=True
+                    )
+                    
+                    # Chart
+                    chart = alt.Chart(sukarela_anomalies).mark_circle(size=100).encode(
+                        x='Db_Sukarela_Avg:Q',
+                        y='Cr_Sukarela_Avg:Q',
+                        color=alt.value('red'),
+                        tooltip=['ID ANGGOTA', 'NAMA', 'Db_Sukarela_Total']
+                    ).properties(height=400, title="Sukarela Anomalies (Debit vs Kredit)")
+                    st.altair_chart(chart, use_container_width=True)
+                else:
+                    st.info("✓ Tidak ada anomali Sukarela terdeteksi")
+            
+            with tab2_3:
+                st.write("**Ringkasan Anomali Terdeteksi:**")
+                summary_data = {
+                    "Tipe Anomali": ["HariRaya", "Sukarela"],
+                    "Jumlah Anomali": [len(hariraya_anomalies), len(sukarela_anomalies)],
+                    "% dari Total": [
+                        f"{(len(hariraya_anomalies)/len(hariraya_results)*100):.2f}%" if len(hariraya_results) > 0 else "0%",
+                        f"{(len(sukarela_anomalies)/len(sukarela_results)*100):.2f}%" if len(sukarela_results) > 0 else "0%"
+                    ]
+                }
+                st.dataframe(pd.DataFrame(summary_data), use_container_width=True)
+            
+            st.divider()
+            
+            # Export
+            st.subheader("💾 Export Hasil")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                if len(hariraya_anomalies) > 0:
+                    excel_buffer = io.BytesIO()
+                    with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
+                        hariraya_anomalies.to_excel(writer, sheet_name='HariRaya', index=False)
+                    excel_buffer.seek(0)
+                    st.download_button(
+                        label="📥 HariRaya Anomalies",
+                        data=excel_buffer.getvalue(),
+                        file_name="Analisa_HariRaya_Anomalies.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+                else:
+                    st.info("Tidak ada data HariRaya")
+            
+            with col2:
+                if len(sukarela_anomalies) > 0:
+                    excel_buffer = io.BytesIO()
+                    with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
+                        sukarela_anomalies.to_excel(writer, sheet_name='Sukarela', index=False)
+                    excel_buffer.seek(0)
+                    st.download_button(
+                        label="📥 Sukarela Anomalies",
+                        data=excel_buffer.getvalue(),
+                        file_name="Analisa_Sukarela_Anomalies.xlsx",
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+                else:
+                    st.info("Tidak ada data Sukarela")
+        else:
+            st.info("👆 Upload file untuk analisa simpanan")

requirements.txt

@@ -0,0 +1,9 @@
+streamlit>=1.28.0
+pandas>=2.1.0
+numpy
+openpyxl
+xlsxwriter
+pyarrow>=12.0.0
+scikit-learn
+altair
+joblib

tools/README.md

@@ -0,0 +1,137 @@
+# 🔧 Tools Directory
+
+Folder ini berisi model machine learning dan konfigurasi untuk anomali detection.
+
+---
+
+## 📦 Files Required
+
+```
+tools/
+├── scaler.pkl              ← StandardScaler model (binary)
+├── isolation_forest.pkl    ← Isolation Forest model (binary)
+├── metadata.json           ← Configuration
+├── model_train.py          ← Training script (optional)
+└── simpanan_analisis.py    ← Helper functions (optional)
+```
+
+---
+
+## 📋 File Descriptions
+
+### scaler.pkl
+
+- **Type:** Binary (Pickle format)
+- **Purpose:** Standardize features untuk ML model
+- **Used by:** Tab 2 (Analisa Simpanan)
+- **Size:** ~1-2 KB
+
+### isolation_forest.pkl
+
+- **Type:** Binary (Pickle format)
+- **Purpose:** Pre-trained Isolation Forest model untuk anomali detection
+- **Used by:** Tab 2 (Analisa Simpanan)
+- **Features:** 8 fitur (Db_Sukarela dan Cr_Sukarela aggregates)
+- **Size:** ~10-50 KB
+
+### metadata.json
+
+- **Type:** JSON (Text)
+- **Purpose:** Konfigurasi model dan parameter
+- **Content:**
+  ```json
+  {
+    "feature_cols": [...],           // Nama kolom untuk model
+    "rolling_zscore_threshold": 1.0, // Threshold untuk Z-Score
+    "rolling_window": 3              // Window size untuk rolling aggregation
+  }
+  ```
+
+### model_train.py (Optional)
+
+Script untuk melatih ulang model jika diperlukan.
+
+### simpanan_analisis.py (Optional)
+
+Helper functions untuk analisa simpanan.
+
+---
+
+## ⚠️ Important Notes
+
+### Binary Model Files (.pkl)
+
+- File `scaler.pkl` dan `isolation_forest.pkl` HARUS ada untuk Tab 2 berfungsi
+- Files ini di-generate saat training, bukan di-create manual
+- Jangan di-edit manual - format binary
+
+### File Locations
+
+- App mencari file di path relatif: `../tools/` (dari app folder)
+- Pastikan struktur folder sesuai template
+
+### Model Updates
+
+Jika ingin update model (retrain):
+
+1. Jalankan `python tools/model_train.py`
+2. File `.pkl` baru akan di-generate
+3. Restart aplikasi
+
+---
+
+## 🔍 Troubleshooting
+
+### Error: "Model tidak ditemukan"
+
+```
+Solusi:
+1. Pastikan scaler.pkl ada di tools/
+2. Pastikan isolation_forest.pkl ada di tools/
+3. Check file paths (case-sensitive di Linux/Mac)
+```
+
+### Error: "Model load failed"
+
+```
+Solusi:
+1. Pastikan Python version sama saat training dan running
+2. Pastikan scikit-learn version sama
+3. Re-train model jika masih error
+```
+
+---
+
+## 📊 Model Info
+
+### Isolation Forest
+
+- **Algorithm:** Anomaly detection via Isolation Forest
+- **Training data:** Historical simpanan transactions
+- **Features:** 8 aggregated metrics
+  - Db_Sukarela_Total, Db_Sukarela_Avg, Db_Sukarela_Std, Db_Sukarela_Max
+  - Cr_Sukarela_Total, Cr_Sukarela_Avg, Cr_Sukarela_Std, Cr_Sukarela_Max
+- **Output:** Binary (Anomaly: -1, Normal: 1)
+
+### StandardScaler
+
+- **Purpose:** Feature normalization
+- **Fitted on:** Historical data statistics
+- **Usage:** Pre-process features before model prediction
+
+---
+
+## 🚀 Quick Check
+
+Verify tools setup:
+
+```bash
+cd THC_APP
+python -c "import joblib; print('scaler:', joblib.load('tools/scaler.pkl')); print('model:', joblib.load('tools/isolation_forest.pkl'))"
+```
+
+Success jika output menunjukkan objects tanpa error.
+
+---
+
+**Last Updated:** May 2026

tools/isolation_forest.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72be34b5739efdb19152074b352fc76dca7f970aa0647f35abcca51732c64c0d
+size 706553

tools/metadata.json

@@ -0,0 +1,12 @@
+{
+  "feature_cols": [
+    "Db_Sukarela_Total",
+    "Db_Sukarela_Avg",
+    "Db_Sukarela_Std",
+    "Db_Sukarela_Max",
+    "Cr_Sukarela_Total",
+    "Cr_Sukarela_Avg",
+    "Cr_Sukarela_Std",
+    "Cr_Sukarela_Max"
+  ]
+}