KMI Dashboard

Dashboard.py

@@ -0,0 +1,1675 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from datetime import datetime
+from sklearn.preprocessing import MinMaxScaler
+import openpyxl
+from scipy.optimize import differential_evolution
+from MonitoringModel import (
+    evaluate_models_for_dashboard,
+    DATA_FILENAME,
+    MODEL_FOLDER,
+    PRODUCT_LIST,
+    FEATURES,
+    TARGET_COLUMN,
+)
+from eda_functions import (
+    compute_eda_summary,
+    create_line_plots,
+    identify_outliers,
+    compute_stats_table,
+    compute_anomaly_table,
+    compute_production_segments,
+)
+
+from Inverse_Model import (
+    AVAILABLE_PRODUCTS,
+    run_inverse_for_targets,
+    results_to_dataframe,
+)
+from Disagregasi_mmbtu import run_disagregasi_pipeline
+from filter_rule_engine import apply_rule_engine
+from prediksi_model_inverse import predict_forward_from_params
+
+st.set_page_config(
+    page_title="Sistem Prediksi & Rekomendasi Parameter Gas (MMBTU)",
+    layout="wide"
+)
+
+AVAILABLE_PRODUCTS = ["BMR BASE", "CKP BASE", "CKR BASE", "CMR BASE", "MORIGRO BASE"]
+
+# Konfigurasi fitur tetap sama untuk semua model
+INPUT_FEATURES = [
+    "D101330TT", "D102260TIC_CV", "D102265TIC_PV",
+    "D102265TIC_CV", "D102266TIC", "D101264FTSCL"
+]
+LAG_STEPS = [1, 2, 3, 6, 12, 24]
+ROLL_WINDOWS = [3, 6, 12, 24]
+CONTEXT_WINDOW = max(max(LAG_STEPS), max(ROLL_WINDOWS))  # 24
+
+# =========================
+# FUNGSI UTILITAS
+# =========================
+def create_temporal_features(df, lag_cols, rolling_cols):
+    """Membuat fitur berbasis waktu (lag, rolling, kalender)."""
+    df_featured = df.copy()
+
+    # Fitur kalender
+    if "Date_time" in df_featured.columns:
+        dt = pd.to_datetime(df_featured["Date_time"], errors="coerce")
+        df_featured["minute"] = dt.dt.minute
+        df_featured["hour"] = dt.dt.hour
+        df_featured["day_of_week"] = dt.dt.dayofweek
+        df_featured["month"] = dt.dt.month
+        df_featured["day_of_month"] = dt.dt.day
+
+    # Fitur lag
+    for col in lag_cols:
+        if col in df_featured.columns:
+            for lag in LAG_STEPS:
+                df_featured[f"{col}_lag_{lag}"] = df_featured[col].shift(lag)
+
+    # Fitur rolling
+    for col in rolling_cols:
+        if col in df_featured.columns:
+            s = df_featured[col]
+            for w in ROLL_WINDOWS:
+                rolled = s.rolling(window=w, min_periods=w)
+                df_featured[f"{col}_rolling_mean_{w}"] = rolled.mean()
+                df_featured[f"{col}_rolling_std_{w}"]  = rolled.std()
+                df_featured[f"{col}_rolling_min_{w}"]  = rolled.min()
+                df_featured[f"{col}_rolling_max_{w}"]  = rolled.max()
+
+    return df_featured
+
+
+def select_context_history(df_product_history, user_row_dict, input_cols, context_window=CONTEXT_WINDOW):
+    """
+    Mencari data historis paling mirip HANYA dalam data produk yang relevan.
+    Mengembalikan: context_df, indeks terbaik, jarak minimum.
+    """
+    hist = df_product_history.copy()
+    hist = hist.sort_values("Date_time").reset_index(drop=True)
+
+    # Pastikan data cukup untuk scaling
+    if len(hist) < 2:
+        return hist, 0, 0.0  # Kembalikan apa adanya jika data tidak cukup
+
+    scaler = MinMaxScaler()
+    hist_scaled = scaler.fit_transform(hist[input_cols])
+
+    user_vec = np.array([[user_row_dict[col] for col in input_cols]], dtype=float)
+    user_scaled = scaler.transform(user_vec)
+
+    deltas = hist_scaled - user_scaled
+    dists = np.sqrt(np.sum(deltas**2, axis=1))
+
+    best_idx = int(np.argmin(dists))
+    start_idx = max(0, best_idx - (context_window - 1))
+    context_df = hist.iloc[start_idx:best_idx + 1].copy()
+
+    return context_df, best_idx, float(dists[best_idx])
+
+
+def load_artifacts_and_history(model_folder, data_source, selected_product):
+    """
+    Memuat model yang tepat dan memfilter data historis untuk produk yang dipilih.
+    data_source bisa berupa:
+      - string path CSV
+      - UploadedFile dari st.file_uploader
+    """
+    # Nama file model berdasarkan produk, contoh: ckr_base_checkpoint.pkl
+    product_file_name = f"{selected_product.lower().replace(' ', '_')}_checkpoint.pkl"
+    model_path = os.path.join(model_folder, product_file_name)
+
+    if not os.path.exists(model_path):
+        st.error(f"❌ File model tidak ditemukan di: {model_path}")
+        return None, None, None
+
+    # Load model
+    artifacts = joblib.load(model_path)
+    model = artifacts["model"]
+    feature_columns = artifacts["features"]
+
+    # Load data historis
+    try:
+        if isinstance(data_source, str):
+            df_raw = pd.read_csv(data_source)
+        else:
+            # Asumsikan ini UploadedFile dari Streamlit
+            df_raw = pd.read_csv(data_source)
+    except Exception as e:
+        st.error(f"❌ Gagal membaca file CSV historis. Error: {e}")
+        return None, None, None
+
+    if "Product" not in df_raw.columns:
+        st.error("Kolom 'Product' tidak ditemukan di data historis.")
+        return None, None, None
+
+    df_product = df_raw[df_raw["Product"] == selected_product].copy()
+    if df_product.empty:
+        st.error(f"Tidak ada data historis untuk produk '{selected_product}'.")
+        return None, None, None
+
+    if "Date_time" not in df_product.columns:
+        st.error("Kolom 'Date_time' tidak ditemukan di data historis.")
+        return None, None, None
+
+    df_product["Date_time"] = pd.to_datetime(df_product["Date_time"], errors="coerce")
+    df_product = df_product.dropna(subset=["Date_time"]).sort_values("Date_time").reset_index(drop=True)
+
+    return model, feature_columns, df_product
+
+# =========================
+# HALAMAN 1: Prediksi Gas dari 6 Parameter
+# =========================
+def page_prediksi_gas_dari_6_parameter():
+    st.subheader("1️⃣ Dashboard Prediksi Konsumsi Gas (MMBTU)")
+
+    st.markdown(
+        """
+        Halaman ini digunakan untuk memprediksi **konsumsi gas (MMBTU)** 
+        berdasarkan **6 parameter proses** pada spray dryer.
+        """
+    )
+
+    # ---------- Konfigurasi Model & Data (DI MAIN PAGE, BUKAN SIDEBAR) ----------
+    st.markdown("### 🔧 Konfigurasi Data & Model")
+
+    config_col1, config_col2 = st.columns(2)
+
+    with config_col1:
+        selected_product = st.selectbox(
+            "Pilih Produk",
+            AVAILABLE_PRODUCTS,
+            index=2  # default CKR BASE
+        )
+
+        model_folder = st.text_input(
+            "Folder Model Checkpoints",
+            value="MODEL CHECKPOINT MANY TO ONE",
+            help="Folder tempat file-file model *.pkl disimpan."
+        )
+
+    with config_col2:
+        data_source_option = st.radio(
+            "Sumber Data Historis",
+            ["Path File CSV", "Upload File CSV"],
+            horizontal=True
+        )
+
+        data_source = None
+        if data_source_option == "Path File CSV":
+            data_file_path = st.text_input(
+                "Path File Data CSV (historis)",
+                value=r"disagregasi_data_spraydryer_terbaru_10_17_2025.csv"
+            )
+            if data_file_path:
+                data_source = data_file_path
+        else:
+            uploaded_file = st.file_uploader(
+                "Upload File CSV Historis",
+                type=["csv"]
+            )
+            if uploaded_file is not None:
+                data_source = uploaded_file
+
+    st.markdown("---")
+
+    # Jika data_source belum ada, jangan lanjut ke prediksi
+    if data_source is None:
+        st.info("ℹ️ Silakan pilih sumber data historis (path atau upload CSV) untuk melanjutkan.")
+        return
+
+    # ---------- Load Model & Data Historis ----------
+    with st.spinner("📦 Memuat model & data historis..."):
+        model, feature_columns, df_history = load_artifacts_and_history(
+            model_folder=model_folder,
+            data_source=data_source,
+            selected_product=selected_product
+        )
+
+    if (model is None) or (df_history is None):
+        return  # pesan error sudah ditampilkan di fungsi loader
+
+    if len(df_history) < CONTEXT_WINDOW:
+        st.error(
+            f"Data historis untuk '{selected_product}' kurang dari {CONTEXT_WINDOW} baris "
+            f"(hanya {len(df_history)}). Prediksi mungkin tidak akurat."
+        )
+        return
+
+    # ---------- Input Parameter dari User ----------
+    st.markdown("### 🧪 Masukkan 6 Parameter Input (Data Baru)")
+
+    c1, c2, c3 = st.columns(3)
+
+    with c1:
+        v_D101330TT = st.number_input("Temperature Outlet Chamber (D101330TT)", value=95.0, format="%.4f")
+        v_D102265TIC_PV = st.number_input("Temperature Inlet Chamber (D102265TIC_PV)", value=185.0, format="%.4f")
+
+    with c2:
+        v_D102260TIC_CV = st.number_input("High Pressure Steam Damper (D102260TIC_CV)", value=45.0, format="%.4f")
+        v_D102265TIC_CV = st.number_input("Low Pressure Steam Damper (D102265TIC_CV)", value=17.0, format="%.4f")
+
+    with c3:
+        v_D102266TIC = st.number_input("Dehumidifier Temperature (D102266TIC)", value=16.0, format="%.4f")
+        v_D101264FTSCL = st.number_input("Flow Feed Dryer (D101264FTSCL)", value=3800.0, format="%.4f")
+
+    st.markdown("---")
+
+    # ---------- Tombol Prediksi ----------
+    if st.button("🔮 Prediksi Konsumsi Gas (MMBTU)", type="primary", use_container_width=True):
+        # Susun baris input user
+        user_row = {
+            "Date_time": pd.to_datetime(datetime.now()),
+            "Product": selected_product,
+            "D101330TT": v_D101330TT,
+            "D102260TIC_CV": v_D102260TIC_CV,
+            "D102265TIC_PV": v_D102265TIC_PV,
+            "D102265TIC_CV": v_D102265TIC_CV,
+            "D102266TIC": v_D102266TIC,
+            "D101264FTSCL": v_D101264FTSCL,
+        }
+
+        with st.spinner(f"🔎 Mencari konteks historis paling mirip di data '{selected_product}'..."):
+            ctx_df, best_idx, best_dist = select_context_history(
+                df_history,
+                user_row,
+                INPUT_FEATURES,
+                context_window=CONTEXT_WINDOW
+            )
+
+        #st.info(
+            #f"Konteks historis paling mirip ditemukan pada index ke-**{best_idx}** "
+            #f"(jarak: **{best_dist:.6f}**) dengan timestamp: "
+            #f"**{ctx_df.iloc[-1]['Date_time']}**"
+        #)
+
+        with st.spinner("🧩 Membentuk fitur temporal & melakukan prediksi..."):
+            # Gabungkan konteks historis dan baris user
+            df_new = pd.DataFrame([user_row])
+            df_combined = pd.concat([ctx_df, df_new], ignore_index=True)
+
+            # Buat fitur temporal
+            df_featured = create_temporal_features(
+                df_combined,
+                lag_cols=INPUT_FEATURES,
+                rolling_cols=INPUT_FEATURES
+            )
+
+            # Ambil baris terakhir sebagai input final
+            final_input_row = df_featured.tail(1)
+
+            # Cek fitur yang dibutuhkan model
+            missing = [c for c in feature_columns if c not in final_input_row.columns]
+            if missing:
+                st.error(f"⚠️ Beberapa fitur yang dibutuhkan model tidak tersedia: {missing}")
+                return
+
+            # Cek NaN
+            if final_input_row[feature_columns].isnull().values.any():
+                st.warning(
+                    "Input akhir mengandung nilai NaN. "
+                    "Ini bisa terjadi jika konteks historis tidak cukup panjang "
+                    "atau data historis memiliki gap."
+                )
+                st.dataframe(final_input_row[feature_columns].T)
+                return
+
+            # Prediksi
+            X_pred = final_input_row[feature_columns]
+            y_pred = model.predict(X_pred)
+
+            st.metric(
+                f"✅ Hasil Prediksi Konsumsi GAS MMBTU untuk {selected_product}",
+                f"{float(y_pred[0]):.6f} MMBTU"
+            )
+
+            with st.expander("🔍 Lihat Input Fitur Final yang Digunakan untuk Prediksi"):
+                st.dataframe(X_pred)
+
+            with st.expander("📈 Lihat Konteks Historis yang Dipakai"):
+                st.dataframe(ctx_df.tail(CONTEXT_WINDOW))
+
+def load_inverse_from_csv(csv_path: str):
+    """
+    Membaca file CSV hasil inverse (global untuk semua produk).
+    Return: DataFrame atau None kalau file tidak ada / kosong.
+    """
+    if not os.path.exists(csv_path):
+        return None
+
+    try:
+        df = pd.read_csv(csv_path)
+        if df.empty:
+            return None
+        return df
+    except Exception as e:
+        st.warning(f"Gagal membaca CSV hasil inverse: {e}")
+        return None
+
+
+def append_inverse_to_csv(df_new: pd.DataFrame, csv_path: str):
+    """
+    Menambahkan df_new ke file CSV hasil inverse.
+
+    Perilaku:
+    - Kalau file belum ada → dibuat baru
+    - Kalau sudah ada → dibaca, diselaraskan kolomnya, lalu dikonkaten dan disimpan ulang
+    - Kolom yang belum ada di file lama akan ditambahkan otomatis
+    """
+    if df_new is None or df_new.empty:
+        return
+
+    if os.path.exists(csv_path):
+        try:
+            df_existing = pd.read_csv(csv_path)
+        except Exception as e:
+            st.warning(
+                f"Gagal membaca CSV lama, akan overwrite dengan hasil baru. Error: {e}"
+            )
+            df_new.to_csv(csv_path, index=False)
+            return
+
+        # Samakan set kolom antara existing dan new
+        all_cols = sorted(set(df_existing.columns).union(df_new.columns))
+        df_existing = df_existing.reindex(columns=all_cols)
+        df_new = df_new.reindex(columns=all_cols)
+
+        df_all = pd.concat([df_existing, df_new], ignore_index=True)
+        df_all.to_csv(csv_path, index=False)
+    else:
+        # File belum ada → buat baru
+        df_new.to_csv(csv_path, index=False)
+
+# =========================
+# HALAMAN 2–6 (STUB SEMENTARA)
+# =========================
+def page_prediksi_parameter_dari_gas():
+    st.subheader("2️⃣ Prediksi Parameter dari Gas (MMBTU)")
+    st.markdown(
+        """
+        Halaman ini digunakan untuk **mencari kombinasi 6 parameter proses** yang paling optimal
+        untuk mencapai **target konsumsi Gas (MMBTU)** tertentu, kemudian
+        memvalidasi hasilnya menggunakan **forward model XGBoost many-to-one**.
+        """
+    )
+
+    # ====== Layout dua kolom utama ======
+    col_left, col_right = st.columns([2, 1])
+
+    # -----------------------------
+    # BAGIAN KIRI – INVERSE MODEL
+    # -----------------------------
+    with col_left:
+        st.markdown("### 🔁 Inverse Model – Parameter Recommendation")
+
+        # 1. Pilih Produk
+        selected_product = st.selectbox(
+            "Pilih Produk",
+            AVAILABLE_PRODUCTS,
+            index=AVAILABLE_PRODUCTS.index("CKR BASE") if "CKR BASE" in AVAILABLE_PRODUCTS else 0,
+            key="inv_product_select"
+        )
+
+        # 2. Input Target Gas
+        target_mmbtu = st.number_input(
+            "Target Gas Consumption (MMBTU)",
+            min_value=0.10,
+            max_value=0.50,
+            value=0.29,
+            step=0.0001,
+            format="%.4f",
+            key="inv_target_mmbtu"
+        )
+
+        # 3. Konfigurasi path model & Excel
+                # 3. Konfigurasi path model & CSV
+        st.markdown("#### ⚙️ Konfigurasi Model & Database Hasil")
+
+        default_model_folder = r"MODEL CHECKPOINT FOR INVERSE MODEL"
+        model_folder = st.text_input(
+            "Folder Model Checkpoint XGBoost (Many-to-One)",
+            value=default_model_folder,
+            help="Folder berisi file model_checkpoint_xgb_{PRODUCT}.joblib"
+        )
+
+        default_csv_path = r"Hasil_Inverse_Model.csv"
+        csv_path = st.text_input(
+            "File CSV Hasil Inverse Model",
+            value=default_csv_path,
+            help="Semua produk disimpan dalam satu file CSV dengan kolom 'Product' dan 'Target_MMBTU'."
+        )
+
+        tol = st.number_input(
+            "Toleransi pencarian target di CSV (±)",
+            min_value=0.0,
+            max_value=0.01,
+            value=0.0005,
+            step=0.0001,
+            format="%.4f",
+            help="Misal 0.0005 → akan mencari baris dengan |Target_MMBTU - target| ≤ 0.0005"
+        )
+
+        # Tombol utama
+        run_btn = st.button(
+            "🔍 Cari / Optimasi Parameter",
+            type="primary",
+            use_container_width=True
+        )
+
+        # Variabel untuk dikirim ke kolom kanan
+        last_result_row = None
+
+        if run_btn:
+            # ------- 3. Lookup di CSV dulu -------
+            df_cache = load_inverse_from_csv(csv_path)
+            found_from_cache = False
+            last_result_row = None
+
+            if df_cache is not None:
+                # Pastikan kolom Product ada
+                if "Product" not in df_cache.columns:
+                    st.info(
+                        "Kolom 'Product' tidak ditemukan di CSV hasil inverse. "
+                        "Akan menjalankan optimasi baru."
+                    )
+                else:
+                    df_prod = df_cache[df_cache["Product"] == selected_product].copy()
+                    if df_prod.empty:
+                        st.info(
+                            f"Tidak ada histori inverse untuk produk '{selected_product}' "
+                            f"di CSV. Akan menjalankan optimasi baru."
+                        )
+                    else:
+                        # Cari kolom target (utama: 'Target_MMBTU', fallback: nama lain)
+                        target_col = None
+                        for c in df_prod.columns:
+                            if c.lower() in [
+                                "target_mmbtu",
+                                "target",
+                                "target_gas",
+                                "target_gas_mmbtu",
+                                "target_input",
+                            ]:
+                                target_col = c
+                                break
+
+                        if target_col is not None:
+                            diffs = (df_prod[target_col] - target_mmbtu).abs()
+                            mask = diffs <= tol
+                            if mask.any():
+                                df_match = df_prod.loc[mask].copy()
+                                df_match["__diff__"] = (df_match[target_col] - target_mmbtu).abs()
+                                df_match = df_match.sort_values("__diff__")
+                                row = df_match.iloc[0].drop(labels="__diff__")
+                                last_result_row = row
+                                found_from_cache = True
+                                st.success(
+                                    "✅ Rekomendasi parameter ditemukan di database CSV "
+                                    "(tanpa perlu menjalankan Differential Evolution)."
+                                )
+                            else:
+                                st.info(
+                                    "ℹ️ Tidak ditemukan target yang mendekati di CSV. "
+                                    "Akan menjalankan optimasi baru."
+                                )
+                        else:
+                            st.info(
+                                "Kolom target tidak ditemukan di CSV hasil inverse. "
+                                "Akan menjalankan optimasi baru."
+                            )
+            else:
+                st.info(
+                    "File CSV hasil inverse belum ada. Akan dibuat setelah optimasi pertama."
+                )
+
+            # ------- 4. Jika tidak ditemukan → jalankan optimasi real-time -------
+                        # ------- 4. Jika tidak ditemukan di CSV → jalankan optimasi real-time -------
+            if not found_from_cache:
+                model_filename = f"model_checkpoint_xgb_{selected_product}.joblib"
+                model_path = os.path.join(model_folder, model_filename)
+
+                if not os.path.exists(model_path):
+                    st.error(f"❌ File model tidak ditemukan: {model_path}")
+                    return
+
+                st.info(
+                    "Sedang mencari kombinasi parameter paling optimal untuk "
+                    "mencapai target Gas Consumption Anda."
+                )
+                with st.spinner(
+                    "Menjalankan Differential Evolution untuk inverse model..."
+                ):
+                    # Jalankan inverse hanya untuk 1 target
+                    results = run_inverse_for_targets(
+                        model_path, selected_product, [target_mmbtu]
+                    )
+                    df_new = results_to_dataframe(results, selected_product)
+
+                    # --- Pastikan struktur kolom minimal untuk CSV global ---
+                    # 1) Tambah kolom Product
+                    df_new["Product"] = selected_product
+
+                    # 2) Normalisasi kolom target → 'Target_MMBTU'
+                    target_col = None
+                    for c in df_new.columns:
+                        if c.lower() in [
+                            "target_mmbtu",
+                            "target",
+                            "target_gas",
+                            "target_gas_mmbtu",
+                            "target_input",
+                        ]:
+                            target_col = c
+                            break
+
+                    if target_col is None:
+                        df_new["Target_MMBTU"] = float(target_mmbtu)
+                    else:
+                        if target_col != "Target_MMBTU":
+                            df_new["Target_MMBTU"] = df_new[target_col]
+
+                    # 3) Tambah kolom-kolom penting jika belum ada
+                    required_cols = [
+                        "Level",
+                        "Predicted_MMBTU",
+                        "Error",
+                        "Error_Pct",
+                        "Objective_Value",
+                        "Converged",
+                        "Iterations",
+                        "Soft_Violations",
+                    ]
+                    for col in required_cols:
+                        if col not in df_new.columns:
+                            df_new[col] = np.nan
+
+                    # Ambil baris pertama sebagai hasil terakhir
+                    last_result_row = df_new.iloc[0]
+
+                    # 4) Simpan ke CSV (append)
+                    try:
+                        append_inverse_to_csv(df_new, csv_path)
+                        st.success(
+                            "✅ Hasil optimasi baru berhasil disimpan ke CSV "
+                            "(Hasil_Inverse_Model)."
+                        )
+                    except Exception as e:
+                        st.error(f"Gagal menyimpan hasil ke CSV: {e}")
+
+
+            # ------- 5. Tampilkan hasil dalam format tabel -------
+            if last_result_row is not None:
+                # Simpan ke session_state agar bisa diakses kolom kanan
+                st.session_state["last_inverse_result"] = {
+                    "product": selected_product,
+                    "target": float(target_mmbtu),
+                    "row": last_result_row.to_dict()
+                }
+
+                # Ambil nilai-nilai parameter
+                row_dict = last_result_row.to_dict()
+
+                # (Note) Prediksi & error di Excel tidak lagi dipakai untuk forward,
+                # tapi masih boleh ditampilkan sebagai informasi historis
+                pred_col = None
+                for c in row_dict.keys():
+                    if c.lower() in ["predicted_mmbtu", "prediction", "prediction_mmbtu"]:
+                        pred_col = c
+                        break
+
+                prediction_val = row_dict.get(pred_col, None)
+                error_val = row_dict.get("Error", None)
+
+                display_row = {
+                    "D101330TT": row_dict.get("D101330TT", np.nan),
+                    "D102260TIC_CV": row_dict.get("D102260TIC_CV", np.nan),
+                    "D102265TIC_CV": row_dict.get("D102265TIC_CV", np.nan),
+                    "D102265TIC_PV": row_dict.get("D102265TIC_PV", np.nan),
+                    "D102266TIC": row_dict.get("D102266TIC", np.nan),
+                    "D101264FTSCL": row_dict.get("D101264FTSCL", np.nan),
+                    "Prediction (MMBTU) [Excel/Inverse]": prediction_val,
+                    "Error (MMBTU) [Excel/Inverse]": error_val,
+                    "Target Input": float(target_mmbtu),
+                }
+
+                st.markdown("#### 📊 Hasil Rekomendasi Parameter")
+                st.dataframe(pd.DataFrame([display_row]), use_container_width=True)
+
+                with st.expander("🔍 Detail Lengkap Hasil Inverse Model (Raw)"):
+                    st.json(row_dict)
+            else:
+                st.warning("Tidak ada hasil yang bisa ditampilkan.")
+
+    # ---------------------------------------------
+    # BAGIAN KANAN – FORWARD MODELLING (VALIDASI)
+    # ---------------------------------------------
+    with col_right:
+        st.markdown("### 📈 Forward Modelling – Validasi XGBoost Many-to-One")
+
+        info_box = st.empty()
+
+        if "last_inverse_result" not in st.session_state:
+            info_box.info(
+                "Belum ada hasil inverse model.\n\n"
+                "Silakan jalankan **Cari / Optimasi Parameter** di sisi kiri terlebih dahulu."
+            )
+            return
+
+        # Ambil hasil terakhir dari inverse model
+        last_res = st.session_state["last_inverse_result"]
+        product_name = last_res["product"]
+        target_input = last_res["target"]
+        row_dict = last_res["row"]
+
+        info_box.success(f"Validasi forward model untuk **{product_name}** (Target: {target_input:.4f} MMBTU)")
+
+        # Tampilkan parameter yang digunakan forward model
+        st.markdown("#### Parameter Input ke Forward Model")
+        param_df = pd.DataFrame([{
+            "D101330TT": row_dict.get("D101330TT", np.nan),
+            "D102260TIC_CV": row_dict.get("D102260TIC_CV", np.nan),
+            "D102265TIC_PV": row_dict.get("D102265TIC_PV", np.nan),
+            "D102265TIC_CV": row_dict.get("D102265TIC_CV", np.nan),
+            "D102266TIC": row_dict.get("D102266TIC", np.nan),
+            "D101264FTSCL": row_dict.get("D101264FTSCL", np.nan),
+        }])
+        st.dataframe(param_df, use_container_width=True)
+
+        # 🔁 Jalankan forward model beneran (bukan baca dari Excel)
+        st.markdown("#### ✅ Hasil Prediksi Forward Model (Recomputed)")
+
+        try:
+            forward_input = {
+                "D101330TT": float(row_dict.get("D101330TT", np.nan)),
+                "D102260TIC_CV": float(row_dict.get("D102260TIC_CV", np.nan)),
+                "D102265TIC_PV": float(row_dict.get("D102265TIC_PV", np.nan)),
+                "D102265TIC_CV": float(row_dict.get("D102265TIC_CV", np.nan)),
+                "D102266TIC": float(row_dict.get("D102266TIC", np.nan)),
+                "D101264FTSCL": float(row_dict.get("D101264FTSCL", np.nan)),
+            }
+
+            pred_val = predict_forward_from_params(product_name, forward_input, model_folder)
+            err_val = float(pred_val) - float(target_input)
+
+            m1, m2 = st.columns(2)
+            with m1:
+                st.metric("Prediksi GAS (MMBTU)", f"{pred_val:.6f}")
+            with m2:
+                st.metric("Error terhadap Target", f"{err_val:+.6f}")
+
+        except Exception as e:
+            st.error(f"Terjadi error saat menghitung ulang prediksi forward: {e}")
+
+        # --------------------------------------------------
+        # 🔽 BAGIAN: SIMULASI PREDIKSI (FORWARD MODELLING)
+        # --------------------------------------------------
+        st.markdown("---")
+        st.markdown("### 🧪 Simulasi Prediksi Konsumsi Gas (Forward Modelling)")
+
+        st.caption(
+            "Pilih produk dan masukkan nilai 6 parameter proses secara manual untuk mensimulasikan "
+            "prediksi konsumsi gas (MMBTU) menggunakan model XGBoost Many-to-One."
+        )
+
+        # Pilih produk untuk simulasi – default ke produk dari inverse terakhir
+        sim_product = st.selectbox(
+            "Produk untuk Simulasi Forward",
+            AVAILABLE_PRODUCTS,
+            index=AVAILABLE_PRODUCTS.index(product_name) if product_name in AVAILABLE_PRODUCTS else 0,
+            key="sim_product_select"
+        )
+
+        # Nilai default:
+        if sim_product == product_name:
+            default_vals = {
+                "D101330TT": float(row_dict.get("D101330TT", 95.0)),
+                "D102260TIC_CV": float(row_dict.get("D102260TIC_CV", 45.0)),
+                "D102265TIC_PV": float(row_dict.get("D102265TIC_PV", 185.0)),
+                "D102265TIC_CV": float(row_dict.get("D102265TIC_CV", 17.0)),
+                "D102266TIC": float(row_dict.get("D102266TIC", 16.0)),
+                "D101264FTSCL": float(row_dict.get("D101264FTSCL", 3800.0)),
+            }
+        else:
+            default_vals = {
+                "D101330TT": 95.0,
+                "D102260TIC_CV": 45.0,
+                "D102265TIC_PV": 185.0,
+                "D102265TIC_CV": 17.0,
+                "D102266TIC": 16.0,
+                "D101264FTSCL": 3800.0,
+            }
+
+        s1, s2, s3 = st.columns(3)
+        with s1:
+            sim_D101330TT = st.number_input(
+                "D101330TT",
+                value=default_vals["D101330TT"],
+                format="%.4f",
+                key="sim_D101330TT"
+            )
+            sim_D102265TIC_PV = st.number_input(
+                "D102265TIC_PV",
+                value=default_vals["D102265TIC_PV"],
+                format="%.4f",
+                key="sim_D102265TIC_PV"
+            )
+        with s2:
+            sim_D102260TIC_CV = st.number_input(
+                "D102260TIC_CV",
+                value=default_vals["D102260TIC_CV"],
+                format="%.4f",
+                key="sim_D102260TIC_CV"
+            )
+            sim_D102265TIC_CV = st.number_input(
+                "D102265TIC_CV",
+                value=default_vals["D102265TIC_CV"],
+                format="%.4f",
+                key="sim_D102265TIC_CV"
+            )
+        with s3:
+            sim_D102266TIC = st.number_input(
+                "D102266TIC",
+                value=default_vals["D102266TIC"],
+                format="%.4f",
+                key="sim_D102266TIC"
+            )
+            sim_D101264FTSCL = st.number_input(
+                "D101264FTSCL",
+                value=default_vals["D101264FTSCL"],
+                format="%.4f",
+                key="sim_D101264FTSCL"
+            )
+
+        sim_btn = st.button(
+            "▶️ Jalankan Simulasi Prediksi GAS (MMBTU)",
+            type="primary",
+            use_container_width=True,
+            key="sim_forward_btn"
+        )
+
+        if sim_btn:
+            sim_input = {
+                "D101330TT": sim_D101330TT,
+                "D102260TIC_CV": sim_D102260TIC_CV,
+                "D102265TIC_PV": sim_D102265TIC_PV,
+                "D102265TIC_CV": sim_D102265TIC_CV,
+                "D102266TIC": sim_D102266TIC,
+                "D101264FTSCL": sim_D101264FTSCL,
+            }
+
+            try:
+                y_sim = predict_forward_from_params(sim_product, sim_input, model_folder)
+
+                diff_from_target = None
+                if (sim_product == product_name) and (target_input is not None):
+                    diff_from_target = float(y_sim) - float(target_input)
+
+                st.success(f"✅ Simulasi prediksi konsumsi GAS untuk produk **{sim_product}** berhasil.")
+                c_res1, c_res2 = st.columns(2)
+                with c_res1:
+                    st.metric(
+                        "Prediksi Konsumsi GAS (MMBTU)",
+                        f"{float(y_sim):.6f}"
+                    )
+                with c_res2:
+                    if diff_from_target is not None:
+                        st.metric(
+                            "Selisih terhadap Target Inverse",
+                            f"{diff_from_target:+.6f}"
+                        )
+                    else:
+                        st.caption(
+                            "Selisih terhadap target hanya dihitung jika produk simulasi sama dengan produk inverse terakhir."
+                        )
+
+            except FileNotFoundError as e:
+                st.error(str(e))
+            except Exception as e:
+                st.error(f"Terjadi error saat menjalankan simulasi forward modelling: {e}")
+
+
+def page_monitoring_model():
+    st.subheader("3️⃣ Evaluasi Performa Model Prediksi Gas (MMBTU) per Produk")
+
+    st.markdown(
+        """
+        Halaman ini menampilkan **ringkasan metrik performa model XGBoost** untuk setiap produk,
+        serta **grafik perbandingan Actual vs Predicted GAS_MMBTU**.
+
+        Kamu bisa:
+        - Menggunakan **dataset default** dari path lokal, atau
+        - Meng-upload **dataset terbaru (CSV)** untuk dievaluasi dengan model yang sama.
+        """
+    )
+
+    # --- Konfigurasi sumber data & model ---
+    st.markdown("#### ⚙️ Konfigurasi Sumber Data & Model")
+    col1, col2 = st.columns(2)
+    with col1:
+        data_path = st.text_input(
+            "Path Data Disaggregated (default)",
+            value=DATA_FILENAME,
+            help="Dipakai jika tidak ada file yang di-upload."
+        )
+    with col2:
+        model_dir = st.text_input(
+            "Folder Model Checkpoint",
+            value=MODEL_FOLDER,
+            help="Folder berisi file model_checkpoint_xgb_{PRODUCT}.joblib"
+        )
+
+    st.markdown("#### 📂 Upload Dataset Terbaru (Opsional)")
+    uploaded_file = st.file_uploader(
+        "Upload file CSV baru (struktur kolom harus sama dengan dataset sebelumnya)",
+        type=["csv"]
+    )
+
+    run_btn = st.button("🔎 Run Evaluation", type="primary", use_container_width=True)
+
+    if not run_btn:
+        st.info(
+            "• Upload dataset baru (opsional), lalu klik **Run Evaluation**\n\n"
+            "• Jika tidak upload apa-apa, sistem akan menggunakan **dataset default**"
+        )
+        return
+
+    # --- Siapkan data_df (jika ada upload) ---
+    data_df = None
+    if uploaded_file is not None:
+        try:
+            data_df = pd.read_csv(uploaded_file)
+            st.success("✅ Dataset baru berhasil dibaca dan akan digunakan untuk evaluasi.")
+        except Exception as e:
+            st.error(f"❌ Gagal membaca file CSV yang di-upload: {e}")
+            return
+    else:
+        st.warning("Tidak ada file yang di-upload. Sistem akan menggunakan dataset default dari path di atas.")
+
+    # --- Jalankan evaluasi ---
+    with st.spinner("Menghitung metrik performa dan menyiapkan grafik..."):
+        summary_df, product_figs = evaluate_models_for_dashboard(
+            data_path=data_path,       # tetap dikirim sebagai fallback
+            model_dir=model_dir,
+            products=PRODUCT_LIST,
+            features=FEATURES,
+            target_col=TARGET_COLUMN,
+            data_df=data_df           # <<-- NEW: jika None → pakai data_path
+        )
+
+    if summary_df.empty:
+        st.warning("Tidak ada hasil evaluasi yang dapat ditampilkan. Periksa kembali data dan model.")
+        return
+
+    # =====================================================
+    # BAGIAN 1 – Tabel Ringkasan Performa
+    # =====================================================
+    st.markdown("### 📊 Ringkasan Performa Model")
+
+    df_display = summary_df.copy()
+    df_display["R²"] = df_display["R²"].round(3)
+    df_display["RMSE"] = df_display["RMSE"].round(3)
+    df_display["MAE"] = df_display["MAE"].round(3)
+
+    def color_r2(val):
+        try:
+            v = float(val)
+        except Exception:
+            return ""
+        if v >= 0.90:
+            return "background-color: #d4edda; color: #155724;"   # hijau
+        elif v >= 0.80:
+            return "background-color: #cce5ff; color: #004085;"   # biru muda
+        else:
+            return "background-color: #fff3cd; color: #856404;"   # kuning
+
+    styled = (
+        df_display.style
+        .applymap(color_r2, subset=["R²"])
+        .format({"R²": "{:.3f}", "RMSE": "{:.3f}", "MAE": "{:.3f}"})
+    )
+
+    st.dataframe(styled, use_container_width=True)
+
+    # =====================================================
+    # BAGIAN 2 – Grafik Actual vs Predicted per Produk
+    # =====================================================
+    st.markdown("### 📈 Grafik Actual vs Predicted per Produk")
+
+    tabs = st.tabs(PRODUCT_LIST)
+
+    for i, product in enumerate(PRODUCT_LIST):
+        with tabs[i]:
+            st.subheader(f"Actual vs Predicted GAS_MMBTU – {product}")
+
+            row = summary_df[summary_df["Product"] == product]
+            if not row.empty:
+                r2 = row["R²"].values[0]
+                rmse = row["RMSE"].values[0]
+                mae = row["MAE"].values[0]
+                st.caption(f"R² = {r2:.3f} | RMSE = {rmse:.3f} | MAE = {mae:.3f}")
+
+            fig = product_figs.get(product)
+            if fig is not None:
+                st.pyplot(fig, use_container_width=True)
+            else:
+                st.info("Tidak ada grafik untuk produk ini (mungkin data/model tidak tersedia).")
+
+
+
+def page_eda():
+    st.subheader("4️⃣ Exploratory Data Analysis (EDA) – Data Konsumsi Gas Spray Dryer")
+
+    st.markdown(
+        """
+        Halaman ini digunakan untuk melakukan **Exploratory Data Analysis (EDA)** terhadap
+        dataset disagregasi spray dryer yang sama dengan halaman **Monitoring Model**.
+        
+        Kamu bisa:
+        - Menggunakan **dataset default** dari path lokal, atau
+        - Meng-upload **dataset baru (CSV)** untuk dianalisis.
+        """
+    )
+
+    # ------------------------------------------------------
+    # 1. Konfigurasi sumber data
+    # ------------------------------------------------------
+    st.markdown("#### ⚙️ Konfigurasi Sumber Data")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        data_path = st.text_input(
+            "Path Data Disaggregated (default)",
+            value=DATA_FILENAME,
+            help="Dipakai jika tidak ada file yang di-upload."
+        )
+    with col2:
+        st.caption(
+            "Pastikan struktur kolom sama dengan dataset yang digunakan di halaman **Monitoring Model** "
+            "(minimal kolom: `Date_time`, `Product`, parameter proses, dan kolom gas)."
+        )
+
+    st.markdown("#### 📂 Upload Dataset untuk EDA (Opsional)")
+    uploaded_file = st.file_uploader(
+        "Upload file CSV untuk dianalisis",
+        type=["csv"],
+        key="eda_upload",
+    )
+
+    run_btn = st.button(
+        "🔁 Refresh / Jalankan EDA",
+        type="primary",
+        use_container_width=True,
+        key="eda_run_btn",
+    )
+
+    if not run_btn:
+        st.info(
+            "• Upload dataset baru (opsional), kemudian klik **Refresh / Jalankan EDA**.\n\n"
+            "• Jika tidak upload apa-apa, sistem akan menggunakan **dataset default** dari path di atas."
+        )
+        return
+
+    # ------------------------------------------------------
+    # 2. Load data (upload > default path)
+    # ------------------------------------------------------
+    if uploaded_file is not None:
+        try:
+            df_raw = pd.read_csv(uploaded_file)
+            st.success("✅ Dataset baru berhasil dibaca dan akan digunakan untuk EDA.")
+        except Exception as e:
+            st.error(f"❌ Gagal membaca file CSV yang di-upload: {e}")
+            return
+    else:
+        try:
+            df_raw = pd.read_csv(data_path)
+            st.warning("Tidak ada file yang di-upload. Menggunakan dataset default dari path di atas.")
+        except Exception as e:
+            st.error(f"❌ Gagal membaca dataset default dari `{data_path}`: {e}")
+            return
+
+    if df_raw.empty:
+        st.error("Dataset kosong. Tidak ada yang bisa dianalisis.")
+        return
+
+    # Pastikan kolom Date_time ada dan dikonversi
+    if "Date_time" in df_raw.columns:
+        df_raw["Date_time"] = pd.to_datetime(df_raw["Date_time"], errors="coerce")
+    else:
+        st.warning("Kolom 'Date_time' tidak ditemukan. EDA tetap berjalan, tapi fitur berbasis waktu terbatas.")
+
+    # ------------------------------------------------------
+    # 3. Data Summary (metric cards)
+    # ------------------------------------------------------
+    PROCESS_PARAMS = [
+        "D101330TT",
+        "D102260TIC_CV",
+        "D102265TIC_PV",
+        "D102265TIC_CV",
+        "D102266TIC",
+        "D101264FTSCL",
+    ]
+
+    summary = compute_eda_summary(df_raw, date_col="Date_time", product_col="Product")
+
+    date_min = summary["date_min"]
+    date_max = summary["date_max"]
+    date_range_text = "-"
+    if pd.notna(date_min) and pd.notna(date_max):
+        date_range_text = f"{date_min:%Y-%m-%d %H:%M} → {date_max:%Y-%m-%d %H:%M}"
+
+    st.markdown("### 📊 Data Summary")
+
+    m1, m2, m3, m4, m5  = st.columns(5)
+    m1.metric("Total Rows", f"{summary['total_rows']:,}")
+    m2.metric("Total Columns", f"{summary['total_columns']}")
+    m3.metric("Total Missing Values", f"{summary['total_missing']:,}")
+    m4.metric("Jumlah Unique Product", f"{summary['unique_products']}")
+    m5.metric("Data Duplikat", f"{summary['duplicate_rows']:,}" if "duplicate_rows" in summary else "-")
+
+    with st.expander("📦 Detail Jumlah Data per Produk"):
+        if summary["product_counts"]:
+            product_count_df = (
+                pd.DataFrame(list(summary["product_counts"].items()), columns=["Product", "Count"])
+                .sort_values("Product")
+            )
+            st.dataframe(product_count_df, use_container_width=True)
+        else:
+            st.write("Tidak ada kolom 'Product' atau tidak ada data produk.")
+
+    # ------------------------------------------------------
+    # 3b. Anomali data (error validasi / anomaly_df)
+    # ------------------------------------------------------
+    st.markdown("---")
+    st.markdown("### ⚠️ Ringkasan Anomali Data")
+
+    anomaly_df = compute_anomaly_table(df_raw, product_col="Product")
+    if anomaly_df.empty:
+        st.info("Tidak ditemukan anomali berdasarkan rule yang didefinisikan.")
+    else:
+        st.dataframe(anomaly_df, use_container_width=True)
+
+    st.markdown("---")
+
+    # ------------------------------------------------------
+    # 4. Segmen produksi (precompute sekali)
+    # ------------------------------------------------------
+    segments_df = compute_production_segments(df_raw, product_col="Product", time_col="Date_time")
+
+    # ------------------------------------------------------
+    # 5. Tabs per produk (All Data + tiap produk)
+    # ------------------------------------------------------
+    st.markdown("### 🔍 EDA per Produk")
+
+    product_counts = summary["product_counts"]
+    product_names = list(product_counts.keys()) if product_counts else []
+
+    # Urutan prioritas tab seperti requirement
+    PRIORITY_PRODUCTS = ["BMR BASE", "CKP BASE", "CKR BASE", "CMR BASE", "MORIGRO BASE"]
+
+    ordered_products = (
+        [p for p in PRIORITY_PRODUCTS if p in product_names]
+        + [p for p in sorted(product_names) if p not in PRIORITY_PRODUCTS]
+    )
+
+    tab_labels = ["All Data"] + ordered_products
+    tabs = st.tabs(tab_labels)
+
+    def highlight_min_max_rows(row):
+        if row.name == "min":
+            return ["background-color: #f8d7da"] * len(row)  # merah muda
+        elif row.name == "max":
+            return ["background-color: #d4edda"] * len(row)  # hijau muda
+        return [""] * len(row)
+
+    for idx, label in enumerate(tab_labels):
+        with tabs[idx]:
+            if label == "All Data":
+                df_tab = df_raw.copy()
+                title_suffix = "All Data"
+            else:
+                df_tab = df_raw[df_raw["Product"] == label].copy()
+                title_suffix = label
+
+            if df_tab.empty:
+                st.warning(f"Tidak ada data untuk: **{label}**")
+                continue
+
+            # 1️⃣ Distribusi parameter utama (2x3 grid, matplotlib)
+            st.markdown(f"#### 1️⃣ Distribusi Parameter Proses – {title_suffix}")
+            fig_dist = create_line_plots(
+                df_tab,
+                params=PROCESS_PARAMS,
+                product_label=title_suffix,
+                time_col="Date_time",
+            )
+            st.pyplot(fig_dist, use_container_width=True)
+
+            # 2️⃣ Outlier detection & visualisasi (2x3 grid, matplotlib)
+            st.markdown(f"#### 2️⃣ Outlier Detection & Visualisasi – {title_suffix}")
+            fig_out, total_outliers, outlier_stats_df = identify_outliers(
+                df_tab,
+                PROCESS_PARAMS,
+                product_label=title_suffix,
+                time_col="Date_time",
+            )
+            st.pyplot(fig_out, use_container_width=True)
+
+            st.caption(
+                f"Total outliers terdeteksi: **{total_outliers}** data points "
+                "(metode IQR per parameter)."
+            )
+
+            with st.expander("Klik untuk lihat detail outlier per parameter"):
+                if not outlier_stats_df.empty:
+                    st.dataframe(outlier_stats_df, use_container_width=True)
+                else:
+                    st.write("Tidak ada outlier terdeteksi untuk parameter yang dianalisis.")
+
+            # 3️⃣ Statistical description table
+            st.markdown(f"#### 3️⃣ Statistical Description – {title_suffix}")
+            desc_df = compute_stats_table(df_tab, PROCESS_PARAMS, target_col=TARGET_COLUMN)
+
+            if desc_df.empty:
+                st.info("Tidak ada kolom numerik yang cukup untuk dihitung statistik deskriptif.")
+            else:
+                styled_desc = (
+                    desc_df.style
+                    .format("{:.3f}")
+                    .apply(highlight_min_max_rows, axis=0)
+                )
+                st.dataframe(styled_desc, use_container_width=True)
+
+            # 4️⃣ Segmen produksi per produk
+            st.markdown(f"#### 4️⃣ Segmen Produksi – {title_suffix}")
+
+            if segments_df.empty or "Product" not in segments_df.columns:
+                st.info("Segmen produksi tidak tersedia (kolom waktu/produk tidak lengkap).")
+            else:
+                if label == "All Data":
+                    seg_to_show = segments_df.copy()
+                else:
+                    seg_to_show = segments_df[segments_df["Product"] == label].copy()
+
+                if seg_to_show.empty:
+                    st.info(f"Tidak ada segmen produksi untuk {title_suffix}.")
+                else:
+                    seg_to_show = seg_to_show.sort_values(["Product", "Start_Time"])
+                    seg_to_show["Duration_Minutes"] = seg_to_show["Duration_Minutes"].round(1)
+                    st.dataframe(
+                        seg_to_show[["Product", "Start_Time", "End_Time", "Duration_Minutes", "Data_Points"]],
+                        use_container_width=True,
+                    )
+def disagregasi_data():
+    st.subheader("5️⃣ Disagregasi Konsumsi Gas Spray Dryer")
+
+    st.markdown(
+        """
+        Halaman ini digunakan untuk mengubah data konsumsi gas **per jam** menjadi 
+        data **per menit** menggunakan **disagregasi berbasis bobot indikator proses** 
+        (weight split proporsional).
+
+        **Alur:**
+        1. Upload file CSV (struktur sama dengan data training, minimal kolom: 
+           `Date_time`, `fixed_rounded_time`, `GAS_MMBTU`, dan 6 indikator proses).
+        2. Klik tombol **Jalankan Proses Disagregasi Sekarang**.
+        3. Sistem menjalankan pipeline disagregasi dan menampilkan ringkasan + hasil dalam bentuk CSV yang bisa diunduh.
+        """
+    )
+
+    st.markdown("### 📂 Upload Data Sumber (Per Jam)")
+
+    uploaded_file = st.file_uploader(
+        "Unggah file CSV data konsumsi gas (per jam) untuk didisagregasi",
+        type="csv",
+        key="disagg_upload",
+    )
+
+    if uploaded_file is None:
+        st.info(
+            "Silakan unggah file CSV terlebih dahulu.\n\n"
+            "Pastikan file memiliki kolom:\n"
+            "- `Date_time`\n"
+            "- `fixed_rounded_time` (timestamp jam, misal: 2025-03-18 01:00:00)\n"
+            "- `GAS_MMBTU` (total gas per jam)\n"
+            "- 6 indikator proses: `D101330TT`, `D102260TIC_CV`, `D102265TIC_PV`, "
+            "`D102265TIC_CV`, `D102266TIC`, `D101264FTSCL`"
+        )
+        return
+
+    # Tombol utama
+    run_btn = st.button(
+        "🚀 Jalankan Proses Disagregasi Sekarang",
+        type="primary",
+        use_container_width=True,
+        key="disagg_run_btn",
+    )
+
+    if not run_btn:
+        return
+
+    # Jalankan pipeline
+    with st.spinner("Sedang melakukan disagregasi... Mohon tunggu 10–20 detik"):
+        df_result, report = run_disagregasi_pipeline(uploaded_file, min_minutes_threshold=50)
+
+    if df_result.empty:
+        st.error("❌ Proses disagregasi gagal atau tidak ada jam yang memenuhi kriteria validasi.")
+        reason = report.get("reason", "")
+        if reason == "no_valid_hours":
+            st.warning(
+                "Tidak ada jam dengan jumlah menit ≥ ambang batas (default 50 menit). "
+                "Silakan cek kembali data input."
+            )
+        return
+
+    st.markdown("## ✅ SELESAI! Proses Disagregasi Berhasil")
+
+    # ===============================
+    # RINGKASAN EKSEKUSI PIPELINE
+    # ===============================
+    st.markdown("### 📊 Ringkasan Eksekusi Pipeline")
+
+    total_jam = report.get("total_jam_input", 0)
+    jam_valid = report.get("jam_valid", 0)
+    jam_tidak_valid = report.get("jam_tidak_valid", 0)
+    total_baris_input = report.get("total_baris_input", 0)
+    total_baris_diproses = report.get("total_baris_diproses", 0)
+    persen_diproses = report.get("persentase_data_diproses", 0.0)
+    total_selisih = report.get("total_selisih_disagregasi", 0.0)
+
+    cols = st.columns(6)
+    cols[0].metric("Total jam dalam dataset", f"{total_jam}")
+    cols[1].metric("Jam valid (diproses)", f"{jam_valid}", "Success")
+    cols[2].metric("Jam tidak valid (skip)", f"{jam_tidak_valid}", "Warning")
+    cols[3].metric(
+        "Total baris yang diproses",
+        f"{total_baris_diproses:,} / {total_baris_input:,}"
+    )
+    cols[4].metric(
+        "Persentase data yang digunakan",
+        f"{persen_diproses:.2f}%",
+        "Success" if persen_diproses >= 95 else ""
+    )
+    cols[5].metric(
+        "Ak. disagregasi (total selisih)",
+        f"{total_selisih:.10f}",
+        "Success" if total_selisih < 1e-8 else "Periksa"
+    )
+
+    # ===============================
+    # TAHAP-Tahap Proses
+    # ===============================
+    st.markdown("### 🧩 Tahap-Tahap Proses Disagregasi")
+
+    # Tahap 1: Validasi Jam Produksi
+    st.success("**Tahap 1: Validasi Jam Produksi**")
+    st.write(
+        f"- Total jam dalam dataset: **{total_jam} jam**\n"
+        f"- Jam valid (diproses): **{jam_valid} jam**\n"
+        f"- Jam tidak valid (di-skip karena durasi < 50 menit): **{jam_tidak_valid} jam**"
+    )
+
+    jam_tidak_valid_detail = report.get("jam_tidak_valid_detail")
+    if jam_tidak_valid_detail is not None and not jam_tidak_valid_detail.empty:
+        with st.expander("📋 Lihat Daftar Jam Tidak Valid"):
+            jam_tidak_valid_detail_sorted = jam_tidak_valid_detail.sort_values(
+                "Jumlah_Menit"
+            )
+            st.dataframe(jam_tidak_valid_detail_sorted, use_container_width=True)
+
+    # Tahap 2 & 3: Perhitungan Bobot & Disagregasi
+    st.info("**Tahap 2 & 3: Perhitungan Bobot & Disagregasi**")
+    st.write(
+        "- Indikator proses yang digunakan:\n"
+        "  `D101330TT`, `D102260TIC_CV`, `D102265TIC_PV`, "
+        "`D102265TIC_CV`, `D102266TIC`, `D101264FTSCL`"
+    )
+    weight_min = report.get("weight_min", None)
+    weight_max = report.get("weight_max", None)
+    if weight_min is not None and weight_max is not None:
+        st.write(
+            f"- Rentang bobot (w_m): **{weight_min:.4f} → {weight_max:.4f}**\n"
+            "- Disagregasi selesai dilakukan untuk seluruh jam valid."
+        )
+
+    # Tahap 4: Validasi Akurasi
+    st.success("**Tahap 4: Validasi Akurasi (Kunci Keberhasilan!)**")
+    validation_df = report.get("validation_df")
+    if validation_df is not None and not validation_df.empty:
+        max_diff = validation_df["Difference"].abs().max()
+        st.write(
+            f"- Total jam divalidasi: **{len(validation_df)} jam**\n"
+            f"- Total selisih (original vs hasil): **{total_selisih:.10f}**\n"
+            f"- Selisih maksimum per jam: **{max_diff:.10f}**"
+        )
+        if total_selisih < 1e-8:
+            st.success("→ **VALIDASI BERHASIL: Total gas terjaga SEMPURNA (akurasi ~100%)**")
+
+        with st.expander("🔎 Lihat Laporan Validasi Lengkap per Jam"):
+            st.dataframe(validation_df, use_container_width=True)
+
+    # Tahap 5: Output Final
+    st.info("**Tahap 5: Output Final**")
+    n_rows, n_cols = df_result.shape
+    st.write(
+        f"- Dimensi data hasil: **{n_rows:,} baris × {n_cols} kolom**\n"
+        "- Kolom baru: `GAS_MMBTU_Disaggregated`\n"
+        "- Semua kolom asli tetap dipertahankan."
+    )
+
+    # ===============================
+    # Analisis Hasil Disagregasi
+    # ===============================
+    st.markdown("### 📈 Analisis Hasil Disagregasi")
+
+    stats = report.get("gas_disagg_stats", None)
+    if stats is not None:
+        st.markdown("**Statistik Konsumsi Gas per Menit (Setelah Disagregasi)**")
+        st.markdown(
+            "```text\n"
+            f"Mean  : {stats['mean']:.3f} MMBTU/menit\n"
+            f"Std   : {stats['std']:.3f}\n"
+            f"Min   : {stats['min']:.3f}\n"
+            f"25%   : {stats['25%']:.3f}\n"
+            f"50%   : {stats['50%']:.3f}\n"
+            f"75%   : {stats['75%']:.3f}\n"
+            f"Max   : {stats['max']:.3f}\n"
+            "```"
+        )
+
+    top_hours = report.get("top_hours", None)
+    if top_hours is not None and not top_hours.empty:
+        st.markdown("**10 Jam dengan Konsumsi Gas Tertinggi (Total per Jam)**")
+        df_top = top_hours.reset_index()
+        df_top.columns = ["fixed_rounded_time", "Total_GAS_MMBTU"]
+        st.dataframe(df_top, use_container_width=True)
+
+    zero_hours = report.get("zero_hours", None)
+    if zero_hours is not None and not zero_hours.empty:
+        st.markdown("**Jam dengan Konsumsi Gas = 0 (Kemungkinan Shutdown)**")
+        df_zero = zero_hours.reset_index()
+        df_zero.columns = ["fixed_rounded_time", "Total_GAS_MMBTU"]
+        st.dataframe(df_zero, use_container_width=True)
+
+    # ===============================
+    # Tombol Aksi
+    # ===============================
+    st.markdown("### 📥 Aksi Lanjutan")
+
+    csv_bytes = df_result.to_csv(index=False).encode("utf-8")
+    st.download_button(
+        "📥 Download Data Hasil Disagregasi (CSV)",
+        data=csv_bytes,
+        file_name="hasil_disagregasi_spraydryer.csv",
+        mime="text/csv",
+        use_container_width=True,
+    )
+
+def filter_rule_engine():
+    st.title("Filter Data dengan Rule Engine")
+    st.markdown("**Upload file hasil disagregasi → Otomatis deteksi & hapus anomali → Download data bersih**")
+
+    uploaded_file = st.file_uploader("Upload file CSV hasil disagregasi", type="csv")
+
+    if uploaded_file is not None:
+        df = pd.read_csv(uploaded_file)
+        st.success(f"File berhasil diupload: {len(df):,} baris")
+
+        if st.button("Jalankan Rule Engine", type="primary", use_container_width=True):
+            with st.spinner("Mendeteksi anomali..."):
+                df_clean, df_anomalies, summary = apply_rule_engine(df)
+
+            st.success("Rule Engine selesai!")
+            st.balloons()
+
+            # --- Ringkasan ---
+            col1, col2, col3, col4 = st.columns(4)
+            col1.metric("Total Baris Awal", f"{summary['total_rows_initial relator']:,}")
+            col2.metric("Baris Bersih", f"{summary['total_rows_clean']:,}")
+            col3.metric("Anomali Dihapus", f"{summary['total_anomalies']:,}", 
+                       f"-{summary['anomaly_percentage']}%")
+            col4.metric("Data Bersih", f"{100 - summary['anomaly_percentage']:.2f}%")
+
+            # --- Detail Anomali ---
+            st.subheader("Detail Jenis Anomali yang Dihapus")
+            breakdown_df = pd.DataFrame([
+                {"Jenis Anomali": reason, "Jumlah": count, "Persentase": f"{count/len(df)*100:.2f}%"}
+                for reason, count in summary['anomaly_breakdown'].items()
+            ])
+            st.dataframe(breakdown_df, use_container_width=True, hide_index=True)
+
+            # --- Download ---
+            csv_clean = df_clean.to_csv(index=False).encode()
+            csv_anomalies = df_anomalies.to_csv(index=False).encode()
+
+            col1, col2 = st.columns(2)
+            with col1:
+                st.download_button(
+                    "Download Data Bersih (Siap Modelling)",
+                    csv_clean,
+                    "data_bersih_spray_dryer.csv",
+                    "text/csv"
+                )
+            with col2:
+                st.download_button(
+                    "Download Data Anomali (untuk Review)",
+                    csv_anomalies,
+                    "data_anomali_dihapus.csv",
+                    "text/csv"
+                )
+
+            with st.expander("Lihat contoh baris yang dihapus"):
+                st.dataframe(df_anomalies[['Date_time', 'anomaly_reason']].head(20))
+
+def filter_rule_engine():
+    st.subheader("6️⃣ Filter Data dengan Rule Engine – Deteksi & Penghapusan Anomali")
+    st.caption("Memastikan data berkualitas yang digunakan untuk analisis dan modelling.")
+
+    st.markdown(
+        """
+        Halaman ini digunakan untuk melakukan **pembersihan data otomatis** menggunakan 
+        **Rule Engine** berbasis domain knowledge, dengan input berupa 
+        **file hasil disagregasi** (sudah memiliki kolom `GAS_MMBTU_Disaggregated`).
+        """
+    )
+
+    st.markdown("### 📂 Upload Data Hasil Disagregasi")
+    uploaded_file = st.file_uploader(
+        "Upload file CSV hasil disagregasi (per menit, sudah ada kolom GAS_MMBTU_Disaggregated)",
+        type="csv",
+        key="rule_engine_upload",
+    )
+
+    if uploaded_file is None:
+        st.info(
+            "Silakan upload file CSV hasil disagregasi terlebih dahulu.\n\n"
+            "Pastikan minimal ada kolom:\n"
+            "- `Date_time`\n"
+            "- `Product`\n"
+            "- `GAS_MMBTU_Disaggregated`\n"
+            "- Parameter proses utama: `D101330TT`, `D102260TIC_CV`, `D102265TIC_PV`, "
+            "`D102265TIC_CV`, `D102266TIC`, `D101264FTSCL`, `D101463PIC_PV`"
+        )
+        return
+
+    run_btn = st.button(
+        "🚦 Jalankan Rule Engine",
+        type="primary",
+        use_container_width=True,
+        key="rule_engine_run_btn",
+    )
+
+    if not run_btn:
+        return
+
+    # ---------------------------------------------------
+    # Jalankan Rule Engine
+    # ---------------------------------------------------
+    try:
+        df_input = pd.read_csv(uploaded_file)
+    except Exception as e:
+        st.error(f"❌ Gagal membaca file CSV: {e}")
+        return
+
+    with st.spinner("Mendeteksi anomali dan melakukan pembersihan data..."):
+        df_clean, df_anomalies, summary = apply_rule_engine(df_input)
+
+    st.success("Rule Engine selesai dijalankan! Data siap digunakan untuk analisis & modelling.")
+    st.balloons()
+
+    total_initial = summary.get("total_rows_initial", len(df_input))
+    total_after = summary.get("total_rows_after_filter", len(df_clean))
+    total_removed = summary.get("total_rows_removed", total_initial - total_after)
+    percent_clean = summary.get("percent_clean", (total_after / total_initial * 100 if total_initial > 0 else 0.0))
+    num_anomaly_types = summary.get("num_anomaly_types", 0)
+    cip_removed = summary.get("cip_rows_removed", 0)
+    rule_removed = summary.get("rule_rows_removed", total_removed - cip_removed)
+
+    # ---------------------------------------------------
+    # Ringkasan Hasil Pembersihan Data (6 metric)
+    # ---------------------------------------------------
+    st.markdown("### 📊 Ringkasan Hasil Pembersihan Data")
+
+    m1, m2, m3, m4, m5 = st.columns(5)
+
+    m1.metric("Total baris awal", f"{total_initial:,}")
+    m2.metric("Total baris setelah filter", f"{total_after:,}")
+    m3.metric("Total baris dihapus (termasuk CIP)", f"{total_removed:,}")
+    m4.metric("Jumlah jenis anomali", f"{num_anomaly_types}")
+    m5.metric(
+        "Total baris dihapus tanpa CIP",
+        f"{rule_removed:,}",
+        delta=f"{cip_removed:,} baris CIP",)
+
+
+    # ---------------------------------------------------
+    # Detail Anomali yang Terdeteksi
+    # ---------------------------------------------------
+    st.markdown("### 🧾 Detail Anomali yang Terdeteksi")
+
+    if df_anomalies.empty:
+        st.info("Tidak ada baris yang dihapus oleh rule engine. Semua data dianggap bersih.")
+    else:
+        if "anomaly_reason" not in df_anomalies.columns:
+            st.warning("Kolom 'anomaly_reason' tidak ditemukan di df_anomalies. Breakdown jenis anomali tidak dapat ditampilkan.")
+        else:
+            # Group by jenis anomali
+            rows = []
+            grouped = df_anomalies.groupby("anomaly_reason")
+            for i, (reason, g) in enumerate(grouped, start=1):
+                count = len(g)
+                pct = (count / total_initial * 100) if total_initial > 0 else 0.0
+
+                # Contoh baris (tanggal/waktu) – ambil sampai 3
+                if "Date_time" in g.columns:
+                    dt_series = pd.to_datetime(g["Date_time"], errors="coerce").dropna()
+                    examples = ", ".join(dt_series.astype(str).head(3).tolist())
+                else:
+                    examples = "-"
+
+                rows.append({
+                    "No": i,
+                    "Jenis Anomali": reason,
+                    "Jumlah Baris": count,
+                    "Persentase": f"{pct:.2f}%",
+                    "Contoh Baris (Tanggal/Waktu)": examples,
+                    "Status": "Dihapus",
+                })
+
+            detail_df = pd.DataFrame(rows)
+
+            st.dataframe(
+                detail_df,
+                use_container_width=True,
+                hide_index=True,
+            )
+
+    # ---------------------------------------------------
+    # Tombol Aksi (Download)
+    # ---------------------------------------------------
+    st.markdown("### 📥 Aksi Lanjutan")
+
+    col_dl1, col_dl2 = st.columns(2)
+    csv_clean = df_clean.to_csv(index=False).encode("utf-8")
+    csv_anom = df_anomalies.to_csv(index=False).encode("utf-8")
+
+    with col_dl1:
+        st.download_button(
+            "📥 Download Data Bersih (Siap Modelling)",
+            data=csv_clean,
+            file_name="data_bersih_spray_dryer_rule_engine.csv",
+            mime="text/csv",
+            use_container_width=True,
+        )
+
+    with col_dl2:
+        st.download_button(
+            "📥 Download Data Anomali yang Dihapus",
+            data=csv_anom,
+            file_name="data_anomali_spray_dryer_rule_engine.csv",
+            mime="text/csv",
+            use_container_width=True,
+        )
+
+    # ---------------------------------------------------
+    # Expander: Lihat Semua Baris yang Dihapus
+    # ---------------------------------------------------
+    with st.expander("🔍 Lihat Semua Baris yang Dihapus (Detail Anomali)"):
+        if df_anomalies.empty:
+            st.write("Tidak ada baris yang dihapus.")
+        else:
+            cols_to_show = ["Date_time", "Product", "anomaly_reason"]
+            cols_existing = [c for c in cols_to_show if c in df_anomalies.columns]
+            other_cols = [c for c in df_anomalies.columns if c not in cols_existing]
+
+            st.dataframe(
+                df_anomalies[cols_existing + other_cols],
+                use_container_width=True,
+            )
+
+
+def main():
+    # Judul besar sistem (selalu tampil di atas)
+    st.title("Sistem Prediksi dan Rekomendasi Parameter Berdasarkan Input Gas Consumption (MMBTU)")
+
+    st.caption(
+        "Platform internal untuk memprediksi konsumsi gas dan merekomendasikan parameter proses "
+        "berdasarkan histori operasi spray dryer."
+    )
+
+    # Sidebar navigasi utama
+    with st.sidebar:
+        st.header("📂 Menu Utama")
+        menu = st.radio(
+            "Pilih Halaman",
+            [
+                "1. Prediksi Gas dari 6 Parameter",
+                "2. Prediksi Parameter dari Gas (MMBTU)",
+                "3. Monitoring Model",
+                "4. EDA",
+                "5. Disagregasi Data",
+                "6. Filter Rule Engine"
+            ]
+        )
+
+    # Ringkasan di bagian atas main page (opsional, bisa kamu modif)
+    if menu.startswith("1."):
+        page_prediksi_gas_dari_6_parameter()
+    elif menu.startswith("2."):
+        page_prediksi_parameter_dari_gas()
+    elif menu.startswith("3."):
+        page_monitoring_model()
+    elif menu.startswith("4."):
+        page_eda()
+    elif menu.startswith("5."):
+        disagregasi_data()
+    elif menu.startswith("6."):
+        filter_rule_engine()
+
+if __name__ == "__main__":
+    main()

Disagregasi_mmbtu.py

@@ -0,0 +1,321 @@
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+import warnings
+warnings.filterwarnings('ignore')
+
+def pipeline_disagregasi(Data_Terbaru, min_minutes_threshold=50):
+    """
+    Pipeline untuk disagregasi data dengan validasi jam produksi
+    
+    Parameters:
+    -----------
+    Data_Terbaru : DataFrame
+        DataFrame input dengan kolom yang diperlukan
+    min_minutes_threshold : int
+        Minimum jumlah menit per jam untuk proses disagregasi (default: 50)
+    
+    Returns:
+    --------
+    df_disaggregated_final : DataFrame
+        DataFrame hasil disagregasi
+    validation_report : dict
+        Laporan validasi dan statistik
+    """
+    
+    print("="*60)
+    print("PIPELINE DISAGREGASI DATA DENGAN VALIDASI JAM PRODUKSI")
+    print("="*60)
+    
+    # Simpan daftar kolom asli untuk memastikan semuanya dipertahankan
+    original_cols = list(Data_Terbaru.columns)
+    
+    # ========================================
+    # TAHAP 1: VALIDASI JAM PRODUKSI
+    # ========================================
+    print("\n--- TAHAP 1: Validasi Jam Produksi ---")
+    
+    # Hitung jumlah data (menit) per jam
+    jumlah_data_per_jam = Data_Terbaru.groupby('fixed_rounded_time').size()
+    jumlah_data_per_jam_df = jumlah_data_per_jam.reset_index(name='Jumlah_Menit')
+    
+    # Identifikasi jam yang valid (>= 50 menit)
+    jam_valid = jumlah_data_per_jam_df[jumlah_data_per_jam_df['Jumlah_Menit'] >= min_minutes_threshold]['fixed_rounded_time'].tolist()
+    jam_tidak_valid = jumlah_data_per_jam_df[jumlah_data_per_jam_df['Jumlah_Menit'] < min_minutes_threshold]
+    
+    print(f"Total jam dalam dataset: {len(jumlah_data_per_jam_df)}")
+    print(f"Jam valid (>= {min_minutes_threshold} menit): {len(jam_valid)}")
+    print(f"Jam tidak valid (< {min_minutes_threshold} menit): {len(jam_tidak_valid)}")
+    
+    # Tampilkan detail jam yang tidak valid
+    if len(jam_tidak_valid) > 0:
+        print("\nDetail jam yang TIDAK akan diproses:")
+        print(jam_tidak_valid.sort_values('Jumlah_Menit')[['fixed_rounded_time', 'Jumlah_Menit']].to_string(index=False))
+    else:
+        print("\nSemua jam valid untuk diproses!")
+    
+    # Filter data hanya untuk jam yang valid
+    df_work = Data_Terbaru[Data_Terbaru['fixed_rounded_time'].isin(jam_valid)].copy()
+    
+    if df_work.empty:
+        print("\n⚠️ PERINGATAN: Tidak ada data yang memenuhi kriteria validasi!")
+        return pd.DataFrame(), {"status": "failed", "reason": "no_valid_hours"}
+    
+    print(f"\nData yang akan diproses: {len(df_work)} baris dari {len(Data_Terbaru)} baris total")
+    print(f"Persentase data yang diproses: {len(df_work)/len(Data_Terbaru)*100:.2f}%")
+    
+    # ========================================
+    # TAHAP 2: PERHITUNGAN BOBOT INDIKATOR
+    # ========================================
+    print("\n--- TAHAP 2: Perhitungan Bobot Indikator ---")
+    
+    indicator_cols = [
+        "D101330TT", "D102260TIC_CV", "D102265TIC_PV",
+        "D102265TIC_CV", "D102266TIC", "D101264FTSCL"
+    ]
+    
+    # Handle missing values
+    df_work[indicator_cols] = df_work[indicator_cols].fillna(0)
+    
+    # Normalisasi menggunakan MinMaxScaler
+    scaled_cols = [col + '_scaled' for col in indicator_cols]
+    scaler = MinMaxScaler()
+    df_work[scaled_cols] = scaler.fit_transform(df_work[indicator_cols])
+    
+    # Hitung bobot total per baris
+    df_work['w_m'] = df_work[scaled_cols].sum(axis=1)
+    
+    print(f"Indikator yang digunakan: {', '.join(indicator_cols)}")
+    print(f"Range bobot (w_m): Min={df_work['w_m'].min():.4f}, Max={df_work['w_m'].max():.4f}")
+    
+    # ========================================
+    # TAHAP 3: APLIKASI ALGORITMA DISAGREGASI
+    # ========================================
+    print("\n--- TAHAP 3: Aplikasi Algoritma Disagregasi ---")
+    
+    # Hitung total bobot per jam
+    total_weight_per_block = df_work.groupby('fixed_rounded_time')['w_m'].transform('sum')
+    total_weight_per_block[total_weight_per_block == 0] = 1 
+    
+    # Hitung proporsi share
+    df_work['proportional_share'] = df_work['w_m'] / total_weight_per_block
+    
+    # Ambil nilai GAS_MMBTU total per jam
+    gas_total_per_block = df_work.groupby('fixed_rounded_time')['GAS_MMBTU'].transform('first')
+    
+    # Hitung GAS_MMBTU yang sudah didisagregasi
+    df_work['GAS_MMBTU_Disaggregated'] = gas_total_per_block * df_work['proportional_share']
+    
+    # Handle kasus khusus: jam dengan total bobot = 0
+    zero_weight_blocks = df_work.groupby('fixed_rounded_time')['w_m'].sum()
+    zero_weight_blocks = zero_weight_blocks[zero_weight_blocks == 0].index
+    
+    if not zero_weight_blocks.empty:
+        print(f"⚠️ Ditemukan {len(zero_weight_blocks)} jam dengan total bobot = 0")
+        print("   Menggunakan distribusi merata untuk jam tersebut")
+        
+        for block_time in zero_weight_blocks:
+            mask = df_work['fixed_rounded_time'] == block_time
+            gas_value = df_work.loc[mask, 'GAS_MMBTU'].iloc[0]
+            count_in_block = mask.sum()
+            df_work.loc[mask, 'GAS_MMBTU_Disaggregated'] = gas_value / count_in_block if count_in_block > 0 else 0
+    
+    print("✓ Disagregasi selesai dilakukan")
+    
+    # ========================================
+    # TAHAP 4: VALIDASI HASIL DISAGREGASI
+    # ========================================
+    print("\n--- TAHAP 4: Validasi Hasil Disagregasi ---")
+    
+    # Bandingkan total per jam
+    original_total = df_work.groupby('fixed_rounded_time')['GAS_MMBTU'].first()
+    disaggregated_total = df_work.groupby('fixed_rounded_time')['GAS_MMBTU_Disaggregated'].sum()
+    
+    validation_df = pd.DataFrame({
+        'Original_Total': original_total,
+        'Disaggregated_Total': disaggregated_total,
+        'Difference': original_total - disaggregated_total
+    })
+    
+    # Statistik validasi
+    max_diff = validation_df['Difference'].abs().max()
+    total_diff = validation_df['Difference'].abs().sum()
+    
+    print(f"Jumlah jam yang divalidasi: {len(validation_df)}")
+    print(f"Total selisih absolut: {total_diff:.10f}")
+    print(f"Selisih maksimum: {max_diff:.10f}")
+    
+    if total_diff < 1e-8:
+        print("✓ Validasi BERHASIL: Total gas terjaga dengan sempurna")
+    else:
+        print("⚠️ PERINGATAN: Terdapat selisih kecil dalam disagregasi")
+    
+    # Tampilkan 5 jam dengan selisih terbesar
+    if max_diff > 1e-10:
+        print("\n5 Jam dengan selisih terbesar:")
+        top_diff = validation_df.nlargest(5, 'Difference')[['Original_Total', 'Disaggregated_Total', 'Difference']]
+        print(top_diff.to_string())
+    
+    # ========================================
+    # TAHAP 5: PERSIAPAN OUTPUT FINAL
+    # ========================================
+    print("\n--- TAHAP 5: Persiapan Output Final ---")
+    
+    # --- PERUBAHAN KUNCI ---
+    # Daripada menghapus kolom, kita secara eksplisit memilih semua kolom asli
+    # ditambah kolom hasil disagregasi yang baru. Ini memastikan semua
+    # kolom lain yang tidak terpakai tetap ada di hasil akhir.
+    
+    # Tentukan daftar kolom final
+    final_cols = original_cols + ['GAS_MMBTU_Disaggregated']
+    # Hapus duplikat jika 'GAS_MMBTU_Disaggregated' sudah ada
+    final_cols = list(dict.fromkeys(final_cols))
+    
+    # Buat dataframe final dengan memilih kolom yang relevan dari df_work
+    df_disaggregated_final = df_work[final_cols]
+    
+    print(f"Dimensi data final: {df_disaggregated_final.shape}")
+    print("Kolom-kolom asli yang tidak digunakan dalam proses telah berhasil dipertahankan.")
+
+    # ========================================
+    # LAPORAN RINGKASAN
+    # ========================================
+    print("\n" + "="*60)
+    print("RINGKASAN PIPELINE")
+    print("="*60)
+    
+    validation_report = {
+        "total_jam_input": len(jumlah_data_per_jam_df),
+        "jam_valid": len(jam_valid),
+        "jam_tidak_valid": len(jam_tidak_valid),
+        "total_baris_input": len(Data_Terbaru),
+        "total_baris_diproses": len(df_work),
+        "persentase_data_diproses": len(df_work)/len(Data_Terbaru)*100 if len(Data_Terbaru) > 0 else 0,
+        "total_selisih_disagregasi": total_diff,
+        "jam_dengan_bobot_nol": len(zero_weight_blocks) if not zero_weight_blocks.empty else 0,
+        "validation_df": validation_df,
+        "jam_tidak_valid_detail": jam_tidak_valid,
+        "weight_min": float(df_work["w_m"].min()),
+        "weight_max": float(df_work["w_m"].max())
+    }
+    
+    print(f"• Total jam input: {validation_report['total_jam_input']}")
+    print(f"• Jam valid untuk disagregasi: {validation_report['jam_valid']}")
+    print(f"• Jam tidak valid (skip): {validation_report['jam_tidak_valid']}")
+    print(f"• Total baris yang diproses: {validation_report['total_baris_diproses']:,} dari {validation_report['total_baris_input']:,}")
+    print(f"• Persentase data diproses: {validation_report['persentase_data_diproses']:.2f}%")
+    print(f"• Akurasi disagregasi (total selisih): {validation_report['total_selisih_disagregasi']:.10f}")
+    
+    print("\n✅ Pipeline selesai dijalankan!")
+    
+    return df_disaggregated_final, validation_report
+
+
+# ========================================
+# FUNGSI UTILITAS TAMBAHAN
+# ========================================
+
+def analyze_disagregation_results(df_result, validation_report):
+    """
+    Analisis mendalam hasil disagregasi
+    """
+    print("\n" + "="*60)
+    print("ANALISIS HASIL DISAGREGASI")
+    print("="*60)
+    
+    # Cek jika df_result kosong
+    if df_result.empty:
+        print("Tidak ada hasil untuk dianalisis.")
+        return None
+
+    # Statistik GAS_MMBTU sebelum dan sesudah
+    print("\n📊 Statistik GAS_MMBTU_Disaggregated:")
+    print(df_result['GAS_MMBTU_Disaggregated'].describe())
+    
+    # Distribusi per jam
+    print("\n📊 Distribusi data per jam (top 10):")
+    hourly_stats = df_result.groupby('fixed_rounded_time').agg({
+        'GAS_MMBTU_Disaggregated': ['sum', 'mean', 'std', 'count']
+    }).round(4)
+    print(hourly_stats.head(10))
+    
+    # Jam dengan nilai ekstrem
+    print("\n⚠️ Jam dengan total GAS tertinggi:")
+    top_hours = df_result.groupby('fixed_rounded_time')['GAS_MMBTU_Disaggregated'].sum().nlargest(5)
+    print(top_hours)
+    
+    print("\n⚠️ Jam dengan total GAS terendah:")
+    bottom_hours = df_result.groupby('fixed_rounded_time')['GAS_MMBTU_Disaggregated'].sum().nsmallest(5)
+    print(bottom_hours)
+    
+    return hourly_stats
+
+def run_disagregasi_pipeline(file_obj, min_minutes_threshold=50):
+    """
+    Wrapper yang dipakai dashboard Streamlit.
+    - file_obj bisa berupa path string atau UploadedFile dari Streamlit.
+    - Mengembalikan: (df_hasil_disagregasi, validation_report_diperluas)
+    """
+    # Baca CSV dari file_obj (path string atau UploadedFile)
+    if isinstance(file_obj, str):
+        df_input = pd.read_csv(file_obj)
+    else:
+        # Asumsikan ini adalah UploadedFile dari st.file_uploader
+        df_input = pd.read_csv(file_obj)
+
+    # Jalankan pipeline utama
+    df_hasil, laporan = pipeline_disagregasi(
+        Data_Terbaru=df_input,
+        min_minutes_threshold=min_minutes_threshold
+    )
+
+    # Jika hasil kosong → langsung kembalikan
+    if df_hasil.empty:
+        return df_hasil, laporan
+
+    # Tambah statistik GAS_MMBTU_Disaggregated untuk kebutuhan dashboard
+    if "GAS_MMBTU_Disaggregated" in df_hasil.columns:
+        stats = df_hasil["GAS_MMBTU_Disaggregated"].describe()
+        laporan["gas_disagg_stats"] = stats
+
+        # Total per jam
+        hourly_total = (
+            df_hasil
+            .groupby("fixed_rounded_time")["GAS_MMBTU_Disaggregated"]
+            .sum()
+        )
+
+        # 10 jam dengan konsumsi gas tertinggi
+        laporan["top_hours"] = hourly_total.sort_values(ascending=False).head(10)
+
+        # Jam dengan total GAS = 0 (kemungkinan shutdown)
+        laporan["zero_hours"] = hourly_total[hourly_total == 0.0]
+
+    return df_hasil, laporan
+
+
+
+# ========================================
+# CARA PENGGUNAAN
+# ========================================
+
+# Ganti dengan path file Anda yang sebenarnya
+if __name__ == "__main__":
+    # Jalankan pipeline utama (mode CLI / testing)
+    df_hasil, laporan = pipeline_disagregasi(
+        Data_Terbaru=pd.read_csv("/work/Dataset 18 Mar - 19 Jun/Processed Data Pipeline EDA_10_17_2025.csv"),
+        min_minutes_threshold=50
+    )
+
+    # Analisis hasil (opsional)
+    stats = analyze_disagregation_results(df_hasil, laporan)
+
+    # Simpan hasil ke CSV (opsional)
+    df_hasil = df_hasil[~df_hasil['Product'].isin(['CIP', 'CIP CHAMBER'])]
+    df_hasil.to_csv('/work/Dataset 18 Mar - 19 Jun/disagregasi_data_spraydryer_terbaru_10_17_2025.csv', index=False)
+
+    # Akses detail validasi
+    print(laporan['validation_df'])
+    print(laporan['jam_tidak_valid_detail'])
+
+

Hasil_Inverse_Model.csv

@@ -0,0 +1,145 @@
+Converged,D101264FTSCL,D101330TT,D102260TIC_CV,D102265TIC_CV,D102265TIC_PV,D102266TIC,Error,Error_Pct,Iterations,Level,Objective_Value,Predicted_MMBTU,Product,Soft_Violations,Target_MMBTU,prediction
+,3955.77,93.24,53.44,31.11,174.33,18.5,0.000392,,,,,,CKR BASE,,0.2667,0.267092
+,3952.31,93.32,60.19,31.64,174.19,18.53,0.000064,,,,,,CKR BASE,,0.27,0.269936
+,3970.4,93.0,60.64,32.82,174.33,18.53,0.003857,,,,,,CKR BASE,,0.2733,0.277157
+,4290.9,94.53,62.77,47.4,180.93,16.04,0.017178,,,,,,CKR BASE,,0.2767,0.293878
+,4431.08,94.49,60.99,46.49,181.08,16.44,0.003841,,,,,,CKR BASE,,0.28,0.283841
+,4457.67,94.32,60.39,46.73,181.46,16.4,0.000053,,,,,,CKR BASE,,0.2833,0.283353
+,4476.58,94.4,61.71,44.93,180.09,16.38,0.000087,,,,,,CKR BASE,,0.2867,0.286613
+,4221.75,94.28,60.94,45.09,185.49,16.22,0.000004,,,,,,CKR BASE,,0.29,0.290004
+,4156.33,95.47,65.84,45.4,184.37,16.13,0.000005,,,,,,CKR BASE,,0.2933,0.293295
+,4314.51,94.52,64.5,46.42,185.9,16.27,0.000061,,,,,,CKR BASE,,0.2967,0.296761
+,4195.16,94.31,67.84,52.73,180.15,16.11,0.000067,,,,,,CKR BASE,,0.3,0.299933
+,4140.37,97.51,67.45,51.3,187.75,17.61,0.000041 (0.01%),,,,,,CKR BASE,,0.3033,0.303292
+,4360.28,96.65,66.48,50.23,187.79,17.35,0.000072 (0.02%),,,,,,CKR BASE,,0.3067,0.306738
+,4408.62,93.81,62.23,59.33,189.59,17.48,0.000096 (0.03%),,,,,,CKR BASE,,0.31,0.310096
+,4468.98,97.68,59.9,54.51,194.32,19.25,0.000009 (0.00%),,,,,,CKR BASE,,0.3133,0.313342
+,4481.76,92.15,67.27,55.53,193.24,19.06,0.000001 (0.00%),,,,,,CKR BASE,,0.3333,0.333332
+,4833.92,93.0,64.14,54.36,190.49,19.39,0.000010 (0.00%),,,,,,CKR BASE,,0.3367,0.33671
+,4675.53,93.3,66.21,53.31,188.33,18.82,0.000035 (0.01%),,,,,,CKR BASE,,0.34,0.340035
+,4587.25,92.91,66.09,53.97,189.73,18.78,0.000035 (0.01%),,,,,,CKR BASE,,0.3467,0.346743
+,4589.9,92.78,65.33,55.22,189.54,19.54,0.000002 (0.00%),,,,,,CKR BASE,,0.3433,0.343332
+,4615.33,92.4,65.76,54.24,190.33,18.83,0.004873 (1.39%),,,,,,CKR BASE,,0.35,0.345127
+,4195.164127,94.31367329,67.83752807,52.72994004,180.1513437,16.11178086,6.67453E-05,,,,,,CKR BASE,,0.3,0.299933255
+,4345.077523,95.73564815,61.94377257,47.97807791,178.5670734,15.94367712,0.015211162,,,,,,CKR BASE,,0.278,0.293211162
+,3714.134992,94.12849457,50.19545981,24.45841829,176.6102062,17.71849347,0.041373372,,,,,,CKR BASE,,0.25,0.291373372
+,4329.033348,96.36362196,61.44665789,47.72381537,177.4725578,16.00013482,0.017786913,,,,,,CKR BASE,,0.276,0.293786913
+,4221.747978,94.27552004,60.94445271,45.09113873,185.4924565,16.22248105,4.49181E-06,,,,,,CKR BASE,,0.29,0.290004492
+,4492.864459,94.21253004,61.40316114,46.06813204,180.9288264,16.4082628,6.45216E-05,,,,,,CKR BASE,,0.287,0.286935478
+,4474.17151,94.69035643,62.42412584,46.69251985,185.2116553,16.41205744,5.86555E-05,,,,,,CKR BASE,,0.289,0.289058656
+,3941.755261,93.92589611,44.02782054,21.35222818,174.9003476,18.31076668,0.034599949,,,,,,CKR BASE,,0.23,0.264599949
+,3935.359007,93.82213382,44.06991256,21.19780621,174.4379727,18.34101723,0.030370471,,,,,,CKR BASE,,0.234,0.264370471
+,3934.465917,94.2948149,44.12207343,21.16965631,174.5110539,18.33528665,0.054408622,,,,,,CKR BASE,,0.212,0.266408622
+,4496.939745,94.48287836,60.40561786,46.98256551,179.586896,16.3735464,7.61817E-05,,,,,,CKR BASE,,0.2865,0.286576182
+,3939.045858,94.37142197,44.09776324,21.14782051,174.5390788,18.32985818,0.056263753,,,,,,CKR BASE,,0.21,0.266263753
+,3960.72,96.25,50.99,18.7,170.17,18.36,0.000049,,,,,,CMR BASE,,0.2667,0.266749
+,4022.34,97.5,50.49,18.54,176.04,16.45,0.000016,,,,,,CMR BASE,,0.27,0.269984
+,4112.43,98.52,55.82,21.49,169.98,16.67,0.000025,,,,,,CMR BASE,,0.2733,0.273275
+,3995.18,96.52,52.26,36.78,172.76,18.57,0.00008,,,,,,CMR BASE,,0.2767,0.27662
+,3920.17,95.81,55.88,38.57,172.86,18.57,0.000011,,,,,,CMR BASE,,0.28,0.279989
+,4212.96,98.78,53.91,24.09,173.13,19.01,0.000019,,,,,,CMR BASE,,0.2833,0.283281
+,4018.11,97.85,61.8,28.33,178.51,16.55,0.000051,,,,,,CMR BASE,,0.2867,0.286751
+,4234.78,98.53,61.17,23.86,175.44,16.48,0.000078,,,,,,CMR BASE,,0.29,0.290078
+,4074.51,98.44,63.57,26.17,183.23,18.89,0.000091,,,,,,CMR BASE,,0.2933,0.293391
+,4280.19,96.32,61.46,24.87,185.23,19.01,0.000091,,,,,,CMR BASE,,0.2967,0.296609
+,4275.9,93.46,60.26,29.42,184.92,18.92,0.000063,,,,,,CMR BASE,,0.3,0.300063
+,4460.72,94.73,61.74,31.95,184.81,17.66,0.000002,,,,,,CMR BASE,,0.3033,0.303298
+,4423.21,92.59,61.8,29.02,181.42,18.31,0.00004,,,,,,CMR BASE,,0.3067,0.30666
+,4105.81,95.59,56.25,30.73,177.18,17.26,0.000075,,,,,,CMR BASE,,0.31,0.310075
+,4511.25,98.45,53.97,27.77,185.56,17.09,0.000093,,,,,,CMR BASE,,0.3133,0.313393
+,4545.64,95.05,56.61,34.31,178.17,17.13,0.000099,,,,,,CMR BASE,,0.3167,0.316799
+,4387.78,95.76,51.89,27.58,181.26,17.22,0.00004,,,,,,CMR BASE,,0.32,0.32004
+,4247.24,95.56,50.73,36.75,182.35,17.12,0.000026,,,,,,CMR BASE,,0.3233,0.323326
+,4320.47,94.24,53.0,35.12,181.15,17.63,0.000008,,,,,,CMR BASE,,0.3267,0.326692
+,4280.32,97.17,51.85,37.78,180.91,17.3,0.000049,,,,,,CMR BASE,,0.33,0.330049
+,4292.95,92.68,54.28,34.86,181.28,17.64,0.002914,,,,,,CMR BASE,,0.3333,0.330386
+,4323.88,92.73,54.1,31.21,181.95,17.63,0.008765,,,,,,CMR BASE,,0.3367,0.327935
+,4371.36,93.22,54.18,31.47,182.42,17.58,0.012532,,,,,,CMR BASE,,0.34,0.327468
+,4404.97,92.77,54.08,31.66,183.11,17.58,0.01776,,,,,,CMR BASE,,0.3433,0.32554
+,4530.4,95.43,54.19,31.63,183.68,17.53,0.022474,,,,,,CMR BASE,,0.3467,0.324226
+,4511.7,95.23,54.68,31.56,184.31,17.54,0.028114,,,,,,CMR BASE,,0.35,0.321886
+,4232.09,92.9,55.2,40.6,173.35,17.42,0.012035,,,,,,CKP BASE,,0.2667,0.278735
+,4225.85,95.07,56.02,39.07,181.37,16.01,0.006521,,,,,,CKP BASE,,0.27,0.276521
+,4314.5,95.08,56.01,39.72,181.97,16.02,0.001893,,,,,,CKP BASE,,0.2733,0.275193
+,4320.76,94.88,63.23,41.57,173.55,17.38,0.000048,,,,,,CKP BASE,,0.2767,0.276652
+,4275.47,98.23,58.08,45.22,181.94,15.87,0.000073,,,,,,CKP BASE,,0.28,0.280073
+,4325.12,98.2,55.74,43.9,183.04,16.17,0.000049,,,,,,CKP BASE,,0.2833,0.283349
+,4336.85,94.77,57.4,39.75,177.04,16.14,0.000028,,,,,,CKP BASE,,0.2867,0.286672
+,4223.68,96.0,62.08,40.75,182.92,16.27,0.000075,,,,,,CKP BASE,,0.29,0.289925
+,4102.85,97.25,65.7,40.94,184.35,17.51,0.000013,,,,,,CKP BASE,,0.2933,0.293313
+,4180.6,93.34,61.73,40.57,177.51,17.58,0.000077,,,,,,CKP BASE,,0.2967,0.296623
+,4184.98,95.03,58.75,40.35,186.57,17.36,0.000099,,,,,,CKP BASE,,0.3,0.299901
+,4445.89,94.24,63.47,47.46,181.55,18.3,0.000063,,,,,,CKP BASE,,0.3033,0.303237
+,4277.34,93.85,64.3,43.57,182.0,17.39,0.000008,,,,,,CKP BASE,,0.3067,0.306708
+,4453.7,98.33,63.97,38.56,181.43,18.48,0.000086,,,,,,CKP BASE,,0.31,0.310086
+,4773.75,95.2,63.56,39.53,180.62,18.81,0.000038,,,,,,CKP BASE,,0.3133,0.313262
+,4535.66,97.4,62.11,45.25,179.82,17.31,0.000039,,,,,,CKP BASE,,0.3167,0.316739
+,4584.37,93.98,64.3,38.7,182.31,18.53,0.000034,,,,,,CKP BASE,,0.32,0.320034
+,4546.56,93.87,57.79,45.99,188.63,17.82,0.00006,,,,,,CKP BASE,,0.3233,0.32324
+,4870.81,97.41,55.3,37.72,182.27,18.6,0.000093,,,,,,CKP BASE,,0.3267,0.326607
+,4867.39,93.27,58.38,38.59,186.96,17.98,0.000099,,,,,,CKP BASE,,0.33,0.329901
+,4541.39,94.08,57.45,41.44,187.13,18.6,0.00005,,,,,,CKP BASE,,0.3333,0.33335
+,4410.88,93.19,59.46,44.06,183.72,18.67,0.000094,,,,,,CKP BASE,,0.3367,0.336794
+,4425.0,95.6,58.1,42.62,186.65,19.0,0.000053,,,,,,CKP BASE,,0.34,0.340053
+,4430.36,92.7,66.4,42.52,193.34,18.99,0.000018,,,,,,CKP BASE,,0.3433,0.343318
+,4532.0,93.35,59.67,39.58,186.57,18.67,0.000086,,,,,,CKP BASE,,0.3467,0.346614
+,4809.65,92.92,65.24,46.53,188.16,18.94,0.000047,,,,,,CKP BASE,,0.35,0.349953
+,4218.146647,95.08684851,56.00051072,39.59284696,181.3237826,16.0520592,0.007520789,,,,,,CKP BASE,,0.269,0.276520789
+,3795.55,98.05,55.61,28.68,181.44,18.16,0.000083,,,,,,MORIGRO BASE,,0.2667,0.266617
+,3694.83,92.72,56.65,29.32,181.89,18.19,0.000038,,,,,,MORIGRO BASE,,0.27,0.269962
+,3784.48,98.26,55.43,32.16,181.93,18.18,0.000071,,,,,,MORIGRO BASE,,0.2733,0.273229
+,3729.28,94.49,56.11,32.26,182.14,18.18,0.000015,,,,,,MORIGRO BASE,,0.2767,0.276685
+,3694.71,94.5,56.59,30.27,184.71,18.2,0.00003,,,,,,MORIGRO BASE,,0.28,0.28003
+,3741.95,94.61,63.73,39.42,182.76,18.28,0.000001,,,,,,MORIGRO BASE,,0.2833,0.283299
+,3770.44,92.65,59.31,31.7,183.89,18.16,0.00001,,,,,,MORIGRO BASE,,0.2867,0.28671
+,3860.63,94.59,63.26,38.77,183.82,18.29,0.000075,,,,,,MORIGRO BASE,,0.29,0.289925
+,3838.07,92.09,63.31,38.71,185.39,18.29,0.000069,,,,,,MORIGRO BASE,,0.2933,0.293231
+,3943.6,94.41,55.48,38.91,182.92,17.89,0.000009,,,,,,MORIGRO BASE,,0.2967,0.296709
+,3754.46,94.68,60.21,41.18,185.66,18.26,0.000057,,,,,,MORIGRO BASE,,0.3,0.300057
+,4006.48,93.89,60.87,43.27,188.25,18.27,0.00003,,,,,,MORIGRO BASE,,0.3033,0.30333
+,3887.14,92.38,59.76,42.61,185.05,18.28,0.000068,,,,,,MORIGRO BASE,,0.3067,0.306632
+,3803.81,92.58,57.93,44.17,187.97,17.76,0.000048,,,,,,MORIGRO BASE,,0.31,0.310048
+,3776.87,96.95,63.09,44.77,187.02,18.25,0.000063,,,,,,MORIGRO BASE,,0.3133,0.313237
+,3814.03,96.55,58.76,35.79,186.12,18.23,0.000011,,,,,,MORIGRO BASE,,0.3167,0.316711
+,3824.88,94.02,57.86,41.7,188.3,17.58,0.000003,,,,,,MORIGRO BASE,,0.32,0.320003
+,3864.91,94.68,60.99,44.18,188.13,17.39,0.000034,,,,,,MORIGRO BASE,,0.3233,0.323334
+,3860.49,97.0,61.18,44.95,186.93,18.15,0.000038,,,,,,MORIGRO BASE,,0.3267,0.326662
+,4014.13,92.26,61.19,43.86,188.73,17.72,0.000002,,,,,,MORIGRO BASE,,0.33,0.329998
+,4008.89,94.22,64.65,43.83,186.2,16.94,0.000038,,,,,,MORIGRO BASE,,0.3333,0.333262
+,4061.17,93.44,61.93,45.06,187.11,17.9,0.000015,,,,,,MORIGRO BASE,,0.3367,0.336715
+,3849.15,94.57,62.98,38.43,188.74,17.77,0.000036,,,,,,MORIGRO BASE,,0.34,0.339964
+,4053.06,93.45,58.44,40.78,186.31,17.88,0.000059,,,,,,MORIGRO BASE,,0.3433,0.343241
+,4049.82,93.53,60.48,41.4,186.96,17.48,0.000028,,,,,,MORIGRO BASE,,0.3467,0.346728
+,3942.5,93.26,60.25,44.66,186.89,17.59,0.000084,,,,,,MORIGRO BASE,,0.35,0.349916
+,3662.153746,92.87885955,56.44008445,37.16931959,182.1015547,18.23756242,1.50828E-05,,,,,,MORIGRO BASE,,0.278,0.277984917
+,3583.481721,94.61536745,47.72407145,33.93406928,184.1877979,18.15319544,9.45765E-05,,,,,,MORIGRO BASE,,0.22,0.220094576
+,4004.1,95.82,53.85,17.76,173.9,18.84,0.000001,,,,,,BMR BASE,,0.2667,0.266701
+,3889.04,92.86,56.08,16.61,176.49,18.39,0.000064,,,,,,BMR BASE,,0.27,0.270064
+,3977.01,94.89,50.45,17.26,172.84,17.88,0.000028,,,,,,BMR BASE,,0.2733,0.273328
+,3975.74,96.97,58.0,20.65,176.81,17.91,0.000046,,,,,,BMR BASE,,0.2767,0.276654
+,4118.13,97.06,59.87,21.46,179.1,17.95,0.000034,,,,,,BMR BASE,,0.28,0.279966
+,4036.57,94.61,57.52,22.4,175.41,17.96,0.000047,,,,,,BMR BASE,,0.2833,0.283253
+,3957.07,94.96,59.03,25.83,180.33,18.06,0.000019,,,,,,BMR BASE,,0.2867,0.286719
+,4012.08,95.13,55.6,23.87,173.89,18.25,0.000079,,,,,,BMR BASE,,0.29,0.290079
+,4006.01,97.24,59.59,26.92,182.22,18.13,0.000009,,,,,,BMR BASE,,0.2933,0.293291
+,4095.45,94.26,57.81,22.97,179.89,18.12,0.000078,,,,,,BMR BASE,,0.2967,0.296778
+,4118.56,95.79,53.04,24.09,182.91,17.94,0.000025,,,,,,BMR BASE,,0.3,0.299975
+,4173.75,93.33,46.73,25.32,180.23,17.22,0.000026,,,,,,BMR BASE,,0.3033,0.303326
+,4261.18,93.59,48.9,25.45,179.85,17.07,0.000032,,,,,,BMR BASE,,0.3067,0.306668
+,3859.52,94.76,51.81,23.39,181.66,17.29,0.000027,,,,,,BMR BASE,,0.31,0.310027
+,3980.3,94.28,51.82,24.51,180.67,17.15,0.000088,,,,,,BMR BASE,,0.3133,0.313212
+,4016.03,93.24,55.74,29.26,186.03,18.0,0.000033,,,,,,BMR BASE,,0.3167,0.316667
+,4130.35,93.03,52.02,28.41,180.54,17.21,0.000099,,,,,,BMR BASE,,0.32,0.319901
+,4060.71,95.76,53.21,31.61,190.97,17.24,0.000055,,,,,,BMR BASE,,0.3233,0.323355
+,4100.03,95.47,59.71,28.84,181.87,17.08,0.000005,,,,,,BMR BASE,,0.3267,0.326695
+,4076.16,98.89,58.05,26.81,185.79,17.13,0.000095,,,,,,BMR BASE,,0.33,0.329905
+,4218.2,94.07,53.28,29.11,187.83,17.04,0.00003,,,,,,BMR BASE,,0.3333,0.33333
+,4083.73,96.28,52.63,27.47,189.31,16.92,0.000009,,,,,,BMR BASE,,0.3367,0.336709
+,4131.45,92.68,52.91,29.2,187.46,17.19,0.000004,,,,,,BMR BASE,,0.34,0.339996
+,4273.64,92.39,52.52,32.09,188.33,17.57,0.000054,,,,,,BMR BASE,,0.3433,0.343354
+,4173.31,94.49,53.5,27.82,191.52,16.45,0.000034,,,,,,BMR BASE,,0.3467,0.346734
+,4037.2,97.81,57.66,30.44,186.81,17.41,0.000089,,,,,,BMR BASE,,0.35,0.350089
+0.0,3954.9311079077775,94.45976055285084,48.6254940047852,19.32750786639565,172.50786350143548,18.96226889703589,5.821013450624246e-05,0.0216394552067815,100.0,menengah,0.0,0.2689417898654938,BMR BASE,,0.269,
+1.0,4208.694512984114,92.90771191305322,56.013646682243845,28.699410878647587,190.6548727013951,16.751303269434544,1.3470649717906014e-07,3.741847143862782e-05,38.0,tinggi,0.0,0.3599998652935028,BMR BASE,,0.36,
+1.0,3905.2788959322415,94.51705193020004,44.83638640133726,20.8867494655602,174.5534716840486,18.29888208092669,0.07266210317611693,36.33105158805847,100.0,rendah,0.0052797812379766,0.2726621031761169,CKR BASE,,0.2,
+1.0,3958.483778501467,93.25064970149444,53.72320503170738,31.112422878232174,174.36778855806637,18.497168825666424,0.0020924067497253285,0.789587452726539,52.0,menengah,4.378166006296113e-06,0.26709240674972534,CKR BASE,,0.265,

Inverse_Model.py

@@ -0,0 +1,440 @@
+# Inverse_Model.py
+import numpy as np
+import pandas as pd
+import joblib
+from scipy.optimize import differential_evolution
+
+# =========================================================
+# KONFIGURASI GLOBAL (TIDAK ADA STREAMLIT DI FILE INI)
+# =========================================================
+
+# List produk yang digunakan untuk inverse model dan dapat juga di-import ke Dashboard
+AVAILABLE_PRODUCTS = ["BMR BASE", "CKP BASE", "CKR BASE", "CMR BASE", "MORIGRO BASE"]
+
+# Batas global parameter (dipakai di perhitungan bounds)
+PARAMS_BOUNDS = {
+    "D101330TT": (92, 99),
+    "D102260TIC_CV": (35, 80),
+    "D102265TIC_PV": (160, 195),
+    "D102265TIC_CV": (10, 70),
+    "D102266TIC": (15, 22),
+    "D101264FTSCL": (3300, 4900),
+}
+
+# Konfigurasi per-produk: GAS range, korelasi, dan BINNING_DATA
+PRODUCT_CONFIG = {
+    "CKR BASE": {
+        "gas_min": 0.20,
+        "gas_max": 0.35,
+        "param_corr": {
+            "D101330TT": "negatif",
+            "D102260TIC_CV": "positif",
+            "D102265TIC_PV": "positif",
+            "D102265TIC_CV": "positif",
+            "D102266TIC": "netral",
+            "D101264FTSCL": "positif",
+        },
+        "binning": {
+            (0.20, 0.275): {
+                "D101330TT": (92.01, 95.14),
+                "D102260TIC_CV": (44.0, 70.0),
+                "D102265TIC_PV": (173.96, 193.58),
+                "D102265TIC_CV": (19.68, 52.23),
+                "D102266TIC": (17.42, 18.59),
+                "D101264FTSCL": (3710.76, 4690.91),
+            },
+            (0.275, 0.35): {
+                "D101330TT": (92.01, 98.31),
+                "D102260TIC_CV": (38.0, 68.0),
+                "D102265TIC_PV": (171.59, 194.97),
+                "D102265TIC_CV": (15.29, 63.62),
+                "D102266TIC": (15.94, 19.59),
+                "D101264FTSCL": (3496.96, 4888.82),
+            },
+        },
+    },
+    "BMR BASE": {
+        "gas_min": 0.20,
+        "gas_max": 0.375,
+        "param_corr": {
+            "D101330TT": "netral",
+            "D102260TIC_CV": "positif",
+            "D102265TIC_PV": "positif",
+            "D102265TIC_CV": "positif",
+            "D102266TIC": "netral",
+            "D101264FTSCL": "positif",
+        },
+        "binning": {
+            (0.20, 0.275): {
+                "D101330TT": (92.62, 97.05),
+                "D102260TIC_CV": (38, 62),
+                "D102265TIC_PV": (171.64, 190.05),
+                "D102265TIC_CV": (14.47, 24.46),
+                "D102266TIC": (17.01, 18.98),
+                "D101264FTSCL": (3633.08, 4125.52),
+            },
+            (0.275, 0.375): {
+                "D101330TT": (92.23, 98.96),
+                "D102260TIC_CV": (36.0, 60.0),
+                "D102265TIC_PV": (171.64, 192.53),
+                "D102265TIC_CV": (11.75, 33.91),
+                "D102266TIC": (16.16, 18.43),
+                "D101264FTSCL": (3535.08, 4283.65),
+            },
+        },
+    },
+    "CKP BASE": {
+        "gas_min": 0.18,
+        "gas_max": 0.375,
+        "param_corr": {
+            "D101330TT": "netral",
+            "D102260TIC_CV": "positif",
+            "D102265TIC_PV": "positif",
+            "D102265TIC_CV": "positif",
+            "D102266TIC": "netral",
+            "D101264FTSCL": "positif",
+        },
+        "binning": {
+            (0.18, 0.28): {
+                "D101330TT":     (92.01, 98.83),
+                "D102260TIC_CV": (36,    68),
+                "D102265TIC_PV": (168.11, 194.97),
+                "D102265TIC_CV": (13.99, 49.36),
+                "D102266TIC":    (15.83, 18.84),
+                "D101264FTSCL":  (3632.62, 4890.58),
+            },
+            (0.28, 0.38): {
+                "D101330TT":     (92.01, 99.00),
+                "D102260TIC_CV": (38,    68),
+                "D102265TIC_PV": (169.50, 194.97),
+                "D102265TIC_CV": (13.93, 49.36),
+                "D102266TIC":    (15.86, 19.02),
+                "D101264FTSCL":  (3658.91, 4890.58),
+            },
+        },
+    },
+    "CMR BASE": {
+        "gas_min": 0.19,
+        "gas_max": 0.375,
+        "param_corr": {
+            "D101330TT": "netral",
+            "D102260TIC_CV": "positif",
+            "D102265TIC_PV": "positif",
+            "D102265TIC_CV": "positif",
+            "D102266TIC": "netral",
+            "D101264FTSCL": "positif",
+        },
+        "binning": {
+            (0.19, 0.275): {
+                "D101264FTSCL": (3618.73, 4539.96),
+                "D101330TT": (92.1, 98.91),
+                "D102260TIC_CV": (38, 62),
+                "D102265TIC_CV": (15.3, 26.01),
+                "D102265TIC_PV": (163.14, 192.25),
+                "D102266TIC": (16.35, 19.55),
+            },
+            (0.275, 0.375): {
+                "D101264FTSCL": (3445.31, 4684.92),
+                "D101330TT": (92.06, 99.0),
+                "D102260TIC_CV": (36, 64),
+                "D102265TIC_CV": (14.75, 39.87),
+                "D102265TIC_PV": (162.09, 191.96),
+                "D102266TIC": (16.2, 19.55),
+            },
+        },
+    },
+    "MORIGRO BASE": {
+        "gas_min": 0.12,
+        "gas_max": 0.375,
+        "param_corr": {
+            "D101330TT": "netral",
+            "D102260TIC_CV": "positif",
+            "D102265TIC_PV": "positif",
+            "D102265TIC_CV": "positif",
+            "D102266TIC": "netral",
+            "D101264FTSCL": "positif",
+        },
+        "binning": {
+            (0.12, 0.28): {
+                "D101264FTSCL": (3437.81, 3922.18),
+                "D101330TT": (92.01, 98.78),
+                "D102260TIC_CV": (36, 70),
+                "D102265TIC_CV": (20.0, 42.95),
+                "D102265TIC_PV": (179.98, 194.97),
+                "D102266TIC": (17.3, 18.32),
+            },
+            (0.28, 0.375): {
+                "D101264FTSCL": (3389.88, 4072.64),
+                "D101330TT": (92.01, 97.27),
+                "D102260TIC_CV": (38, 66),
+                "D102265TIC_CV": (19.65, 45.87),
+                "D102265TIC_PV": (180.32, 189.0),
+                "D102266TIC": (16.91, 18.32),
+            },
+        },
+    },
+}
+
+# =========================================================
+# FUNGSI MODEL & OPTIMISASI (BACKEND)
+# =========================================================
+
+def load_model(model_path: str):
+    """Load forward model XGBoost + poly_transformer dari checkpoint."""
+    deployment_bundle = joblib.load(model_path)
+    return (
+        deployment_bundle["model"],
+        deployment_bundle["poly_transformer"],
+        deployment_bundle["input_features"],
+        deployment_bundle["poly_feature_names"],
+    )
+
+def predict_mmbtu(params_array, model, poly_transformer, input_features, poly_feature_names):
+    """Prediksi GAS_MMBTU dari array parameter."""
+    params_dict = dict(zip(input_features, params_array))
+    X = pd.DataFrame([params_dict])[input_features]
+    X_poly = poly_transformer.transform(X)
+    X_poly_df = pd.DataFrame(X_poly, columns=poly_feature_names)
+    return float(model.predict(X_poly_df)[0])
+
+def get_operational_bounds(target_mmbtu: float, binning: dict):
+    """
+    Ambil bounds operasional dari BINNING_DATA terdekat.
+    - Jika target di dalam salah satu bin => pakai bin itu
+    - Jika di bawah minimum => pakai bin pertama
+    - Jika di atas maksimum => pakai bin terakhir
+    """
+    bins_sorted = sorted(binning.keys(), key=lambda x: x[0])  # sort by lower bound
+
+    for (lo, hi) in bins_sorted:
+        if lo <= target_mmbtu <= hi:
+            return binning[(lo, hi)]
+
+    # fallback
+    if target_mmbtu < bins_sorted[0][0]:
+        return binning[bins_sorted[0]]
+    else:
+        return binning[bins_sorted[-1]]
+
+def calculate_bounds(target_mmbtu, input_features, product_cfg):
+    """
+    Hitung hard_bounds & soft_bounds untuk satu produk dan satu target MMBTU.
+    """
+    gas_min = product_cfg["gas_min"]
+    gas_max = product_cfg["gas_max"]
+    binning = product_cfg["binning"]
+    param_corr = product_cfg["param_corr"]
+
+    # Step 1: SP_target dan level
+    gas_range = gas_max - gas_min
+    sp_target = (target_mmbtu - gas_min) / gas_range
+    sp_target = float(np.clip(sp_target, 0, 1))
+    sp_inverse = 1.0 - sp_target
+
+    if sp_target < 0.33:
+        level = "rendah"
+    elif sp_target < 0.67:
+        level = "menengah"
+    else:
+        level = "tinggi"
+
+    # Step 2: hard bounds dari binning
+    operational_bounds = get_operational_bounds(target_mmbtu, binning)
+    hard_bounds = {}
+    soft_bounds = {}
+
+    # Step 3: soft bounds per parameter
+    for param in input_features:
+        keras_min, keras_max = operational_bounds[param]
+        keras_range = keras_max - keras_min
+        hard_bounds[param] = (keras_min, keras_max)
+
+        korelasi = param_corr.get(param, "netral")
+
+        # SP relevan tergantung korelasi
+        sp = sp_inverse if korelasi == "negatif" else sp_target
+
+        # Target ideal global dari global bounds
+        min_global, max_global = PARAMS_BOUNDS[param]
+        range_global = max_global - min_global
+        target_ideal_global = min_global + (sp * range_global)
+
+        # Jika target ideal global masih within bin => pakai
+        if keras_min <= target_ideal_global <= keras_max:
+            target_ideal = target_ideal_global
+        else:
+            target_ideal = keras_min + (sp * keras_range)
+
+        buffer = 0.2 * keras_range  # 20% dari range
+
+        if korelasi == "netral":
+            ideal_min = keras_min
+            ideal_max = keras_max
+        elif level == "rendah":
+            if korelasi == "positif":
+                ideal_min = keras_min
+                ideal_max = target_ideal + buffer
+            else:  # negatif
+                ideal_min = target_ideal - buffer
+                ideal_max = keras_max
+        elif level == "menengah":
+            ideal_min = target_ideal - buffer
+            ideal_max = target_ideal + buffer
+        else:  # tinggi
+            if korelasi == "positif":
+                ideal_min = target_ideal - buffer
+                ideal_max = keras_max
+            else:  # negatif
+                ideal_min = keras_min
+                ideal_max = target_ideal + buffer
+
+        ideal_min = max(ideal_min, keras_min)
+        ideal_max = min(ideal_max, keras_max)
+        soft_bounds[param] = (ideal_min, ideal_max)
+
+    return hard_bounds, soft_bounds, level
+
+def objective_function(
+    params_array,
+    target_mmbtu,
+    model,
+    poly_transformer,
+    input_features,
+    poly_feature_names,
+    hard_bounds,
+    soft_bounds,
+):
+    """Fungsi objektif untuk Differential Evolution."""
+    prediction = predict_mmbtu(params_array, model, poly_transformer, input_features, poly_feature_names)
+    error_pred = (prediction - target_mmbtu) ** 2
+
+    total_penalty = 0.0
+    for i, param in enumerate(input_features):
+        value = params_array[i]
+        ideal_min, ideal_max = soft_bounds[param]
+        keras_min, keras_max = hard_bounds[param]
+        param_range = keras_max - keras_min
+
+        violation = 0.0
+        if value < ideal_min:
+            violation = ideal_min - value
+        elif value > ideal_max:
+            violation = value - ideal_max
+
+        if param_range > 0:
+            total_penalty += (violation / param_range)
+
+    ERROR_THRESHOLD = 1e-4
+    if abs(prediction - target_mmbtu) < ERROR_THRESHOLD:
+        return total_penalty
+    else:
+        return error_pred + total_penalty
+
+def optimize_one_target(
+    target_mmbtu,
+    model,
+    poly_transformer,
+    input_features,
+    poly_feature_names,
+    product_cfg,
+    maxiter=100,
+    popsize=30,
+):
+    """Optimasi inverse model untuk satu nilai target MMBTU."""
+    hard_bounds, soft_bounds, level = calculate_bounds(target_mmbtu, input_features, product_cfg)
+    optimizer_bounds = [hard_bounds[param] for param in input_features]
+
+    def obj_wrapper(params_array):
+        return objective_function(
+            params_array,
+            target_mmbtu,
+            model,
+            poly_transformer,
+            input_features,
+            poly_feature_names,
+            hard_bounds,
+            soft_bounds,
+        )
+
+    result = differential_evolution(
+        func=obj_wrapper,
+        bounds=optimizer_bounds,
+        strategy="best1bin",
+        maxiter=maxiter,
+        popsize=popsize,
+        tol=1e-4,
+        mutation=(0.5, 1),
+        recombination=0.7,
+        seed=42,
+        polish=True,
+        atol=1e-6,
+        disp=False,
+    )
+
+    optimal_params = dict(zip(input_features, result.x))
+    final_pred = predict_mmbtu(result.x, model, poly_transformer, input_features, poly_feature_names)
+
+    violations = []
+    for param, value in optimal_params.items():
+        ideal_min, ideal_max = soft_bounds[param]
+        if not (ideal_min <= value <= ideal_max):
+            violations.append(param)
+
+    return {
+        "target": float(target_mmbtu),
+        "level": level,
+        "optimal_params": optimal_params,
+        "prediction": float(final_pred),
+        "error": abs(final_pred - target_mmbtu),
+        "error_pct": abs(final_pred - target_mmbtu) / target_mmbtu * 100.0,
+        "objective_value": float(result.fun),
+        "converged": bool(result.success),
+        "iterations": int(result.nit),
+        "soft_violations": violations,
+        "hard_bounds": hard_bounds,
+        "soft_bounds": soft_bounds,
+    }
+
+def run_inverse_for_targets(model_path, product_name, targets):
+    """
+    Wrapper: load model dan jalankan optimasi untuk list target.
+    Dipanggil dari Dashboard.
+    """
+    product_cfg = PRODUCT_CONFIG[product_name]
+    model, poly_transformer, input_features, poly_feature_names = load_model(model_path)
+
+    results = []
+    for t in targets:
+        res = optimize_one_target(
+            target_mmbtu=t,
+            model=model,
+            poly_transformer=poly_transformer,
+            input_features=input_features,
+            poly_feature_names=poly_feature_names,
+            product_cfg=product_cfg,
+            maxiter=100,
+            popsize=30,
+        )
+        results.append(res)
+    return results
+
+def results_to_dataframe(results, product_name):
+    """Convert list of result dicts menjadi DataFrame flat untuk ditampilkan / disimpan."""
+    rows = []
+    for r in results:
+        base = {
+            "Product": product_name,
+            "Target_MMBTU": r["target"],
+            "Level": r["level"],
+            "Predicted_MMBTU": r["prediction"],
+            "Error": r["error"],
+            "Error_Pct": r["error_pct"],
+            "Objective_Value": r["objective_value"],
+            "Converged": r["converged"],
+            "Iterations": r["iterations"],
+            "Soft_Violations": ", ".join(r["soft_violations"]) if r["soft_violations"] else "",
+        }
+        for param, value in r["optimal_params"].items():
+            base[param] = value
+        rows.append(base)
+    return pd.DataFrame(rows)

MonitoringModel.py

@@ -0,0 +1,245 @@
+import pandas as pd
+import numpy as np
+import joblib
+from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
+import matplotlib.pyplot as plt
+import seaborn as sns 
+import os
+
+# =========================================================
+# KONFIGURASI GLOBAL (tetap)
+# =========================================================
+DATA_FILENAME = r'C:\Dokumen\One To Many_17_10_2025\MMBTU\DASHBOARD\One To Many\disagregasi_data_spraydryer_terbaru_10_17_2025.csv'
+MODEL_FOLDER = r'C:\Dokumen\One To Many_17_10_2025\MMBTU\DASHBOARD\One To Many\MODEL CHECKPOINT FOR INVERSE MODEL'
+TARGET_COLUMN = 'GAS_MMBTU_Disaggregated'
+
+PRODUCT_LIST = [
+    'BMR BASE',
+    'CKP BASE',
+    'CKR BASE',
+    'CMR BASE',
+    'MORIGRO BASE'
+]
+
+FEATURES = [
+    'D101330TT',
+    'D102260TIC_CV',
+    'D102265TIC_PV',
+    'D102265TIC_CV',
+    'D102266TIC',
+    'D101264FTSCL'
+]
+
+PREDICTION_COLUMN = 'Prediksi_Gas'
+MODEL_FILENAME_TEMPLATE = 'model_checkpoint_xgb_{}.joblib'
+
+
+# =========================================================
+# FUNGSI UTILITAS (tetap)
+# =========================================================
+def calculate_metrics(y_true, y_pred):
+    """Menghitung R2, RMSE, dan MAE."""
+    r2 = r2_score(y_true, y_pred)
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+    mae = mean_absolute_error(y_true, y_pred)
+    return r2, rmse, mae
+
+
+def _load_model_for_product(model_dir, product):
+    """Load model XGBoost + poly_transformer untuk satu produk."""
+    model_path = os.path.join(model_dir, MODEL_FILENAME_TEMPLATE.format(product))
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"File model tidak ditemukan: {model_path}")
+
+    deployment_bundle = joblib.load(model_path)
+
+    model = deployment_bundle.get('model')
+    poly_transformer = deployment_bundle.get('poly_transformer')
+    poly_feature_names = deployment_bundle.get('poly_feature_names')
+
+    if model is None or poly_transformer is None or poly_feature_names is None:
+        raise KeyError(
+            "Bundle model tidak lengkap. Pastikan berisi "
+            "'model', 'poly_transformer', dan 'poly_feature_names'."
+        )
+
+    return model, poly_transformer, poly_feature_names
+
+
+# =========================================================
+# FUNGSI UTAMA UNTUK DASHBOARD (PERBAIKAN)
+# =========================================================
+def evaluate_models_for_dashboard(
+    data_path: str = DATA_FILENAME,
+    model_dir: str = MODEL_FOLDER,
+    products: list = None,
+    features: list = None,
+    target_col: str = TARGET_COLUMN,
+    data_df=None,   # <--- NEW: bisa kirim DataFrame langsung dari Streamlit
+):
+    """
+    Fungsi utama yang melakukan evaluasi performa.
+    Mengembalikan:
+      - summary_df: DataFrame berisi [Product, R², RMSE, MAE]
+      - product_figs: dict {product_name: matplotlib.figure.Figure}
+
+    Prioritas data:
+    1) Jika data_df tidak None  -> gunakan data_df (upload dari Streamlit)
+    2) Jika data_df None        -> baca dari data_path (CSV default)
+    """
+    if products is None:
+        products = PRODUCT_LIST
+    if features is None:
+        features = FEATURES
+
+    # --- 1. Load data ---
+    if data_df is not None:
+        # Pakai dataset yang di-upload user (sudah dalam bentuk DataFrame)
+        df = data_df.copy()
+    else:
+        # Fallback: baca dari CSV path seperti sebelumnya
+        try:
+            df = pd.read_csv(data_path)
+        except FileNotFoundError:
+            print(f"[ERROR] Data file tidak ditemukan di: {data_path}")
+            return pd.DataFrame(columns=['Product', 'R²', 'RMSE', 'MAE']), {}
+        except Exception as e:
+            print(f"[ERROR] Gagal memuat data: {e}")
+            return pd.DataFrame(columns=['Product', 'R²', 'RMSE', 'MAE']), {}
+
+    # Pastikan Date_time ada dan dalam bentuk datetime (kalau mau pakai time-series)
+    if 'Date_time' in df.columns:
+        df['Date_time'] = pd.to_datetime(df['Date_time'], errors='coerce')
+
+    summary_results = []
+    plot_data_list = [] 
+    
+    # --- 2. Loop per produk ---
+    for product in products:
+        df_prod = df[df['Product'] == product].copy()
+        
+        if df_prod.empty or len(df_prod) < 2:
+            continue
+
+        missing_features = [f for f in features if f not in df_prod.columns]
+        if missing_features:
+            print(f"[WARN] Fitur hilang untuk {product}: {missing_features}")
+            continue
+
+        if 'Date_time' in df_prod.columns:
+            df_prod = df_prod.sort_values('Date_time')
+
+        X_raw = df_prod[features]
+        y_true = df_prod[target_col]
+
+        # --- 2a. Load model produk ---
+        try:
+            model, poly_transformer, poly_feature_names = _load_model_for_product(model_dir, product)
+        except Exception as e:
+            print(f"[WARN] Gagal load model untuk {product}: {e}")
+            continue
+
+        # --- 2b. Transformasi dan prediksi ---
+        try:
+            X_transformed_np = poly_transformer.transform(X_raw)
+            X_transformed_df = pd.DataFrame(
+                X_transformed_np,
+                columns=poly_feature_names,
+                index=X_raw.index
+            )
+            y_pred = model.predict(X_transformed_df)
+        except Exception as e:
+            print(f"[WARN] Gagal transform/predict untuk {product}: {e}")
+            continue
+
+        # --- 2c. Hitung metrik ---
+        r2, rmse, mae = calculate_metrics(y_true, y_pred)
+        summary_results.append({
+            'Product': product,
+            'R²': r2,
+            'RMSE': rmse,
+            'MAE': mae
+        })
+
+        # --- 2d. Siapkan data untuk plot ---
+        plot_df = pd.DataFrame({
+            'Actual': y_true.values,
+            'Predicted': y_pred,
+            'Product': product
+        })
+        plot_data_list.append(plot_df)
+
+    # --- 3. Buat summary_df ---
+    if summary_results:
+        summary_df = pd.DataFrame(summary_results)
+        summary_df['Product'] = pd.Categorical(summary_df['Product'], categories=products, ordered=True)
+        summary_df = summary_df.sort_values('Product').reset_index(drop=True)
+    else:
+        summary_df = pd.DataFrame(columns=['Product', 'R²', 'RMSE', 'MAE'])
+        return summary_df, {} 
+    
+    product_figs = {}
+
+    # --- 4. Generate Figures (per produk, untuk Streamlit) ---
+    if plot_data_list:
+        all_plot_data = pd.concat(plot_data_list)
+        products_evaluated = summary_df['Product'].tolist()
+
+        sns.set_style("whitegrid")
+
+        for product in products_evaluated:
+            product_data = all_plot_data[all_plot_data['Product'] == product].dropna()
+            if product_data.empty:
+                continue
+
+            metrics = summary_df[summary_df['Product'] == product].iloc[0]
+            title = (f'{product}\n'
+                     f'$R^2$: {metrics["R²"]:.3f}, '
+                     f'RMSE: {metrics["RMSE"]:.3f}, '
+                     f'MAE: {metrics["MAE"]:.3f}')
+
+            min_val = min(product_data['Actual'].min(), product_data['Predicted'].min())
+            max_val = max(product_data['Actual'].max(), product_data['Predicted'].max())
+            margin = (max_val - min_val) * 0.05
+            plot_range = [min_val - margin, max_val + margin]
+
+            # Figure tunggal per produk
+            fig_single = plt.figure(figsize=(8, 6))
+            ax_single = fig_single.add_subplot(111)
+            sns.scatterplot(
+                x='Actual',
+                y='Predicted',
+                data=product_data,
+                ax=ax_single,
+                alpha=0.6
+            )
+            ax_single.plot(plot_range, plot_range, 'r--', label='Ideal (Actual = Predicted)')
+            ax_single.set_xlim(plot_range)
+            ax_single.set_ylim(plot_range)
+            ax_single.set_title(title)
+            ax_single.set_xlabel(f'Actual {target_col}')
+            ax_single.set_ylabel(f'Predicted {target_col}')
+            ax_single.legend()
+
+            product_figs[product] = fig_single
+            plt.close(fig_single)
+
+    return summary_df, product_figs
+
+# =========================================================
+# OPSIONAL: MODE CLI (tetap)
+# =========================================================
+if __name__ == "__main__":
+    
+    print("Memulai Evaluasi Performa Model Inverse...")
+    
+    summary_df, figs = evaluate_models_for_dashboard()
+    
+    print("\n" + "="*40)
+    print("=== Ringkasan Performa Model ===")
+    print("="*40)
+    
+    if not summary_df.empty:
+        print(summary_df.to_markdown(index=False, floatfmt=".4f"))
+    else:
+        print("Gagal memproses data atau model. Periksa pesan error di atas.")

README.md

@@ -0,0 +1,143 @@
+# Dashboard Prediksi Model XGBoost dan Inverse Model untuk Spray Dryer
+
+Dashboard ini adalah aplikasi Streamlit yang dirancang untuk melakukan prediksi konsumsi gas (MMBTU) pada proses spray dryer menggunakan model XGBoost dan inverse modelling. Dashboard ini juga menyertakan fitur EDA (Exploratory Data Analysis), disagregasi data, filtering dengan rule engine, serta monitoring performa model. Aplikasi ini mendukung prediksi berdasarkan parameter proses, simulasi inverse untuk menemukan parameter optimal dari target gas, serta cleaning data untuk memastikan kualitas input.
+
+## Cara Instalasi dan Menjalankan Dashboard Secara Lokal
+Ikuti langkah-langkah berikut untuk menjalankan dashboard : 
+
+1. **Buka Terminal atau Command Prompt**  
+   Jika menggunakan VS Code, buka terminal terintegrasi dengan `Ctrl + ` (backtick).
+
+2. **Beralih ke Direktori Proyek**  
+   Gunakan perintah berikut untuk pindah ke folder tempat proyek disimpan:  
+   ```
+   cd "path/ke/folder/proyek"
+   ```  
+   Ganti `"path/ke/folder/proyek"` dengan lokasi folder Anda (contoh: `cd "C:\Users\NamaUser\Documents\DashboardSprayDryer"`).
+
+3. **Buat Environment Virtual Baru**  
+   Buat environment virtual untuk mengisolasi dependensi:  
+   ```
+   python -m venv nama_env
+   ```  
+   Ganti `nama_env` dengan nama yang diinginkan (contoh: `python -m venv spraydryer_env`).
+
+4. **Aktifkan Environment Virtual**  
+   Aktifkan environment:  
+   - Pada Windows:  
+     ```
+     nama_env\Scripts\activate
+     ```  
+   - Pada macOS/Linux:  
+     ```
+     source nama_env/bin/activate
+     ```  
+   Setelah diaktifkan, prompt terminal Anda akan menampilkan nama environment (misalnya: `(nama_env)`).
+
+5. **Instal Dependensi**  
+   Instal semua package yang diperlukan dari file `requirements.txt`:  
+   ```
+   pip install -r requirements.txt
+   ```  
+   Pastikan file `requirements.txt` ada di direktori proyek (contoh isi: `streamlit`, `pandas`, `numpy`, `xgboost`, `scikit-learn`, dll.).
+
+6. **Jalankan Dashboard**  
+   Jalankan aplikasi Streamlit dengan perintah:  
+   ```
+   streamlit run Dashboard.py
+   ```  
+   (Catatan: Jika nama file utama berbeda, sesuaikan dengan nama file Anda.)
+
+7. **Akses Dashboard**  
+   Setelah dijalankan, Streamlit akan menampilkan pesan seperti:  
+   ```
+   You can now view your Streamlit app in your browser.
+   Local URL: http://localhost:8501
+   Network URL: http://192.168.x.x:8501
+   ```  
+   Klik salah satu URL untuk membuka dashboard di browser. Jika gagal, coba akses `http://localhost:8501` secara manual.
+
+Jika mengalami error, periksa:
+- Versi Python yang benar.
+- Semua dependensi terinstal (jalankan `pip list` untuk verifikasi).
+- File model (misalnya XGBoost) dan data historis tersedia di direktori yang tepat.
+
+## Fitur dan Halaman Dashboard
+Dashboard ini memiliki 6 halaman utama, masing-masing dengan fungsi spesifik untuk mendukung prediksi, analisis, dan pembersihan data spray dryer. Berikut deskripsi lengkapnya:
+
+### 1. Prediksi Gas dari 6 Parameter
+Halaman ini menggunakan model XGBoost dengan feature engineering berbasis waktu untuk memprediksi konsumsi gas (MMBTU) dari 6 parameter proses utama:  
+- `D101330TT` (Outlet Temperature)  
+- `D102260TIC_CV` (HP Steam Damper CV)  
+- `D102265TIC_PV` (Inlet Temperature PV)  
+- `D102265TIC_CV` (LP Steam Damper CV)  
+- `D102266TIC` (Dehumidifier Temperature)  
+- `D101264FTSCL` (Flow Feed)  
+
+**Cara Penggunaan:**  
+- Input rentang nilai untuk masing-masing parameter.  
+- Klik tombol **"Prediksi Konsumsi Gas (MMBTU)"** untuk menjalankan prediksi.  
+- Opsi tambahan: Unggah file CSV untuk prediksi batch.  
+Fitur ini membutuhkan konteks data historis untuk menghitung fitur waktu. 
+
+### 2. Prediksi Parameter dari Gas (MMBTU)
+Halaman ini terdiri dari 3 bagian utama: Inverse Model, Validasi Model, dan Simulasi Prediksi. Model yang digunakan adalah XGBoost dengan Polynomial Features untuk inverse modelling (memprediksi 6 parameter dari target gas).  
+
+**Alur Penggunaan:**  
+1. **Inverse Model:**  
+   - Pilih produk   
+   - Input target konsumsi gas (MMBTU) yang diinginkan.  
+   - Klik **"Optimasi Parameter"** untuk mencari rekomendasi 6 parameter.  
+   - Metode pencarian:  
+     - Cari di file csv historis (jika tersedia).  
+     - Atau jalankan algoritma Differential Evolution untuk optimasi.  
+   - Hasil rekomendasi akan disimpan ke file Excel.  
+
+2. **Validasi Model – XGBoost Many-to-One:**  
+   - Gunakan parameter hasil inverse untuk validasi forward modelling.  
+   - Tampilkan metrik performa seperti MAE, RMSE, R², dan Prediksi GAS (MMBTU).  
+
+3. **Simulasi Prediksi Konsumsi Gas (Forward Modelling):**  
+   - Input manual 6 parameter proses.  
+   - Dapatkan prediksi konsumsi gas secara real-time menggunakan model forward yang sama.  
+
+
+### 3. Monitoring Model
+Halaman ini untuk memantau performa model secara real-time.  
+
+**Cara Penggunaan:**  
+- Unggah file CSV data evaluasi yang mencakup target `GAS_MMBTU_Disaggregated`.  
+- Sistem akan memprediksi nilai gas untuk setiap produk, menghitung selisih antara prediksi dan data aktual, serta menampilkan metrik performa per produk (seperti MAE, RMSE, R²).  
+Fitur ini berguna untuk evaluasi model pada data baru. 
+
+### 4. Exploratory Data Analysis (EDA)
+Halaman ini menyediakan analisis eksploratif data spray dryer.  
+
+**Fitur Utama:**  
+- **Ringkasan Data (Data Summary):** Tampilkan metric seperti total baris, total kolom, rentang tanggal produksi, total missing values, jumlah produk unik, jumlah data duplikat, dan ringkasan anomali.  
+- **EDA per Kategori Produk:** Gunakan tab untuk "All Data" dan setiap produk unik (misalnya: BMR BASE, CKP BASE, CKR BASE, CMR BASE, MORIGRO BASE, dll.). Di setiap tab:  
+  - Distribusi Parameter Proses (boxplot/violin plot untuk 6 parameter utama).  
+  - Deteksi Outlier (boxplot dengan highlight, plus jumlah outlier per parameter).  
+  - Tabel Statistik Deskriptif (`df.describe()` untuk 6 parameter + GAS_MMBTU_Disaggregated).  
+  - Segmen Produksi per Produk (tabel dengan Start_Time, End_Time, Duration_Minutes, Data_Points).  
+- Tombol **"Refresh EDA"** untuk update data baru.  
+
+### 5. Disagregasi Data
+Halaman ini untuk mengubah data konsumsi gas dari skala per jam menjadi per menit menggunakan algoritma disagregasi berbasis bobot indikator proses (proportional weight splitting).  
+
+**Alur Penggunaan:**  
+- Unggah file CSV data per jam.  
+- Klik **"Jalankan Proses Disagregasi"**.  
+- Tampilkan laporan lengkap: validasi jam produksi, perhitungan bobot, validasi akurasi (selisih nol), ringkasan pipeline, analisis hasil (statistik, jam tertinggi/terendah).  
+- Unduh file hasil disagregasi (dengan kolom baru `GAS_MMBTU_Disaggregated`).  
+Panggil fungsi dari `disagregasi_data.py` untuk proses inti.
+
+### 6. Filter Rule Engine
+Halaman ini untuk membersihkan data hasil disagregasi menggunakan rule engine dengan 4 aturan anomali.  
+
+**Alur Penggunaan:**  
+- Unggah file CSV hasil disagregasi.  
+- Klik **"Jalankan Rule Engine"**.  
+- Tampilkan ringkasan: total baris awal/bersih, jumlah anomali dihapus, persentase data bersih.  
+- Detail anomali: tabel dengan jenis anomali, jumlah baris, persentase, contoh waktu.  
+- Unduh file data bersih dan file anomali (dengan kolom `anomaly_reason`).  

eda_functions.py

@@ -0,0 +1,1111 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from datetime import datetime, timedelta
+import warnings
+warnings.filterwarnings('ignore')
+
+class SprayDryerEDAPipeline:
+    """
+    Pipeline untuk Exploratory Data Analysis (EDA) dan preprocessing data spray dryer
+    """
+    
+    def __init__(self, data_path=None, dataframe=None):
+        """
+        Inisialisasi pipeline
+        
+        Parameters:
+        -----------
+        data_path : str, optional
+            Path ke file data (CSV, Excel, dll)
+        dataframe : pd.DataFrame, optional
+            DataFrame yang sudah dimuat
+        """
+        if dataframe is not None:
+            self.df_original = dataframe.copy()
+        elif data_path:
+            self.df_original = self.load_data(data_path)
+        else:
+            raise ValueError("Harus memberikan data_path atau dataframe")
+        
+        self.df = self.df_original.copy()
+        self.product_dataframes = {}
+        self.setup_visualization()
+        
+    def setup_visualization(self):
+        """Setup parameter visualisasi"""
+        plt.style.use('default')
+        sns.set_palette("husl")
+        
+    def load_data(self, path):
+        """Load data dari file"""
+        if path.endswith('.csv'):
+            return pd.read_csv(path)
+        elif path.endswith(('.xlsx', '.xls')):
+            return pd.read_excel(path)
+        else:
+            raise ValueError("Format file tidak didukung")
+    
+    # ============= STEP 1: PEMERIKSAAN KOLOM AWAL =============
+    def check_and_fix_columns(self):
+        """
+        Step 1: Pemeriksaan dan perbaikan nama kolom
+        """
+        print("="*80)
+        print("STEP 1: PEMERIKSAAN KOLOM AWAL")
+        print("="*80)
+        
+        # Daftar kolom standar
+        standard_columns = [
+            'Date_time', 'Drier_On_Product', 'D101330TT', 'D102260TIC_CV',
+            'D102265TIC_PV', 'D102265TIC_CV', 'D102266TIC', 'D101264FTSCL',
+            'Product', 'GAS_MMBTU', 'fixed_rounded_time'
+        ]
+        
+        print(f"Kolom yang ada di dataframe: {list(self.df.columns)}")
+        print(f"\nKolom standar yang diharapkan: {standard_columns}")
+        standard_lookup = {col.lower(): col for col in standard_columns}
+        column_mapping = {}
+        unmatched_column = []
+        for actual_col in self.df.columns: 
+            actual_col_lower = actual_col.lower()
+            if actual_col_lower in standard_lookup:
+                standard_name = standard_lookup[actual_col_lower]
+                if actual_col != standard_name:
+                    column_mapping[actual_col] = standard_name
+            else:
+                unmatched_column.append(actual_col)
+
+        # Rename kolom
+        self.df.rename(columns=column_mapping, inplace=True)
+        
+        # Hapus kolom yang tidak ada dalam daftar standar
+        cols_to_keep = [col for col in self.df.columns if col in standard_columns]
+        cols_removed = [col for col in self.df.columns if col not in standard_columns]
+        
+        if cols_removed:
+            print(f"\nKolom yang dihapus: {cols_removed}")
+        
+        self.df = self.df[cols_to_keep]
+        
+        # Cek apakah fixed_rounded_time ada
+        if 'fixed_rounded_time' not in self.df.columns:
+            print("\nKolom 'fixed_rounded_time' tidak ditemukan. Akan dibuat nanti.")
+        
+        print(f"\nKolom final: {list(self.df.columns)}")
+        print(f"Shape dataframe: {self.df.shape}")
+        
+    # ============= STEP 2: VALIDASI KOLOM PRODUCT =============
+    def validate_product_names(self):
+        """
+        Step 2: Validasi dan standardisasi nama produk secara otomatis.
+        """
+        print("\n" + "="*80)
+        print("STEP 2: VALIDASI DAN STANDARDISASI KOLOM PRODUCT")
+        print("="*80)
+        
+        # Pastikan kolom 'Product' ada
+        if 'Product' not in self.df.columns:
+            print("PERINGATAN: Kolom 'Product' tidak ditemukan. Melewati langkah ini.")
+            print("="*80 + "\n")
+            return self.df
+
+        # 1. Daftar nama produk standar (sumber kebenaran)
+        standard_products = [
+            'CKP BASE', 'CMP BASE', 'BMP BASE', 'MORIGRO BASE', 'CKH BASE',
+            'CMH BASE', 'BMH BASE', 'CKR BASE', 'CMR BASE', 'BMR BASE',
+            'CGI BASE', 'NL33 BASE POWDER', 'CKS BASE', 'CHIL SCHOOL',
+            'CHIL MIL SOYA', 'CIP', 'CIP CHAMBER'
+        ]
+        
+        # 2. Mapping HANYA untuk kasus-kasus khusus/salah ketik yang tidak bisa ditebak
+        # Contoh: ada kata 'BASE' ganda, atau singkatan yang tidak standar.
+        special_product_mapping = {
+            'CMR BASE BASE': 'CMR BASE',
+            'CGI 6-12 BASE' : 'CGI BASE',
+            'CMH BASE': 'CMH BASE',
+            'BMH  BASE': 'BMH BASE'
+        }
+        
+        print(f"Produk unik sebelum standardisasi: {self.df['Product'].unique()}")
+
+        # 3. Buat kamus pencocokan (lookup map) utama secara otomatis
+        # Kunci: nama produk dalam format UPPERCASE dan tanpa spasi berlebih
+        # Nilai: nama produk standar yang benar
+        
+        # Mulai dengan standard products
+        product_lookup = {prod.upper().strip(): prod for prod in standard_products}
+        
+        # Timpa/tambahkan dengan special mapping. Ini memastikan kasus khusus diutamakan.
+        for key, value in special_product_mapping.items():
+            product_lookup[key.upper().strip()] = value
+
+        # 4. Gunakan metode .map() dari Pandas untuk efisiensi tinggi
+        # Ini jauh lebih cepat daripada .apply() untuk data besar
+        
+        # Simpan kolom produk asli untuk perbandingan
+        original_products = self.df['Product'].copy()
+        
+        # Buat series baru dengan nilai yang sudah dinormalisasi (uppercase, strip)
+        normalized_products = self.df['Product'].astype(str).str.upper().str.strip()
+        
+        # Gunakan .map() untuk mengganti nilai. Nilai yang tidak ada di `product_lookup` akan menjadi NaN
+        self.df['Product'] = normalized_products.map(product_lookup)
+        
+        # Isi kembali nilai yang menjadi NaN dengan nilai aslinya.
+        # Ini memastikan produk yang tidak dikenali tidak akan hilang/diubah.
+        self.df['Product'].fillna(original_products, inplace=True)
+
+        print(f"\nProduk unik setelah standardisasi: {self.df['Product'].unique()}")
+        print(f"\nJumlah setiap produk:\n{self.df['Product'].value_counts()}")
+        
+        # 5. (Opsional tapi sangat direkomendasikan) Laporkan produk yang tidak berhasil distandardisasi
+        final_products_set = set(self.df['Product'].unique())
+        standard_products_set = set(standard_products)
+        
+        unstandardized = final_products_set - standard_products_set
+        # Hapus None atau NaN jika ada dalam hasil
+        unstandardized = {item for item in unstandardized if pd.notna(item)}
+        
+        if unstandardized:
+            print("\n" + "-"*40)
+            print(f"PERINGATAN: Ditemukan {len(unstandardized)} produk yang tidak sesuai standar:")
+            for item in unstandardized:
+                print(f" - '{item}'")
+            print("Pertimbangkan untuk menambahkannya ke `standard_products` atau `special_product_mapping`.")
+            print("-"*40)
+
+        print("\n" + "="*80)
+        print("STEP 2 SELESAI")
+        print("="*80 + "\n")
+        return self.df
+        
+    # ============= STEP 3: PEMISAHAN DATA PER PRODUK =============
+    def separate_data_by_product(self):
+        """
+        Step 3: Pemisahan data berdasarkan produk
+        """
+        print("\n" + "="*80)
+        print("STEP 3: PEMISAHAN DATA PER PRODUK")
+        print("="*80)
+        
+        unique_products = self.df['Product'].unique()
+        print(f"Memisahkan data untuk {len(unique_products)} produk...")
+        
+        for product in unique_products:
+            self.product_dataframes[product] = self.df[self.df['Product'] == product].copy()
+            print(f"\n{product}: {len(self.product_dataframes[product])} baris")
+        
+        # Tampilkan statistik deskriptif
+        print("\n" + "-"*50)
+        print("STATISTIK DESKRIPTIF - DATA KESELURUHAN")
+        print("-"*50)
+        print(self.df.describe())
+        
+        print("\n" + "-"*50)
+        print("INFO DATA KESELURUHAN")
+        print("-"*50)
+        print(self.df.info())
+        
+        # Statistik per produk
+        for product, df_product in self.product_dataframes.items():
+            print("\n" + "-"*50)
+            print(f"STATISTIK DESKRIPTIF - {product}")
+            print("-"*50)
+            print(df_product.describe())
+            
+            print(f"\nINFO - {product}")
+            print(df_product.info())
+    
+    # ============= STEP 4: IDENTIFIKASI ANOMALI DATA =============
+    def identify_anomalies(self):
+        """
+        Step 4: Identifikasi anomali berdasarkan aturan teknis
+        """
+        print("\n" + "="*80)
+        print("STEP 4: IDENTIFIKASI ANOMALI DATA")
+        print("="*80)
+        
+        anomaly_rules = {
+            'D101330TT': {'min': 20, 'max': 130, 'zero_anomaly': True},
+            'D102265TIC_PV': {'min': 20, 'zero_anomaly': True},
+            'D102265TIC_CV': {'zero_allowed_products': ['CIP', 'CIP CHAMBER']},
+            'D102266TIC': {'zero_anomaly': True}
+        }
+        
+        anomalies = []
+        
+        for product, df_product in self.product_dataframes.items():
+            print(f"\nMemeriksa anomali untuk produk: {product}")
+            
+            for column, rules in anomaly_rules.items():
+                if column not in df_product.columns:
+                    continue
+                
+                # Cek nilai 0
+                if 'zero_anomaly' in rules and rules['zero_anomaly']:
+                    zero_count = (df_product[column] == 0).sum()
+                    if zero_count > 0:
+                        anomalies.append({
+                            'Product': product,
+                            'Column': column,
+                            'Anomaly': 'Nilai 0',
+                            'Count': zero_count
+                        })
+                        print(f"  - {column}: Ditemukan {zero_count} nilai 0 (anomali)")
+                
+                # Cek nilai 0 untuk D102265TIC_CV
+                if 'zero_allowed_products' in rules:
+                    if product not in rules['zero_allowed_products']:
+                        zero_count = (df_product[column] == 0).sum()
+                        if zero_count > 0:
+                            anomalies.append({
+                                'Product': product,
+                                'Column': column,
+                                'Anomaly': 'Nilai 0 (tidak diizinkan untuk produk ini)',
+                                'Count': zero_count
+                            })
+                            print(f"  - {column}: Ditemukan {zero_count} nilai 0 (anomali untuk produk non-CIP)")
+                
+                # Cek nilai minimum
+                if 'min' in rules:
+                    below_min = (df_product[column] < rules['min']).sum()
+                    if below_min > 0:
+                        anomalies.append({
+                            'Product': product,
+                            'Column': column,
+                            'Anomaly': f'Nilai < {rules["min"]}',
+                            'Count': below_min
+                        })
+                        print(f"  - {column}: Ditemukan {below_min} nilai < {rules['min']}")
+                
+                # Cek nilai maksimum
+                if 'max' in rules:
+                    above_max = (df_product[column] > rules['max']).sum()
+                    if above_max > 0:
+                        anomalies.append({
+                            'Product': product,
+                            'Column': column,
+                            'Anomaly': f'Nilai > {rules["max"]}',
+                            'Count': above_max
+                        })
+                        print(f"  - {column}: Ditemukan {above_max} nilai > {rules['max']}")
+        
+        if anomalies:
+            anomaly_df = pd.DataFrame(anomalies)
+            print("\n" + "-"*50)
+            print("RINGKASAN ANOMALI")
+            print("-"*50)
+            print(anomaly_df.to_string())
+        else:
+            print("\nTidak ditemukan anomali berdasarkan aturan yang ditetapkan.")
+    
+    # ============= STEP 5: VALIDASI KOLOM DRIER_ON_PRODUCT =============
+    def validate_drier_on_product(self):
+        """
+        Step 5: Validasi kolom Drier_On_Product
+        """
+        print("\n" + "="*80)
+        print("STEP 5: VALIDASI KOLOM DRIER_ON_PRODUCT")
+        print("="*80)
+        
+        production_products = [
+            'CKP BASE', 'CMP BASE', 'BMP BASE', 'MORIGRO BASE', 'CKH BASE',
+            'CMH BASE', 'BMH BASE', 'CKR BASE', 'CMR BASE', 'BMR BASE',
+            'CGI BASE', 'NL33 BASE POWDER', 'CKS BASE', 'CHIL SCHOOL',
+            'CHIL MIL SOYA'
+        ]
+        
+        cip_products = ['CIP', 'CIP CHAMBER']
+        
+        validation_errors = []
+        
+        for product in self.df['Product'].unique():
+            df_product = self.df[self.df['Product'] == product]
+            
+            if product in production_products:
+                # Harus 1
+                wrong_values = df_product[df_product['Drier_On_Product'] != 1]
+                if len(wrong_values) > 0:
+                    validation_errors.append({
+                        'Product': product,
+                        'Expected': 1,
+                        'Wrong_Count': len(wrong_values)
+                    })
+                    print(f"ERROR: {product} memiliki {len(wrong_values)} baris dengan Drier_On_Product != 1")
+            
+            elif product in cip_products:
+                # Harus 0
+                wrong_values = df_product[df_product['Drier_On_Product'] != 0]
+                if len(wrong_values) > 0:
+                    validation_errors.append({
+                        'Product': product,
+                        'Expected': 0,
+                        'Wrong_Count': len(wrong_values)
+                    })
+                    print(f"ERROR: {product} memiliki {len(wrong_values)} baris dengan Drier_On_Product != 0")
+        
+        if not validation_errors:
+            print("✓ Semua nilai Drier_On_Product sesuai dengan ketentuan")
+        else:
+            error_df = pd.DataFrame(validation_errors)
+            print("\nRingkasan Error Validasi:")
+            print(error_df)
+    
+    # ============= STEP 6: CEK MISSING VALUES DAN DUPLIKASI =============
+    def check_missing_and_duplicates(self):
+        """
+        Step 6: Periksa missing values dan hapus duplikasi
+        """
+        print("\n" + "="*80)
+        print("STEP 6: CEK MISSING VALUES DAN DUPLIKASI")
+        print("="*80)
+        
+        # Cek missing values
+        print("Missing Values per Kolom:")
+        missing_counts = self.df.isnull().sum()
+        print(missing_counts[missing_counts > 0] if any(missing_counts > 0) else "Tidak ada missing values")
+        
+        # Cek duplikasi berdasarkan Date_time
+        duplicates = self.df[self.df.duplicated(subset=['Date_time'], keep=False)]
+        print(f"\nJumlah baris duplikat berdasarkan Date_time: {len(duplicates)}")
+        
+        if len(duplicates) > 0:
+            print("Menghapus duplikasi...")
+            self.df = self.df.drop_duplicates(subset=['Date_time'], keep='first')
+            print(f"Shape setelah menghapus duplikasi: {self.df.shape}")
+            
+            # Update product dataframes
+            for product in self.product_dataframes.keys():
+                self.product_dataframes[product] = self.df[self.df['Product'] == product].copy()
+    
+    # ============= STEP 7: PERHITUNGAN DURASI PRODUKSI =============
+    def calculate_production_duration(self):
+        """
+        Step 7: Hitung durasi produksi untuk setiap produk berdasarkan segmen produksi yang berkelanjutan.
+        
+        Logika:
+        1.  Data diurutkan berdasarkan waktu.
+        2.  Sebuah "segmen" produksi diidentifikasi sebagai blok baris yang berurutan
+            di mana nama produknya sama.
+        3.  Jika nama produk pada baris saat ini berbeda dari baris sebelumnya,
+            maka itu dianggap sebagai awal dari segmen baru.
+        4.  Durasi dihitung untuk setiap segmen (end_time - start_time).
+        5.  Total durasi untuk satu produk adalah jumlah dari semua durasi segmennya.
+        """
+        print("\n" + "="*80)
+        print("STEP 7: PERHITUNGAN DURASI PRODUKSI (METODE SEGMENTASI)")
+        print("="*80)
+
+        # Pastikan tipe data dan urutan sudah benar
+        try:
+            self.df['Date_time'] = pd.to_datetime(self.df['Date_time'])
+        except Exception as e:
+            print(f"Error saat konversi 'Date_time': {e}")
+            return
+
+        if self.df.empty:
+            print("DataFrame kosong, tidak ada durasi untuk dihitung.")
+            return
+            
+        # Urutkan dataframe berdasarkan waktu, ini krusial untuk logika segmentasi
+        df_sorted = self.df.sort_values('Date_time').copy()
+        
+        # --- Logika Inti: Identifikasi Segmen Produksi ---
+        # Buat kolom 'segment_id' yang akan unik untuk setiap blok produksi yang berkelanjutan.
+        # .shift() membandingkan produk di baris saat ini dengan baris sebelumnya.
+        # .cumsum() akan mengakumulasi nilai (True=1, False=0), sehingga menciptakan ID unik untuk setiap segmen.
+        df_sorted['segment_id'] = (df_sorted['Product'] != df_sorted['Product'].shift()).cumsum()
+        
+        # Kelompokkan berdasarkan Produk dan ID Segmen untuk mendapatkan start dan end time setiap segmen
+        production_segments = df_sorted.groupby(['Product', 'segment_id']).agg(
+            Start_Time=('Date_time', 'min'),
+            End_Time=('Date_time', 'max'),
+            Data_Points=('Date_time', 'count')
+        ).reset_index()
+        
+        # Hitung durasi untuk setiap segmen
+        production_segments['Duration'] = production_segments['End_Time'] - production_segments['Start_Time']
+        
+        # Filter hanya untuk produk produksi (bukan CIP)
+        production_segments_filtered = production_segments[
+            ~production_segments['Product'].isin(['CIP', 'CIP CHAMBER'])
+        ].copy()
+
+        if production_segments_filtered.empty:
+            print("Tidak ada data produksi (non-CIP) untuk dihitung durasinya.")
+            return
+
+        # Hitung total durasi dengan menjumlahkan durasi dari semua segmen per produk
+        total_durations = production_segments_filtered.groupby('Product')['Duration'].sum().reset_index()
+        
+        # Konversi total durasi ke jam
+        total_durations['Total_Duration_Hours'] = round(total_durations['Duration'].dt.total_seconds() / 3600, 2)
+        
+        # Gabungkan dengan jumlah data points
+        total_data_points = production_segments_filtered.groupby('Product')['Data_Points'].sum().reset_index()
+        summary_df = pd.merge(total_durations, total_data_points, on='Product')
+        
+        print("--- RINGKASAN TOTAL DURASI PRODUKSI PER PRODUK ---")
+        print(summary_df[['Product', 'Total_Duration_Hours', 'Data_Points']].to_string(index=False))
+        
+        print("\n" + "-"*80)
+        print("--- DETAIL SEGMEN PRODUKSI ---")
+        # Tampilkan detail setiap segmen untuk setiap produk
+        for product in summary_df['Product'].unique():
+            print(f"\nProduk: {product}")
+            product_segment_details = production_segments_filtered[production_segments_filtered['Product'] == product].copy()
+            
+            # Konversi durasi segmen ke menit untuk keterbacaan
+            product_segment_details['Duration_Minutes'] = round(product_segment_details['Duration'].dt.total_seconds() / 60, 2)
+            
+            print(product_segment_details[[
+                'Start_Time', 
+                'End_Time', 
+                'Duration_Minutes', 
+                'Data_Points'
+            ]].to_string(index=False))
+    
+    # ============= STEP 8: PEMBUATAN KOLOM FIXED_ROUNDED_TIME =============
+    def create_fixed_rounded_time(self):
+        """
+        Step 8: Buat kolom fixed_rounded_time jika belum ada
+        """
+        print("\n" + "="*80)
+        print("STEP 8: PEMBUATAN KOLOM FIXED_ROUNDED_TIME")
+        print("="*80)
+        
+        if 'fixed_rounded_time' not in self.df.columns:
+            print("Membuat kolom fixed_rounded_time...")
+            self.df['Date_time'] = pd.to_datetime(self.df['Date_time'])
+            self.df['fixed_rounded_time'] = (self.df['Date_time'] + pd.Timedelta(hours=1)).dt.floor('H')
+            
+            print("Sample hasil:")
+            print(self.df[['Date_time', 'fixed_rounded_time']].head(10))
+            
+            # Update product dataframes
+            for product in self.product_dataframes.keys():
+                self.product_dataframes[product] = self.df[self.df['Product'] == product].copy()
+        else:
+            print("Kolom fixed_rounded_time sudah ada")
+    
+    # ============= STEP 9: PERHITUNGAN JUMLAH MENIT =============
+    def calculate_minutes_per_hour(self):
+        """
+        Step 9: Hitung jumlah data per jam berdasarkan fixed_rounded_time
+        """
+        print("\n" + "="*80)
+        print("STEP 9: PERHITUNGAN JUMLAH DATA PER JAM")
+        print("="*80)
+        
+        if 'fixed_rounded_time' not in self.df.columns:
+            print("ERROR: Kolom fixed_rounded_time tidak ditemukan!")
+            return
+        
+        # Hitung jumlah data per jam
+        jumlah_data_per_jam = self.df.groupby('fixed_rounded_time').size()
+        jumlah_data_per_jam_df = jumlah_data_per_jam.reset_index(name='Jumlah Data Per Jam')
+        
+        # Filter data dengan jumlah kurang dari 60
+        jumlah_data_kurang_60 = jumlah_data_per_jam_df[jumlah_data_per_jam_df['Jumlah Data Per Jam'] <= 60]
+        
+        # Urutkan dari jumlah terkecil ke terbesar
+        jumlah_data_kurang_60 = jumlah_data_kurang_60.sort_values(by='Jumlah Data Per Jam', ascending=True)
+        
+        print(f"Jam dengan data < 60 menit ({len(jumlah_data_kurang_60)} jam):")
+        pd.set_option("display.max_rows", None)
+        print(jumlah_data_kurang_60.to_string())
+        pd.set_option("display.max_rows", 10)
+    
+    # ============= STEP 10: VISUALISASI DATA =============
+    def create_line_plots(self, show_all_products=True, show_overall=True):
+        """
+        Step 10: Buat line plot untuk visualisasi data
+        """
+        print("\n" + "="*80)
+        print("STEP 10: VISUALISASI DATA (LINE PLOTS)")
+        print("="*80)
+        
+        numeric_columns = self.df.select_dtypes(include=[np.number]).columns
+        numeric_columns = [col for col in numeric_columns if col not in ['Drier_On_Product']]
+        
+        # Plot untuk keseluruhan data
+        if show_overall:
+            print("\nMembuat plot untuk keseluruhan produk...")
+            df_plot = self.df[self.df['Drier_On_Product'] == 1].copy()
+            
+            if len(df_plot) > 0:
+                df_plot = df_plot.sort_values('Date_time')
+                
+                for column in numeric_columns:
+                    if column in df_plot.columns:
+                        plt.figure(figsize=(30, 5))
+                        plt.plot(df_plot['Date_time'], df_plot[column], marker='o', markersize=2, label=column)
+                        plt.title(f'Line Plot of {column} Over Time - All Products', fontsize=14)
+                        plt.xlabel('Date_time')
+                        plt.ylabel(column)
+                        plt.xticks(rotation=45)
+                        plt.legend()
+                        plt.grid(True, alpha=0.3)
+                        plt.tight_layout()
+                        plt.show()
+        
+        # Plot untuk setiap produk
+        if show_all_products:
+            for product, df_product in self.product_dataframes.items():
+                if product not in ['CIP', 'CIP CHAMBER']:
+                    print(f"\nMembuat plot untuk produk: {product}")
+                    df_plot = df_product[df_product['Drier_On_Product'] == 1].copy()
+                    
+                    if len(df_plot) > 0:
+                        df_plot = df_plot.sort_values('Date_time')
+                        
+                        for column in numeric_columns:
+                            if column in df_plot.columns:
+                                plt.figure(figsize=(20, 4))
+                                plt.plot(df_plot['Date_time'], df_plot[column], marker='o', markersize=3, label=column)
+                                plt.title(f'{product} - {column} Over Time', fontsize=12)
+                                plt.xlabel('Date_time')
+                                plt.ylabel(column)
+                                plt.xticks(rotation=45)
+                                plt.legend()
+                                plt.grid(True, alpha=0.3)
+                                plt.tight_layout()
+                                plt.show()
+    
+    # ============= STEP 11: IDENTIFIKASI OUTLIERS =============
+    def identify_outliers(self, show_plots=True):
+        """
+        Step 11: Identifikasi outliers menggunakan metode IQR
+        """
+        print("\n" + "="*80)
+        print("STEP 11: IDENTIFIKASI OUTLIERS")
+        print("="*80)
+        
+        def analyze_outliers(dataframe, product_name="Overall"):
+            """Analisis outliers untuk dataframe tertentu"""
+            
+            df_copy = dataframe.copy()
+            df_copy['Date_time'] = pd.to_datetime(df_copy['Date_time'])
+            drier_on_data = df_copy[df_copy['Drier_On_Product'] == 1].copy()
+            
+            if drier_on_data.empty:
+                print(f"Tidak ada data dengan Drier_On_Product == 1 untuk {product_name}")
+                return None, None
+            
+            print(f"\n{'='*60}")
+            print(f"Analisis Outliers - {product_name}")
+            print(f"Total data yang dianalisis: {len(drier_on_data)} baris")
+            print(f"{'='*60}")
+            
+            all_stats_data = []
+            list_of_outliers = []
+            
+            numeric_columns = drier_on_data.select_dtypes(include=np.number).columns.drop('Drier_On_Product', errors='ignore')
+            
+            for column in numeric_columns:
+                if column in drier_on_data.columns:
+                    param_data = drier_on_data[column].dropna()
+                    
+                    if len(param_data) > 0:
+                        Q1 = param_data.quantile(0.25)
+                        Q3 = param_data.quantile(0.75)
+                        IQR = Q3 - Q1
+                        lower_bound = Q1 - 1.5 * IQR
+                        upper_bound = Q3 + 1.5 * IQR
+                        
+                        outliers = param_data[(param_data < lower_bound) | (param_data > upper_bound)]
+                        has_outliers = not outliers.empty
+                        
+                        mean_val = param_data.mean()
+                        median_val = param_data.median()
+                        std_val = param_data.std()
+                        chosen_val = median_val if has_outliers else mean_val
+                        
+                        all_stats_data.append({
+                            'Parameter': column,
+                            'Mean': mean_val,
+                            'Median': median_val,
+                            'Std_Dev': std_val,
+                            'Batas_Bawah': lower_bound,
+                            'Batas_Atas': upper_bound,
+                            'Has_Outliers': has_outliers,
+                            'Outliers_Count': len(outliers),
+                            'Chosen_Value': chosen_val
+                        })
+                        
+                        if has_outliers:
+                            outlier_mask = (drier_on_data[column] < lower_bound) | (drier_on_data[column] > upper_bound)
+                            outlier_rows = drier_on_data[outlier_mask]
+                            
+                            for index, row in outlier_rows.iterrows():
+                                list_of_outliers.append({
+                                    'Tanggal dan Jam': row['Date_time'],
+                                    'Kolom Outliers': column,
+                                    'Nilai Outliers': row[column],
+                                    'Produk': row['Product'] if 'Product' in row else product_name
+                                })
+                        
+                        # Visualisasi jika diminta
+                        if show_plots and has_outliers:
+                            fig, axes = plt.subplots(1, 2, figsize=(18, 5))
+                            
+                            # Histogram
+                            axes[0].hist(param_data, bins=30, edgecolor='black', alpha=0.7)
+                            axes[0].axvline(mean_val, color='green', linestyle='--', label=f'Mean: {mean_val:.2f}')
+                            axes[0].axvline(median_val, color='red', linestyle='--', label=f'Median: {median_val:.2f}')
+                            axes[0].set_title(f'Distribution - {column}')
+                            axes[0].legend()
+                            
+                            # Time series with outliers
+                            axes[1].plot(range(len(param_data)), param_data.values, 'b-', alpha=0.5)
+                            axes[1].axhline(upper_bound, color='purple', linestyle='--', label=f'Upper: {upper_bound:.2f}')
+                            axes[1].axhline(lower_bound, color='orange', linestyle='--', label=f'Lower: {lower_bound:.2f}')
+                            
+                            if has_outliers:
+                                outlier_indices = []
+                                outlier_values = []
+                                for i, (idx, val) in enumerate(param_data.items()):
+                                    if val < lower_bound or val > upper_bound:
+                                        outlier_indices.append(i)
+                                        outlier_values.append(val)
+                                axes[1].scatter(outlier_indices, outlier_values, color='red', s=50, zorder=5, label='Outliers')
+                            
+                            axes[1].set_title(f'Time Series - {column}')
+                            axes[1].legend()
+                            
+                            plt.suptitle(f'{product_name}: {column}', fontsize=14)
+                            plt.tight_layout()
+                            plt.show()
+            
+            result_df = pd.DataFrame(all_stats_data) if all_stats_data else None
+            outliers_df = pd.DataFrame(list_of_outliers) if list_of_outliers else None
+            
+            if outliers_df is not None and not outliers_df.empty:
+                outliers_df = outliers_df.sort_values(by='Tanggal dan Jam').reset_index(drop=True)
+            
+            return result_df, outliers_df
+        
+        # Analisis untuk keseluruhan data
+        print("\n" + "="*70)
+        print("ANALISIS OUTLIERS - KESELURUHAN DATA")
+        print("="*70)
+        overall_stats, overall_outliers = analyze_outliers(self.df, "OVERALL")
+        
+        if overall_stats is not None:
+            print("\nRingkasan Statistik - Keseluruhan:")
+            print(overall_stats.to_string())
+        
+        if overall_outliers is not None and not overall_outliers.empty:
+            print(f"\nTotal Outliers Keseluruhan: {len(overall_outliers)}")
+            print("\nSample Outliers (10 pertama):")
+            print(overall_outliers.head(10).to_string())
+        
+        # Analisis untuk setiap produk
+        for product, df_product in self.product_dataframes.items():
+            if product not in ['CIP', 'CIP CHAMBER']:
+                stats, outliers = analyze_outliers(df_product, product)
+                
+                if stats is not None:
+                    print(f"\n{'='*50}")
+                    print(f"Ringkasan Statistik - {product}:")
+                    print(stats.to_string())
+                
+                if outliers is not None and not outliers.empty:
+                    print(f"\nTotal Outliers {product}: {len(outliers)}")
+    
+    # ============= MAIN PIPELINE EXECUTION =============
+    def run_full_pipeline(self, show_visualizations=True):
+        """
+        Menjalankan seluruh pipeline EDA
+        """
+        print("\n" + "="*80)
+        print(" " * 20 + "SPRAY DRYER EDA PIPELINE")
+        print(" " * 25 + "STARTING ANALYSIS")
+        print("="*80)
+        
+        try:
+            # Step 1: Pemeriksaan kolom
+            self.check_and_fix_columns()
+            
+            # Step 2: Validasi nama produk
+            self.validate_product_names()
+            
+            # Step 3: Pemisahan data per produk
+            self.separate_data_by_product()
+            
+            # Step 4: Identifikasi anomali
+            self.identify_anomalies()
+            
+            # Step 5: Validasi Drier_On_Product
+            self.validate_drier_on_product()
+            
+            # Step 6: Cek missing values dan duplikasi
+            self.check_missing_and_duplicates()
+            
+            # Step 7: Hitung durasi produksi
+            self.calculate_production_duration()
+            
+            # Step 8: Buat kolom fixed_rounded_time
+            self.create_fixed_rounded_time()
+            
+            # Step 9: Hitung jumlah menit per jam
+            self.calculate_minutes_per_hour()
+            
+            # Step 10: Visualisasi (optional)
+            if show_visualizations:
+                self.create_line_plots(show_all_products=False, show_overall=True)
+            
+            # Step 11: Identifikasi outliers
+            self.identify_outliers(show_plots=show_visualizations)
+            
+            print("\n" + "="*80)
+            print(" " * 25 + "PIPELINE COMPLETED SUCCESSFULLY")
+            print("="*80)
+            
+            return self.df, self.product_dataframes
+            
+        except Exception as e:
+            print(f"\nERROR dalam pipeline: {str(e)}")
+            raise
+    
+    def get_summary(self):
+        """
+        Mendapatkan ringkasan hasil analisis
+        """
+        summary = {
+            'total_rows': len(self.df),
+            'total_columns': len(self.df.columns),
+            'unique_products': self.df['Product'].nunique(),
+            'date_range': {
+                'start': self.df['Date_time'].min(),
+                'end': self.df['Date_time'].max()
+            },
+            'missing_values': self.df.isnull().sum().to_dict(),
+            'product_counts': self.df['Product'].value_counts().to_dict()
+        }
+
+        print("\n" + "="*50)
+        print("📊 DATA SUMMARY")
+        print("="*50)
+        print(f"{'Total rows':20}: {summary['total_rows']:,}")
+        print(f"{'Total columns':20}: {summary['total_columns']}")
+        print(f"{'Unique products':20}: {summary['unique_products']}")
+        print(f"{'Date range':20}: {summary['date_range']['start']} → {summary['date_range']['end']}")
+
+        print("\n🔍 Missing values per column")
+        print("-"*50)
+        for col, val in summary['missing_values'].items():
+            print(f"{col:25} : {val}")
+
+        print("\n📦 Product counts")
+        print("-"*50)
+        for prod, count in summary['product_counts'].items():
+            print(f"{prod:25} : {count:,}")
+
+        return summary
+    
+# ======================================================================
+# HELPER FUNCTIONS UNTUK DASHBOARD STREAMLIT (EDA)
+# ======================================================================
+
+def compute_eda_summary(df: pd.DataFrame,
+                        date_col: str = "Date_time",
+                        product_col: str = "Product") -> dict:
+    """Ringkasan umum dataset untuk metric/cards di dashboard."""
+    df = df.copy()
+
+    # Tanggal
+    if date_col in df.columns:
+        df[date_col] = pd.to_datetime(df[date_col], errors="coerce")
+        date_min = df[date_col].min()
+        date_max = df[date_col].max()
+    else:
+        date_min, date_max = pd.NaT, pd.NaT
+
+    total_rows = len(df)
+    total_columns = df.shape[1]
+    total_missing = int(df.isna().sum().sum())
+    duplicate_rows = int(df.duplicated().sum())
+
+    if product_col in df.columns:
+        product_counts = df[product_col].value_counts().to_dict()
+        unique_products = int(df[product_col].nunique())
+    else:
+        product_counts = {}
+        unique_products = 0
+
+    summary = {
+        "total_rows": total_rows,
+        "total_columns": total_columns,
+        "date_min": date_min,
+        "date_max": date_max,
+        "total_missing": total_missing,
+        "duplicate_rows": duplicate_rows,
+        "unique_products": unique_products,
+        "product_counts": product_counts,
+    }
+    return summary
+
+
+def compute_anomaly_table(df: pd.DataFrame,
+                          product_col: str = "Product") -> pd.DataFrame:
+    """
+    Hitung anomali berbasis rule teknis (error validasi),
+    dengan struktur kolom: Product, Column, Anomaly, Count.
+    """
+    if product_col not in df.columns:
+        return pd.DataFrame(columns=["Product", "Column", "Anomaly", "Count"])
+
+    anomaly_rules = {
+        'D101330TT': {'min': 20, 'max': 130, 'zero_anomaly': True},
+        'D102265TIC_PV': {'min': 20, 'zero_anomaly': True},
+        'D102265TIC_CV': {'zero_allowed_products': ['CIP', 'CIP CHAMBER']},
+        'D102266TIC': {'zero_anomaly': True}
+    }
+
+    anomalies = []
+
+    for product, df_product in df.groupby(product_col):
+        for column, rules in anomaly_rules.items():
+            if column not in df_product.columns:
+                continue
+
+            # Nilai 0 yang dianggap anomali
+            if rules.get("zero_anomaly", False):
+                zero_count = (df_product[column] == 0).sum()
+                if zero_count > 0:
+                    anomalies.append({
+                        "Product": product,
+                        "Column": column,
+                        "Anomaly": "Nilai 0",
+                        "Count": int(zero_count),
+                    })
+
+            # Nilai 0 untuk kolom yang hanya boleh 0 di produk tertentu
+            if "zero_allowed_products" in rules:
+                if product not in rules["zero_allowed_products"]:
+                    zero_count = (df_product[column] == 0).sum()
+                    if zero_count > 0:
+                        anomalies.append({
+                            "Product": product,
+                            "Column": column,
+                            "Anomaly": "Nilai 0 (tidak diizinkan untuk produk ini)",
+                            "Count": int(zero_count),
+                        })
+
+            # Nilai < min
+            if "min" in rules:
+                below_min = (df_product[column] < rules["min"]).sum()
+                if below_min > 0:
+                    anomalies.append({
+                        "Product": product,
+                        "Column": column,
+                        "Anomaly": f"Nilai < {rules['min']}",
+                        "Count": int(below_min),
+                    })
+
+            # Nilai > max
+            if "max" in rules:
+                above_max = (df_product[column] > rules["max"]).sum()
+                if above_max > 0:
+                    anomalies.append({
+                        "Product": product,
+                        "Column": column,
+                        "Anomaly": f"Nilai > {rules['max']}",
+                        "Count": int(above_max),
+                    })
+
+    if not anomalies:
+        return pd.DataFrame(columns=["Product", "Column", "Anomaly", "Count"])
+
+    anomaly_df = pd.DataFrame(anomalies)
+    anomaly_df = anomaly_df.groupby(
+        ["Product", "Column", "Anomaly"], as_index=False
+    )["Count"].sum()
+
+    return anomaly_df
+
+
+def compute_production_segments(df: pd.DataFrame,
+                                product_col: str = "Product",
+                                time_col: str = "Date_time") -> pd.DataFrame:
+    """
+    Hitung segmen produksi kontinu per produk.
+
+    Output kolom:
+    Product | Start_Time | End_Time | Duration_Minutes | Data_Points
+    """
+    if product_col not in df.columns or time_col not in df.columns:
+        return pd.DataFrame(columns=["Product", "Start_Time", "End_Time", "Duration_Minutes", "Data_Points"])
+
+    df_seg = df[[product_col, time_col]].copy()
+    df_seg[time_col] = pd.to_datetime(df_seg[time_col], errors="coerce")
+    df_seg = df_seg.dropna(subset=[time_col]).sort_values(time_col)
+
+    # Segment id: berubah setiap kali Product berubah
+    df_seg["segment_id"] = (df_seg[product_col] != df_seg[product_col].shift()).cumsum()
+
+    grouped = df_seg.groupby([product_col, "segment_id"]).agg(
+        Start_Time=(time_col, "min"),
+        End_Time=(time_col, "max"),
+        Data_Points=(time_col, "count"),
+    ).reset_index()
+
+    grouped["Duration"] = grouped["End_Time"] - grouped["Start_Time"]
+    # Filter non-CIP jika perlu (optional)
+    grouped = grouped[~grouped[product_col].isin(["CIP", "CIP CHAMBER"])]
+
+    if grouped.empty:
+        return pd.DataFrame(columns=["Product", "Start_Time", "End_Time", "Duration_Minutes", "Data_Points"])
+
+    grouped["Duration_Minutes"] = grouped["Duration"].dt.total_seconds() / 60.0
+
+    result = grouped[[product_col, "Start_Time", "End_Time", "Duration_Minutes", "Data_Points"]].copy()
+    result.rename(columns={product_col: "Product"}, inplace=True)
+
+    return result
+
+
+def create_line_plots(df: pd.DataFrame,
+                      params: list,
+                      product_label: str = "All Data",
+                      time_col: str = "Date_time"):
+    """
+    Membuat 6 plot distribusi parameter proses (2x3 grid) vs waktu.
+    Mengembalikan satu Figure matplotlib untuk ditampilkan di Streamlit.
+    """
+    df_plot = df.copy()
+    if time_col in df_plot.columns:
+        df_plot[time_col] = pd.to_datetime(df_plot[time_col], errors="coerce")
+        df_plot = df_plot.dropna(subset=[time_col]).sort_values(time_col)
+
+    # Siapkan figure 2x3
+    fig, axes = plt.subplots(2, 3, figsize=(18, 8), sharex=True)
+    axes = axes.flatten()
+
+    for i, param in enumerate(params):
+        ax = axes[i]
+        if param in df_plot.columns:
+            ax.plot(df_plot[time_col], df_plot[param], marker=".", linewidth=0.7)
+            ax.set_title(param)
+            ax.grid(True, alpha=0.3)
+        else:
+            ax.set_title(f"{param} (not found)")
+            ax.axis("off")
+
+    # Jika params < 6, matikan axis kosong
+    for j in range(len(params), 6):
+        axes[j].axis("off")
+
+    fig.suptitle(f"Distribusi Parameter Proses – {product_label}", fontsize=14)
+    fig.tight_layout(rect=[0, 0.03, 1, 0.95])
+    return fig
+
+
+def identify_outliers(df: pd.DataFrame,
+                      params: list,
+                      product_label: str = "All Data",
+                      time_col: str = "Date_time"):
+    """
+    Deteksi outlier dengan metode IQR untuk setiap parameter dalam `params`.
+    Mengembalikan:
+        - fig_out  : Figure 2x3 dengan plot time series + highlight outlier
+        - total_outliers: total jumlah outlier semua parameter
+        - outlier_stats_df: tabel ringkasan per parameter
+    """
+    df_proc = df.copy()
+    if time_col in df_proc.columns:
+        df_proc[time_col] = pd.to_datetime(df_proc[time_col], errors="coerce")
+        df_proc = df_proc.dropna(subset=[time_col]).sort_values(time_col)
+
+    stats_rows = []
+    total_outliers = 0
+
+    fig, axes = plt.subplots(2, 3, figsize=(18, 8), sharex=True)
+    axes = axes.flatten()
+
+    for i, param in enumerate(params):
+        ax = axes[i]
+        if param not in df_proc.columns:
+            ax.set_title(f"{param} (not found)")
+            ax.axis("off")
+            continue
+
+        series = df_proc[param].astype(float)
+        series_no_na = series.dropna()
+
+        if series_no_na.empty:
+            ax.set_title(f"{param} (no data)")
+            ax.axis("off")
+            continue
+
+        Q1 = series_no_na.quantile(0.25)
+        Q3 = series_no_na.quantile(0.75)
+        IQR = Q3 - Q1
+        lower = Q1 - 1.5 * IQR
+        upper = Q3 + 1.5 * IQR
+
+        outlier_mask = (series < lower) | (series > upper)
+        outlier_idx = df_proc.index[outlier_mask]
+        outlier_vals = series[outlier_mask]
+
+        count_out = int(outlier_mask.sum())
+        total_outliers += count_out
+
+        stats_rows.append({
+            "Parameter": param,
+            "Q1": Q1,
+            "Q3": Q3,
+            "IQR": IQR,
+            "Lower_Bound": lower,
+            "Upper_Bound": upper,
+            "Outliers_Count": count_out,
+        })
+
+        # Plot time series + highlight outliers
+        ax.plot(df_proc[time_col], series, linewidth=0.7)
+        if count_out > 0:
+            ax.scatter(df_proc.loc[outlier_idx, time_col], outlier_vals, s=15)
+        ax.axhline(lower, linestyle="--")
+        ax.axhline(upper, linestyle="--")
+        ax.set_title(f"{param} (outliers: {count_out})")
+        ax.grid(True, alpha=0.3)
+
+    # Matikan axis kosong jika params < 6
+    for j in range(len(params), 6):
+        axes[j].axis("off")
+
+    fig.suptitle(f"Outlier Detection – {product_label}", fontsize=14)
+    fig.tight_layout(rect=[0, 0.03, 1, 0.95])
+
+    outlier_stats_df = pd.DataFrame(stats_rows)
+    return fig, total_outliers, outlier_stats_df
+
+
+def compute_stats_table(df: pd.DataFrame,
+                        params: list,
+                        target_col: str = None) -> pd.DataFrame:
+    """
+    Tabel statistik deskriptif untuk parameter proses + kolom target gas (jika ada).
+    """
+    cols = [c for c in params if c in df.columns]
+    if target_col and target_col in df.columns:
+        cols.append(target_col)
+
+    if not cols:
+        return pd.DataFrame()
+
+    desc = df[cols].describe().T  # index = parameter
+    return desc
+
+
+# ============= CARA PENGGUNAAN =============
+if __name__ == "__main__":
+    df = pd.read_csv(r"C:\Dokumen\One To Many_17_10_2025\MMBTU\DASHBOARD\One To Many\disagregasi_data_spraydryer_terbaru_10_17_2025.csv")
+    pipeline = SprayDryerEDAPipeline(dataframe=df)
+    processed_df, product_dfs = pipeline.run_full_pipeline(show_visualizations=True)
+    processed_df.to_csv(r"Processed Data Pipeline EDA_21_10_2025.csv", index=False)
+    summary = pipeline.get_summary()
+    print(summary)

filter_rule_engine.py

@@ -0,0 +1,361 @@
+import pandas as pd
+
+
+# =========================
+# RULE 1 (detect_anomaly_new_rules)
+# =========================
+def _detect_anomaly_rule_1(df: pd.DataFrame) -> pd.Series:
+    """
+    LOGIKA ASLI (tidak diubah)
+    """
+    NOZZLE_PRESSURE = 'D101463PIC_PV'    # Tekanan nozzle
+    TIC_PV = 'D102265TIC_PV'             # Inlet Temperature
+    TOC = 'D101330TT'                    # Outlet Temperature
+    HP_CV = 'D102260TIC_CV'              # Steam Damper CV (High Pressure)
+    LP_CV = 'D102265TIC_CV'              # Steam Damper CV (Low Pressure)
+    
+    required_cols = [NOZZLE_PRESSURE, TIC_PV, TOC, HP_CV, LP_CV, 'Date_time']
+    for col in required_cols:
+        if col not in df.columns:
+            raise ValueError(f"❌ Kolom yang dibutuhkan '{col}' tidak ada di DataFrame.")
+
+    tmp = df.copy()
+    tmp['Date_time'] = pd.to_datetime(tmp['Date_time'])
+    tmp = tmp.sort_values('Date_time').reset_index(drop=True)
+
+    # 1 menit sebelumnya
+    rename_prev = {c: f"prev_{c}" for c in [TIC_PV, TOC, HP_CV, LP_CV]}
+    df_prev = tmp[['Date_time'] + list(rename_prev.keys())].rename(columns=rename_prev)
+    df_prev['Date_time'] = df_prev['Date_time'] + pd.Timedelta(minutes=1)
+
+    tmp = tmp.merge(df_prev, on='Date_time', how='left')
+
+    # Delta
+    tmp['delta_TIC'] = tmp[TIC_PV] - tmp[f'prev_{TIC_PV}']
+    tmp['delta_TOC'] = tmp[TOC]    - tmp[f'prev_{TOC}']
+    tmp['delta_HP']  = tmp[HP_CV]  - tmp[f'prev_{HP_CV}']
+    tmp['delta_LP']  = tmp[LP_CV]  - tmp[f'prev_{LP_CV}']
+
+    # Kondisi dasar: mesin running
+    is_running = tmp[NOZZLE_PRESSURE] >= 135
+
+    # Case A: Inlet TURUN
+    is_tic_delta_eq_neg_3 = (tmp['delta_TIC'] == -3)
+    is_toc_up = (tmp['delta_TOC'] > 0)
+    anomaly_case_A1 = is_running & is_tic_delta_eq_neg_3 & is_toc_up
+
+    is_tic_delta_lt_neg_3 = (tmp['delta_TIC'] < -3)
+    is_damper_up = (tmp['delta_HP'] > 0) | (tmp['delta_LP'] > 0)
+    anomaly_case_A2 = is_running & is_tic_delta_lt_neg_3 & is_damper_up
+
+    # Case B: Inlet NAIK
+    is_tic_delta_eq_pos_3 = (tmp['delta_TIC'] == 3)
+    is_toc_down = (tmp['delta_TOC'] < 0)
+    anomaly_case_B1 = is_running & is_tic_delta_eq_pos_3 & is_toc_down
+
+    is_tic_delta_gt_pos_3 = (tmp['delta_TIC'] > 3)
+    is_damper_down = (tmp['delta_HP'] < 0) | (tmp['delta_LP'] < 0)
+    anomaly_case_B2 = is_running & is_tic_delta_gt_pos_3 & is_damper_down
+
+    anomaly_flags = anomaly_case_A1 | anomaly_case_A2 | anomaly_case_B1 | anomaly_case_B2
+    anomaly_flags.name = "anomaly_flag"
+
+    print(f"✅ Jumlah anomali (Rule 1 - new_rules) terdeteksi: {anomaly_flags.sum()} dari {len(tmp)} baris data")
+    return anomaly_flags
+
+
+# =========================
+# RULE 2 (detect_anomaly_rule_2_revised)
+# =========================
+def _detect_anomaly_rule_2(df: pd.DataFrame) -> pd.Series:
+    """
+    LOGIKA ASLI (tidak diubah)
+    """
+    NOZZLE_PRESSURE = 'D101463PIC_PV'
+    FF = 'D101264FTSCL'  # Flow Feed
+    TOC = 'D101330TT'    # Outlet Temperature
+
+    required_cols = [NOZZLE_PRESSURE, FF, TOC, 'Date_time']
+    for col in required_cols:
+        if col not in df.columns:
+            raise ValueError(f"❌ Kolom '{col}' tidak ada di DataFrame.")
+
+    tmp = df.copy()
+    tmp['Date_time'] = pd.to_datetime(tmp['Date_time'])
+    tmp = tmp.sort_values('Date_time').reset_index(drop=True)
+
+    # 1 menit sebelumnya
+    rename_prev = {c: f'prev_{c}' for c in [FF, TOC]}
+    df_prev = tmp[['Date_time'] + list(rename_prev.keys())].rename(columns=rename_prev)
+    df_prev['Date_time'] = df_prev['Date_time'] + pd.Timedelta(minutes=1)
+    tmp = tmp.merge(df_prev, on='Date_time', how='left')
+
+    # Delta
+    tmp['delta_FF'] = tmp[FF]  - tmp[f'prev_{FF}']
+    tmp['delta_TOC'] = tmp[TOC] - tmp[f'prev_{TOC}']
+
+    # Kondisi dasar: mesin running
+    is_running = tmp[NOZZLE_PRESSURE] >= 135
+
+    # Kondisi 1: FF turun & TOC turun signifikan
+    is_ff_down = tmp['delta_FF'] < 0
+    is_toc_drop_significant = tmp['delta_TOC'] <= -1.0
+    anomaly_case_1 = is_running & is_ff_down & is_toc_drop_significant
+
+    # Kondisi 2: FF naik & TOC naik 1 s/d 12.59
+    is_ff_up = tmp['delta_FF'] > 0
+    is_toc_rise_in_range = (tmp['delta_TOC'] >= 1.0) & (tmp['delta_TOC'] <= 12.59)
+    anomaly_case_2 = is_running & is_ff_up & is_toc_rise_in_range
+
+    anomaly_flags = anomaly_case_1 | anomaly_case_2
+    anomaly_flags.name = "anomaly_flag_2"
+
+    print(f"✅ Jumlah anomali (Rule 2 Rev) terdeteksi: {anomaly_flags.sum()} dari {len(tmp)} baris data")
+    return anomaly_flags
+
+
+# =========================
+# RULE 3 (detect_anomaly_rule_3_revised)
+# =========================
+def _detect_anomaly_rule_3(df: pd.DataFrame) -> pd.Series:
+    """
+    LOGIKA ASLI (tidak diubah)
+    """
+    NOZZLE_PRESSURE = 'D101463PIC_PV'
+    FF = 'D101264FTSCL'
+    TIC_PV = 'D102265TIC_PV'
+    GAS_MMBTU = 'GAS_MMBTU_Disaggregated'
+
+    required_cols = [NOZZLE_PRESSURE, FF, TIC_PV, GAS_MMBTU, 'Date_time']
+    for col in required_cols:
+        if col not in df.columns:
+            raise ValueError(f"❌ Kolom '{col}' tidak ada di DataFrame.")
+
+    tmp = df.copy()
+    tmp['Date_time'] = pd.to_datetime(tmp['Date_time'])
+    tmp = tmp.sort_values('Date_time').reset_index(drop=True)
+
+    # 1 menit sebelumnya
+    rename_prev = {c: f'prev_{c}' for c in [FF, TIC_PV, GAS_MMBTU]}
+    df_prev = tmp[['Date_time'] + list(rename_prev.keys())].rename(columns=rename_prev)
+    df_prev['Date_time'] = df_prev['Date_time'] + pd.Timedelta(minutes=1)
+    tmp = tmp.merge(df_prev, on='Date_time', how='left')
+
+    # Delta
+    tmp['delta_FF'] = tmp[FF]         - tmp[f'prev_{FF}']
+    tmp['delta_TIC'] = tmp[TIC_PV]    - tmp[f'prev_{TIC_PV}']
+    tmp['delta_MMBTU'] = tmp[GAS_MMBTU] - tmp[f'prev_{GAS_MMBTU}']
+
+    # Kondisi dasar: mesin running
+    is_running = tmp[NOZZLE_PRESSURE] >= 135
+
+    # Rule 1: FF naik, TIC naik, tapi GAS turun
+    is_ff_up = tmp['delta_FF'] > 0
+    is_tic_up = tmp['delta_TIC'] > 0
+    is_mmbtu_down = tmp['delta_MMBTU'] < 0
+    anomaly_case_1 = is_running & is_ff_up & is_tic_up & is_mmbtu_down
+
+    # Rule 2: FF turun, TIC turun, tapi GAS naik
+    is_ff_down = tmp['delta_FF'] < 0
+    is_tic_down = tmp['delta_TIC'] < 0
+    is_mmbtu_up = tmp['delta_MMBTU'] > 0
+    anomaly_case_2 = is_running & is_ff_down & is_tic_down & is_mmbtu_up
+
+    anomaly_flags = anomaly_case_1 | anomaly_case_2
+    anomaly_flags.name = "anomaly_flag_3"
+
+    print(f"✅ Jumlah anomali (Rule 3 Rev) terdeteksi: {anomaly_flags.sum()} dari {len(tmp)} baris data")
+    return anomaly_flags
+
+
+# =========================
+# RULE 4 (detect_spray_dryer_anomalies)
+# =========================
+def _detect_anomaly_rule_4(df: pd.DataFrame) -> pd.Series:
+    """
+    LOGIKA ASLI (tidak diubah)
+    """
+    NOZZLE_PRESSURE = 'D101463PIC_PV'
+    HP_CV = 'D102260TIC_CV'
+    LP_CV = 'D102265TIC_CV'
+    TIC = 'D102265TIC_PV'
+    TOC = 'D101330TT'
+    
+    required_cols = [NOZZLE_PRESSURE, HP_CV, LP_CV, TIC, TOC, 'Date_time']
+    for col in required_cols:
+        if col not in df.columns:
+            raise ValueError(f"❌ Kolom '{col}' tidak ada di DataFrame.")
+
+    tmp = df.copy()
+    tmp['Date_time'] = pd.to_datetime(tmp['Date_time'])
+    tmp = tmp.sort_values('Date_time').reset_index(drop=True)
+
+    # 1 menit sebelumnya untuk HP & LP
+    rename_prev = {c: f'prev_{c}' for c in [HP_CV, LP_CV]}
+    df_prev = tmp[['Date_time'] + list(rename_prev.keys())].rename(columns=rename_prev)
+    df_prev['Date_time'] = df_prev['Date_time'] + pd.Timedelta(minutes=1)
+    tmp = tmp.merge(df_prev, on='Date_time', how='left')
+
+    # Delta
+    tmp['delta_HP'] = tmp[HP_CV] - tmp[f'prev_{HP_CV}']
+    tmp['delta_LP'] = tmp[LP_CV] - tmp[f'prev_{LP_CV}']
+
+    # Kondisi dasar: mesin running
+    is_running = tmp[NOZZLE_PRESSURE] >= 135
+
+    # Aturan 1: HP naik, LP turun > 1
+    is_hp_up = tmp['delta_HP'] > 0
+    is_lp_down_significant = tmp['delta_LP'] < -1.0
+    anomaly_1 = is_hp_up & is_lp_down_significant
+    
+    # Aturan 2: HP turun, LP naik > 1
+    is_hp_down = tmp['delta_HP'] < 0
+    is_lp_up_significant = tmp['delta_LP'] > 1.0
+    anomaly_2 = is_hp_down & is_lp_up_significant
+
+    # Aturan 3: TOC > TIC
+    anomaly_3 = tmp[TOC] > tmp[TIC]
+
+    final_anomaly_flags = is_running & (anomaly_1 | anomaly_2 | anomaly_3)
+    final_anomaly_flags.name = "anomaly_flag_4"
+
+    print(f"✅ Jumlah anomali (Rule 4) terdeteksi: {final_anomaly_flags.sum()} dari {len(tmp)} baris data")
+    return final_anomaly_flags
+
+
+# =========================
+# PIPELINE UTAMA
+# =========================
+def apply_rule_engine(df: pd.DataFrame):
+    """
+    Pipeline terintegrasi + pre-filter CIP/CIP CHAMBER.
+
+    Returns:
+    - df_clean      : data yang sudah bersih (tanpa CIP & tanpa anomali rule engine)
+    - df_anomalies  : semua baris yang dihapus + kolom alasan ('anomaly_reason')
+    - summary_report: dict ringkasan (total, persentase, CIP, dst.)
+    """
+    df_original = df.copy()
+    total_rows_initial = len(df_original)
+
+    # --- 1) Hapus CIP & CIP CHAMBER lebih dulu ---
+    if "Product" in df_original.columns:
+        cip_mask = df_original["Product"].isin(["CIP", "CIP CHAMBER"])
+    else:
+        cip_mask = pd.Series(False, index=df_original.index)
+
+    df_cip = df_original[cip_mask].copy()
+    df_non_cip = df_original[~cip_mask].copy()
+    cip_removed = int(cip_mask.sum())
+
+    # Siapkan kolom flag awal untuk CIP
+    rule_flag_cols = ["anomaly_flag", "anomaly_flag_2", "anomaly_flag_3", "anomaly_flag_4"]
+    if not df_cip.empty:
+        for c in rule_flag_cols + ["anomaly_any"]:
+            df_cip[c] = False
+        df_cip["anomaly_reason"] = "Produk CIP / CIP CHAMBER (dihapus sebelum rule engine)"
+
+    # --- 2) Jalankan 4 rule di data non-CIP ---
+    if len(df_non_cip) > 0:
+        rule1_flags = _detect_anomaly_rule_1(df_non_cip)
+        rule2_flags = _detect_anomaly_rule_2(df_non_cip)
+        rule3_flags = _detect_anomaly_rule_3(df_non_cip)
+        rule4_flags = _detect_anomaly_rule_4(df_non_cip)
+
+        df_with_flags = df_non_cip.copy()
+        df_with_flags["anomaly_flag"]   = rule1_flags.values
+        df_with_flags["anomaly_flag_2"] = rule2_flags.values
+        df_with_flags["anomaly_flag_3"] = rule3_flags.values
+        df_with_flags["anomaly_flag_4"] = rule4_flags.values
+
+        df_with_flags["anomaly_any"] = df_with_flags[rule_flag_cols].any(axis=1)
+
+        df_clean_rules = df_with_flags[~df_with_flags["anomaly_any"]].reset_index(drop=True)
+        df_anomaly_rules = df_with_flags[df_with_flags["anomaly_any"]].reset_index(drop=True)
+
+        # Build alasan tiap baris rule
+        def _build_reasons(row):
+            reasons = []
+            if row["anomaly_flag"]:
+                reasons.append("Rule 1 – TIC/TOC vs Damper dynamics")
+            if row["anomaly_flag_2"]:
+                reasons.append("Rule 2 – Flow Feed vs TOC")
+            if row["anomaly_flag_3"]:
+                reasons.append("Rule 3 – Flow & TIC vs GAS MMBTU")
+            if row["anomaly_flag_4"]:
+                reasons.append("Rule 4 – HP/LP damper & TOC>TIC")
+            return "; ".join(reasons)
+
+        if not df_anomaly_rules.empty:
+            df_anomaly_rules["anomaly_reason"] = df_anomaly_rules.apply(_build_reasons, axis=1)
+    else:
+        # Tidak ada data non-CIP
+        df_clean_rules = df_non_cip.copy()
+        df_anomaly_rules = df_non_cip.iloc[0:0].copy()
+        df_with_flags = df_non_cip.copy()
+
+    # --- 3) Satukan semua baris anomali: CIP + rule engine ---
+    if not df_cip.empty and not df_anomaly_rules.empty:
+        df_anomalies = pd.concat([df_cip, df_anomaly_rules], ignore_index=True, sort=False)
+    elif not df_cip.empty:
+        df_anomalies = df_cip.copy()
+    else:
+        df_anomalies = df_anomaly_rules.copy()
+
+    # Data bersih final = clean_rules (non-CIP & lolos semua rule)
+    df_clean = df_clean_rules.copy()
+
+    # --- 4) Ringkasan angka ---
+    total_rows_after_filter = len(df_clean)
+    total_rows_removed = total_rows_initial - total_rows_after_filter
+    percent_clean = float(total_rows_after_filter / total_rows_initial * 100) if total_rows_initial > 0 else 0.0
+
+    # Breakdown CIP vs Rule
+    rule_rows_removed = len(df_anomaly_rules)
+    rule_percent = float(rule_rows_removed / total_rows_initial * 100) if total_rows_initial > 0 else 0.0
+    cip_percent = float(cip_removed / total_rows_initial * 100) if total_rows_initial > 0 else 0.0
+
+    # Jumlah jenis anomali unik
+    if not df_anomalies.empty and "anomaly_reason" in df_anomalies.columns:
+        num_anomaly_types = int(df_anomalies["anomaly_reason"].nunique())
+    else:
+        num_anomaly_types = 0
+
+    summary_report = {
+        "total_rows_initial": total_rows_initial,
+        "total_rows_after_filter": total_rows_after_filter,
+        "total_rows_removed": total_rows_removed,
+        "percent_clean": percent_clean,
+        "cip_rows_removed": cip_removed,
+        "cip_percent": cip_percent,
+        "rule_rows_removed": rule_rows_removed,
+        "rule_percent": rule_percent,
+        "num_anomaly_types": num_anomaly_types,
+    }
+
+    print(f"✅ Jumlah data awal : {total_rows_initial}")
+    print(f"✅ Jumlah data bersih: {total_rows_after_filter}")
+    print(f"🗑️ Jumlah baris yang dihapus (CIP + anomali rule): {total_rows_removed}")
+
+    return df_clean, df_anomalies, summary_report
+
+
+# Alias utk kompatibilitas lama
+def apply_spray_dryer_rule_engine(df: pd.DataFrame):
+    return apply_rule_engine(df)
+
+
+if __name__ == "__main__":
+    # Contoh pemakaian manual
+    path_csv = "/work/Dataset 18 Mar - 19 Jun/disagregasi_data_spraydryer_terbaru_10_17_2025.csv"
+    try:
+        df_raw = pd.read_csv(path_csv)
+        df_clean, df_anom, summary = apply_rule_engine(df_raw)
+
+        print("\n--- RINGKASAN ---")
+        for k, v in summary.items():
+            print(f"{k}: {v}")
+        print("Contoh anomali:")
+        print(df_anom.head())
+    except FileNotFoundError:
+        print(f"File contoh tidak ditemukan: {path_csv}")

inverse_model_forward.py

@@ -0,0 +1,119 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import os
+
+# --- KONFIGURASI PATH ---
+BASE_MODEL_FOLDER = r"C:\Dokumen\One To Many_17_10_2025\MMBTU\DASHBOARD\One To Many\MODEL CHECKPOINT FOR INVERSE MODEL"
+AVAILABLE_PRODUCTS = ["BMR BASE", "CKP BASE", "CKR BASE", "CMR BASE", "MORIGRO BASE"]
+INPUT_FEATURES = [
+    "D101330TT", "D102260TIC_CV", "D102265TIC_PV",
+    "D102265TIC_CV", "D102266TIC", "D101264FTSCL"
+]
+@st.cache_resource(show_spinner="Memuat model...")
+def load_model_artifacts(product_name, base_folder):
+    file_name = f"model_checkpoint_xgb_{product_name}.joblib"
+    model_path = os.path.join(base_folder, file_name)
+    if not os.path.exists(model_path):
+        st.error(f"File model tidak ditemukan untuk **{product_name}** di: **{model_path}**")
+        return None, None, None, None
+
+    try:
+        deployment_bundle = joblib.load(model_path)
+        
+        # Mengambil artefak sesuai dengan struktur kode awal Anda
+        model = deployment_bundle.get('model')
+        poly_transformer = deployment_bundle.get('poly_transformer')
+        input_features = deployment_bundle.get('input_features')
+        poly_feature_names = deployment_bundle.get('poly_feature_names')
+        
+        # Validasi sederhana
+        if model is None or poly_transformer is None or input_features is None or poly_feature_names is None:
+             st.error(f"Salah satu artefak (model, poly_transformer, input_features, poly_feature_names) hilang dalam file joblib **{product_name}**.")
+             return None, None, None, None
+             
+        return model, poly_transformer, input_features, poly_feature_names
+    
+    except Exception as e:
+        st.error(f"Gagal memuat atau membaca file joblib. Error: {e}")
+        return None, None, None, None
+
+# --- TAMPILAN (UI) STREAMLIT ---
+st.set_page_config(page_title="Dashboard Prediksi GAS MMBTU", layout="wide")
+with st.sidebar:
+    st.header("⚙️ Konfigurasi Model")
+    # Dropdown untuk memilih produk
+    selected_product = st.selectbox(
+        "Pilih Produk Target:", 
+        AVAILABLE_PRODUCTS, 
+        index=AVAILABLE_PRODUCTS.index("CKR BASE") if "CKR BASE" in AVAILABLE_PRODUCTS else 0
+    )
+    st.markdown(f"**Folder Model:** `{BASE_MODEL_FOLDER}`")
+st.title(f"🔥 Dashboard Prediksi GAS MMBTU: **{selected_product}**")
+st.markdown("Dashboard ini menggunakan model **XGBoost** dan transformasi **Polinomial**.")
+st.markdown("---")
+model, poly_transformer, input_features_loaded, poly_feature_names = load_model_artifacts(
+    selected_product, BASE_MODEL_FOLDER
+)
+
+if model is None:
+    st.stop() # Berhenti jika model gagal dimuat
+    
+# Cek apakah fitur input konsisten
+if set(input_features_loaded) != set(INPUT_FEATURES):
+    st.warning("Fitur Input yang dimuat dari joblib berbeda dengan daftar fitur default. Menggunakan fitur dari joblib.")
+    INPUT_FEATURES = input_features_loaded
+st.subheader("🧪 Masukkan Nilai Input Mentah")
+st.markdown("Harap masukkan nilai numerik untuk 6 fitur di bawah:")
+
+# Membuat kolom input untuk 6 fitur
+cols = st.columns(len(INPUT_FEATURES))
+user_raw_data = {}
+for i, feature in enumerate(INPUT_FEATURES):
+    # Menggunakan nilai default untuk contoh
+    default_value = 0.0 
+    if feature == "D101330TT": default_value = 95.0
+    elif feature == "D102260TIC_CV": default_value = 45.0
+    elif feature == "D102265TIC_PV": default_value = 185.0
+    elif feature == "D102265TIC_CV": default_value = 17.0
+    elif feature == "D102266TIC": default_value = 16.0
+    elif feature == "D101264FTSCL": default_value = 3800.0
+    
+    # Input nilai per fitur
+    user_raw_data[feature] = cols[i].number_input(
+        feature, 
+        value=default_value, 
+        format="%.4f", 
+        key=f"input_{feature}"
+    )
+
+st.markdown("---")
+
+# Tombol prediksi
+if st.button("🔮 Prediksi GAS MMBTU Sekarang", type="primary", use_container_width=True):
+    
+    # Membuat DataFrame dari input mentah (sesuai urutan fitur input)
+    sim_input_df = pd.DataFrame([user_raw_data])[INPUT_FEATURES]
+
+    st.subheader("⚙️ Proses Transformasi & Prediksi")
+
+    # 1. Transformasi Polinomial
+    with st.spinner("1. Menerapkan transformasi polinomial..."):
+        transformed_input_np = poly_transformer.transform(sim_input_df)
+        transformed_input_df = pd.DataFrame(
+            transformed_input_np, 
+            columns=poly_feature_names,
+            index=sim_input_df.index
+        )
+    # 2. Prediksi
+    with st.spinner("2. Melakukan prediksi dengan model..."):
+        predictions = model.predict(transformed_input_df)
+        prediksi_final = predictions[0]
+    
+    st.markdown("### ✅ Hasil Prediksi")
+    st.metric(
+        f"Prediksi Kebutuhan **GAS MMBTU** untuk {selected_product}", 
+        f"{prediksi_final:.6f}MMBTU"
+    )
+st.markdown("---")

prediksi_model_inverse.py

@@ -0,0 +1,64 @@
+import os
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import os
+from datetime import datetime
+from sklearn.preprocessing import MinMaxScaler
+import openpyxl
+from scipy.optimize import differential_evolution
+
+def predict_forward_from_params(product_name: str, params_dict: dict, model_folder: str) -> float:
+    """
+    Jalankan forward modelling XGBoost many-to-one untuk 1 baris input parameter.
+    Dipakai baik untuk Validasi maupun Simulasi agar konsisten.
+    """
+    model_filename = f"model_checkpoint_xgb_{product_name}.joblib"
+    model_path = os.path.join(model_folder, model_filename)
+
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"File model untuk produk {product_name} tidak ditemukan: {model_path}")
+
+    artifacts = joblib.load(model_path)
+
+    # Struktur bundle: dict dengan kunci 'model', 'poly_transformer', 'input_features', 'poly_feature_names'
+    if isinstance(artifacts, dict):
+        fwd_model = artifacts.get("model", artifacts)
+        poly_transformer = artifacts.get("poly_transformer", None)
+        input_features = artifacts.get("input_features", list(params_dict.keys()))
+        poly_feature_names = artifacts.get("poly_feature_names", None)
+    else:
+        # Fallback: kalau bukan dict, anggap langsung model
+        fwd_model = artifacts
+        poly_transformer = None
+        input_features = list(params_dict.keys())
+        poly_feature_names = None
+
+    # Susun DataFrame satu baris
+    X_base = pd.DataFrame([params_dict])
+
+    # Pastikan semua fitur ada
+    missing = [f for f in input_features if f not in X_base.columns]
+    if missing:
+        raise ValueError(
+            "Fitur berikut dibutuhkan oleh model namun tidak ada di input: "
+            + ", ".join(missing)
+        )
+
+    # Urutkan kolom sesuai urutan training
+    X_base = X_base[input_features]
+
+    # Polynomial features jika ada
+    if poly_transformer is not None:
+        X_poly = poly_transformer.transform(X_base)
+        if (poly_feature_names is not None) and (len(poly_feature_names) == X_poly.shape[1]):
+            X_final = pd.DataFrame(X_poly, columns=poly_feature_names)
+        else:
+            X_final = pd.DataFrame(X_poly)
+    else:
+        X_final = X_base
+
+    # Prediksi
+    y_pred = fwd_model.predict(X_final)[0]
+    return float(y_pred)

requirements.txt

@@ -0,0 +1,10 @@
+streamlit
+pandas 
+numpy 
+joblib 
+scikit-learn 
+openpyxl 
+scipy 
+matplotlib 
+seaborn 
+xgboost