Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,522 @@
-import altair as alt
+
+
+import os
+import json
+import time
+from datetime import datetime
 import numpy as np
 import pandas as pd
 import streamlit as st
+import matplotlib.pyplot as plt
+import seaborn as sns
+import joblib
+
+# ML imports
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LinearRegression
+from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, ExtraTreesRegressor
+from sklearn.preprocessing import StandardScaler, PolynomialFeatures
+from sklearn.decomposition import PCA
+from sklearn.cluster import KMeans
+from sklearn.metrics import mean_squared_error, r2_score
+
+# SHAP
+import shap
+
+# -------------------------
+# Config & paths
+# -------------------------
+st.set_page_config(page_title="AI Feature Universe Explorer — Advanced + SHAP", layout="wide")
+DATA_DIR = "/mnt/data"
+CSV_PATH = os.path.join(DATA_DIR, "flatfile_universe_advanced.csv")
+META_PATH = os.path.join(DATA_DIR, "feature_metadata_advanced.json")
+PDF_PATH = os.path.join(DATA_DIR, "annotated_bibliography.pdf")
+ENSEMBLE_ARTIFACT = os.path.join(DATA_DIR, "ensemble_models.joblib")
+
+# -------------------------
+# Utility: generate advanced dataset if missing
+# -------------------------
+def generate_advanced_flatfile(n_rows=3000, random_seed=42, max_polynomial_new=60):
+    """
+    Generates a large synthetic, physics-aligned dataset with many engineered features.
+    Saves CSV and metadata JSON and a short annotated bibliography PDF (text).
+    """
+    np.random.seed(random_seed)
+    os.makedirs(DATA_DIR, exist_ok=True)
+    # --- base natural features across 8 use cases (expanded)
+    natural_feats = [
+        "vibration_x","vibration_y","motor_current","rpm","bearing_temp","ambient_temp","lube_pressure","power_factor",
+        "furnace_temp","tap_temp","slag_temp","offgas_co","offgas_co2","o2_probe_pct","c_feed_rate","arc_power","furnace_pressure","feed_time",
+        "mold_temp","casting_speed","nozzle_pressure","cooling_water_temp","billet_length","chemical_C","chemical_Mn","chemical_Si","chemical_S",
+        "roll_speed","motor_load","coolant_flow","exit_temp","strip_thickness","line_tension","roller_vibration",
+        "lighting_intensity","surface_temp","image_entropy_proxy",
+        "spectro_Fe","spectro_C","spectro_Mn","spectro_Si","time_since_last_sample",
+        "batch_id_numeric","weight_input","weight_output","time_in_queue","conveyor_speed",
+        "shell_temp","lining_thickness","water_flow","cooling_out_temp","heat_flux"
+    ]
+    # dedupe if duplicated names
+    natural_feats = list(dict.fromkeys(natural_feats))
+
+    # helper sampling heuristics
+    def sample_col(name, n):
+        name_l = name.lower()
+        if "furnace_temp" in name_l or name_l.endswith("_temp") or "tap_temp" in name_l:
+            return np.random.normal(1550, 50, n)
+        if name_l in ("tap_temp","mold_temp","shell_temp","cooling_out_temp","exit_temp"):
+            return np.random.normal(200 if "mold" not in name_l else 1500, 30, n)
+        if "offgas_co2" in name_l:
+            return np.abs(np.random.normal(15,4,n))
+        if "offgas_co" in name_l:
+            return np.abs(np.random.normal(20,5,n))
+        if "o2" in name_l:
+            return np.clip(np.random.normal(5,1,n), 0.01, 60)
+        if "arc_power" in name_l or "motor_load" in name_l:
+            return np.abs(np.random.normal(600,120,n))
+        if "rpm" in name_l:
+            return np.abs(np.random.normal(120,30,n))
+        if "vibration" in name_l:
+            return np.abs(np.random.normal(0.4,0.15,n))
+        if "bearing_temp" in name_l:
+            return np.random.normal(65,5,n)
+        if "chemical" in name_l or "spectro" in name_l:
+            return np.random.normal(0.7,0.15,n)
+        if "weight" in name_l:
+            return np.random.normal(1000,100,n)
+        if "conveyor_speed" in name_l or "casting_speed" in name_l:
+            return np.random.normal(2.5,0.6,n)
+        if "power_factor" in name_l:
+            return np.clip(np.random.normal(0.92,0.03,n),0.6,1.0)
+        if "image_entropy_proxy" in name_l:
+            return np.abs(np.random.normal(0.5,0.25,n))
+        if "batch_id" in name_l:
+            return np.random.randint(1000,9999,n)
+        if "time_since" in name_l or "time_in_queue" in name_l:
+            return np.abs(np.random.normal(30,20,n))
+        if "heat_flux" in name_l:
+            return np.abs(np.random.normal(1000,300,n))
+        return np.random.normal(0,1,n)
+
+    # build DF
+    df = pd.DataFrame({c: sample_col(c, n_rows) for c in natural_feats})
+
+    # timestamps & metadata
+    start = pd.Timestamp("2025-01-01T00:00:00")
+    df["timestamp"] = pd.date_range(start, periods=n_rows, freq="T")
+    df["cycle_minute"] = np.mod(np.arange(n_rows), 80)
+    df["meta_plant_name"] = np.random.choice(["Rourkela","Jamshedpur","VSP","Bokaro","Kalinganagar","Salem"], n_rows)
+    df["meta_country"] = "India"
+
+    # --- synthetic features: physics informed proxies
+    df["carbon_proxy"] = df["offgas_co"] / (df["offgas_co2"] + 1.0)
+    df["oxygen_utilization"] = df["offgas_co2"] / (df["offgas_co"] + 1.0)
+    df["power_density"] = df["arc_power"] / (df["weight_input"] + 1.0)
+    df["energy_efficiency"] = df["furnace_temp"] / (df["arc_power"] + 1.0)
+    df["slag_foaming_index"] = (df["slag_temp"] * df["offgas_co"]) / (df["o2_probe_pct"] + 1.0)
+    df["yield_ratio"] = df["weight_output"] / (df["weight_input"] + 1e-9)
+
+    # rolling stats, lags, rocs for a prioritized set
+    rolling_cols = ["arc_power","furnace_temp","offgas_co","offgas_co2","motor_current","vibration_x","weight_input"]
+    for rc in rolling_cols:
+        if rc in df.columns:
+            df[f"{rc}_roll_mean_3"] = df[rc].rolling(3, min_periods=1).mean()
+            df[f"{rc}_roll_std_5"] = df[rc].rolling(5, min_periods=1).std().fillna(0)
+            df[f"{rc}_lag1"] = df[rc].shift(1).fillna(method="bfill")
+            df[f"{rc}_roc_1"] = df[rc].diff().fillna(0)
+
+    # interaction & polynomial-lite
+    df["arc_o2_interaction"] = df["arc_power"] * df["o2_probe_pct"]
+    df["carbon_power_ratio"] = df["carbon_proxy"] / (df["arc_power"] + 1e-6)
+    df["temp_power_sqrt"] = df["furnace_temp"] * np.sqrt(np.abs(df["arc_power"]) + 1e-6)
+
+    # polynomial features limited to first 12 numeric columns to avoid explosion
+    numeric = df.select_dtypes(include=[np.number]).fillna(0)
+    poly_source_cols = numeric.columns[:12].tolist()
+    poly = PolynomialFeatures(degree=2, interaction_only=False, include_bias=False)
+    poly_mat = poly.fit_transform(numeric[poly_source_cols])
+    poly_names = poly.get_feature_names_out(poly_source_cols)
+    poly_df = pd.DataFrame(poly_mat, columns=[f"poly__{n}" for n in poly_names], index=df.index)
+    # drop identical originals and limit new cols
+    keep_poly = [c for c in poly_df.columns if c.replace("poly__","") not in poly_source_cols]
+    if len(keep_poly) > 0:
+      poly_df = poly_df[keep_poly].iloc[:, :max_polynomial_new]
+    else:
+      poly_df = poly_df.iloc[:, :0]
+    df = pd.concat([df, poly_df], axis=1)
+
+    # PCA embeddings across numeric sensors
+    scaler = StandardScaler()
+    scaled = scaler.fit_transform(numeric)
+    pca = PCA(n_components=6, random_state=42)
+    pca_cols = pca.fit_transform(scaled)
+    for i in range(pca_cols.shape[1]):
+        df[f"pca_{i+1}"] = pca_cols[:, i]
+
+    # KMeans cluster label for operating mode
+    kmeans = KMeans(n_clusters=6, random_state=42, n_init=10)
+    df["operating_mode"] = kmeans.fit_predict(scaled)
+
+    # surrogate models to create short-horizon predicted states (fast regressors)
+    # furnace_temp_next surrogate
+    surrogate_df = df.copy()
+    surrogate_df["furnace_temp_next"] = surrogate_df["furnace_temp"].shift(-1).fillna(method="ffill")
+    features_for_surrogate = [c for c in ["furnace_temp","arc_power","o2_probe_pct","offgas_co","offgas_co2"] if c in df.columns]
+    if len(features_for_surrogate) >= 2:
+        X = surrogate_df[features_for_surrogate].fillna(0)
+        y = surrogate_df["furnace_temp_next"]
+        from sklearn.ensemble import RandomForestRegressor
+        rf = RandomForestRegressor(n_estimators=50, random_state=42, n_jobs=-1)
+        rf.fit(X, y)
+        df["pred_temp_30s"] = rf.predict(X)
+    else:
+        df["pred_temp_30s"] = df["furnace_temp"]
+
+    # surrogate for carbon proxy
+    if all(c in df.columns for c in ["offgas_co","offgas_co2","o2_probe_pct"]):
+        X2 = df[["offgas_co","offgas_co2","o2_probe_pct"]].fillna(0)
+        rf2 = RandomForestRegressor(n_estimators=50, random_state=1, n_jobs=-1)
+        rf2.fit(X2, df["carbon_proxy"])
+        df["pred_carbon_5min"] = rf2.predict(X2)
+    else:
+        df["pred_carbon_5min"] = df["carbon_proxy"]
+
+    # safety indices & flags
+    df["refractory_limit_flag"] = (df["lining_thickness"] < 140).astype(int)
+    df["max_allowed_power_delta"] = np.clip(df["arc_power"].diff().abs().fillna(0), 0, 2000)
+
+    # simple rule-based target action for demo
+    df["ARC_ON"] = ((df["arc_power"] > df["arc_power"].median()) & (df["carbon_proxy"] < 1.0)).astype(int)
+    df["prediction_confidence"] = np.clip(np.random.beta(2,5, n_rows), 0.05, 0.99)
+
+    # clean NaN and infinite
+    df.replace([np.inf, -np.inf], np.nan, inplace=True)
+    df.fillna(method="bfill", inplace=True)
+    df.fillna(0, inplace=True)
+
+    # save CSV & metadata
+    df.to_csv(CSV_PATH, index=False)
+
+    meta = []
+    for col in df.columns:
+        if col in natural_feats:
+            source = "natural"
+        elif col.startswith("poly__") or col.startswith("pca_") or col in ["operating_mode"]:
+            source = "advanced_synthetic"
+        else:
+            source = "synthetic"
+        meta.append({
+            "feature_name": col,
+            "source_type": source,
+            "linked_use_cases": ["All" if source!="natural" else "Mapped"],
+            "units": "-",
+            "formula": "see generator logic",
+            "remarks": "auto-generated or simulated"
+        })
+    with open(META_PATH, "w") as f:
+        json.dump(meta, f, indent=2)
+
+    # annotated bibliography text saved as simple PDF-like text (clients accept PDF)
+    try:
+        from fpdf import FPDF
+        pdf = FPDF('P','mm','A4')
+        pdf.add_page()
+        pdf.set_font("Helvetica","B",14)
+        pdf.cell(0,8,"Annotated Bibliography - Metallurgical AI (Selected Papers)", ln=True)
+        pdf.ln(2)
+        pdf.set_font("Helvetica","",10)
+        pdf.cell(0,6,"Generated: " + datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC"), ln=True)
+        pdf.ln(4)
+        bib_items = [
+            ("A Survey of Data-Driven Soft Sensing in Ironmaking Systems","Yan et al. (2024)","Review of soft-sensors; supports gas proxies, lags, PCA."),
+            ("Optimisation of Oxygen Blowing Process using RL","Ojeda Roldan et al. (2022)","RL for oxygen control; motivates surrogate predicted states & safety indices."),
+            ("Analyzing the Energy Efficiency of Electric Arc Furnace","Zhuo et al. (2024)","Energy KPIs (kWh/t) motivate power_density & energy_efficiency features."),
+            ("BOF/Endpoint prediction techniques","Springer (2024)","Endpoint prediction; supports temporal lags and cycle encoding."),
+            ("Dynamic EAF modeling & slag foaming","MacRosty et al.","Physics priors for slag_foaming_index and refractory health modeling.")
+        ]
+        for title, auth, note in bib_items:
+            pdf.set_font("Helvetica","B",11)
+            pdf.multi_cell(0,6, f"{title} — {auth}")
+            pdf.set_font("Helvetica","",10)
+            pdf.multi_cell(0,5, f"Notes: {note}")
+            pdf.ln(2)
+        pdf.output(PDF_PATH)
+    except Exception as e:
+        # fallback: simple text file
+        with open(PDF_PATH.replace(".pdf",".txt"), "w") as tf:
+            tf.write("Annotated bibliography generated. Install fpdf for PDF output.\n")
+    return CSV_PATH, META_PATH, PDF_PATH
+
+# -------------------------
+# Ensure dataset exists
+# -------------------------
+if not os.path.exists(CSV_PATH) or not os.path.exists(META_PATH):
+    with st.spinner("Generating advanced feature universe (this may take ~20-60s)..."):
+        CSV_PATH, META_PATH, PDF_PATH = generate_advanced_flatfile(n_rows=3000, random_seed=42, max_polynomial_new=80)
+        st.success(f"Generated dataset and metadata: {CSV_PATH}")
+
+# -------------------------
+# Load data & metadata (cached)
+# -------------------------
+@st.cache_data
+def load_data(csv_path=CSV_PATH, meta_path=META_PATH):
+    df_local = pd.read_csv(csv_path)
+    with open(meta_path, "r") as f:
+        meta_local = json.load(f)
+    return df_local, pd.DataFrame(meta_local)
+
+df, meta_df = load_data()
+
+# -------------------------
+# Sidebar filters & UI
+# -------------------------
+st.sidebar.title("🔎 Feature Explorer - Advanced + SHAP")
+feat_types = sorted(meta_df["source_type"].unique().tolist())
+selected_types = st.sidebar.multiselect("Feature type", feat_types, default=feat_types)
+numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+
+# -------------------------
+# Main tabs
+# -------------------------
+st.title("Steel Authority of India Limited (SHAP-enabled)")
+tabs = st.tabs([
+    "Features",
+    "Visualize",
+    "Correlations",
+    "Stats",
+    "Ensemble + SHAP",
+    "Target & Business Impact",
+    "Bibliography"
+])
+
+# ----- Features tab
+with tabs[0]:
+    st.subheader("Feature metadata")
+    filtered_meta = meta_df[meta_df["source_type"].isin(selected_types)]
+    st.dataframe(filtered_meta[["feature_name","source_type","formula","remarks"]].rename(columns={"feature_name":"Feature"}), height=400)
+    st.markdown(f"Total features loaded: **{df.shape[1]}**  |  Rows: **{df.shape[0]}**")
+
+# ----- Visualize tab
+with tabs[1]:
+    st.subheader("Feature visualization")
+    col = st.selectbox("Choose numeric feature", numeric_cols, index=0)
+    bins = st.slider("Histogram bins", 10, 200, 50)
+    fig, ax = plt.subplots(figsize=(8,4))
+    sns.histplot(df[col], bins=bins, kde=True, ax=ax)
+    ax.set_title(col)
+    st.pyplot(fig)
+    st.write(df[col].describe().to_frame().T)
+
+# ----- Correlations tab
+with tabs[2]:
+    st.subheader("Correlation explorer")
+    default_corr = numeric_cols[:20] if len(numeric_cols) >= 20 else numeric_cols
+    corr_sel = st.multiselect("Select features (min 2)", numeric_cols, default=default_corr)
+    if len(corr_sel) >= 2:
+        corr = df[corr_sel].corr()
+        fig, ax = plt.subplots(figsize=(10,8))
+        sns.heatmap(corr, cmap="coolwarm", center=0, ax=ax)
+        st.pyplot(fig)
+    else:
+        st.info("Choose at least 2 numeric features to compute correlation.")
+
+# ----- Stats tab
+with tabs[3]:
+    st.subheader("Summary statistics (numeric features)")
+    st.dataframe(df.describe().T.style.format("{:.3f}"), height=500)
+
+# ----- Ensemble + SHAP tab
+with tabs[4]:
+    st.subheader("Ensemble modeling sandbox (fast) + SHAP explainability")
+    # Feature & target selector
+    target = st.selectbox("Target variable", numeric_cols, index=numeric_cols.index("furnace_temp") if "furnace_temp" in numeric_cols else 0)
+    default_features = [c for c in numeric_cols if c != target][:50]  # preselect up to 50 features default
+    features = st.multiselect("Model input features (select many; start with defaults)", numeric_cols, default=default_features)
+    sample_size = st.slider("Sample rows to use for training (speed vs fidelity)", min_value=200, max_value=min(4000, df.shape[0]), value=1000, step=100)
+    train_button = st.button("Train ensemble & compute SHAP (recommended sample only)")
+
+    if train_button:
+        with st.spinner("Preparing data and training ensemble..."):
+            sub_df = df[features + [target]].sample(n=sample_size, random_state=42)
+            X = sub_df[features].fillna(0)
+            y = sub_df[target].fillna(0)
+            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+            # models
+            models = {
+                "Linear": LinearRegression(),
+                "RandomForest": RandomForestRegressor(n_estimators=150, random_state=42, n_jobs=-1),
+                "GradientBoosting": GradientBoostingRegressor(n_estimators=150, random_state=42),
+                "ExtraTrees": ExtraTreesRegressor(n_estimators=150, random_state=42, n_jobs=-1)
+            }
+            preds = {}
+            results = []
+            for name, m in models.items():
+                m.fit(X_train, y_train)
+                p = m.predict(X_test)
+                preds[name] = p
+                results.append({"Model": name, "R2": r2_score(y_test, p), "RMSE": float(np.sqrt(mean_squared_error(y_test, p)))})
+            # ensemble average
+            ensemble_pred = np.column_stack(list(preds.values())).mean(axis=1)
+            results.append({"Model": "EnsembleAvg", "R2": r2_score(y_test, ensemble_pred), "RMSE": float(np.sqrt(mean_squared_error(y_test, ensemble_pred)))})
+            st.dataframe(pd.DataFrame(results).set_index("Model").round(4))
+
+            # scatter
+            fig, ax = plt.subplots(figsize=(8,4))
+            ax.scatter(y_test, ensemble_pred, alpha=0.5)
+            ax.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], "r--")
+            ax.set_xlabel("Actual"); ax.set_ylabel("Predicted (Ensemble)")
+            st.pyplot(fig)
+
+            # save the models (lightweight)
+            joblib.dump(models, ENSEMBLE_ARTIFACT)
+            st.success(f"Saved ensemble models to {ENSEMBLE_ARTIFACT}")
+
+            # ---------- SHAP explainability ----------
+            st.markdown("### SHAP Explainability — pick a model to explain (Tree models recommended)")
+            explain_model_name = st.selectbox("Model to explain", list(models.keys()), index= list(models.keys()).index("RandomForest") if "RandomForest" in models else 0)
+            explainer_sample = st.slider("Number of rows to use for SHAP explanation (memory heavy)", 50, min(1500, sample_size), value=300, step=50)
+
+            # Use a Tree explainer if possible; otherwise KernelExplainer (slow)
+            model_to_explain = models[explain_model_name]
+            X_shap = X_test.copy()
+            if explainer_sample < X_shap.shape[0]:
+                X_shap_for = X_shap.sample(n=explainer_sample, random_state=42)
+            else:
+                X_shap_for = X_shap
+
+            with st.spinner("Computing SHAP values (this may take a while for large SHAP sample)..."):
+                try:
+                    if hasattr(model_to_explain, "predict") and (explain_model_name in ["RandomForest","ExtraTrees","GradientBoosting"]):
+                        explainer = shap.TreeExplainer(model_to_explain)
+                        shap_values = explainer.shap_values(X_shap_for)
+                        # summary plot
+                        import warnings
+                        warnings.filterwarnings("ignore", category=UserWarning, module="matplotlib")
+                        fig_shap = plt.figure(figsize=(8,6))
+                        shap.summary_plot(shap_values, X_shap_for, show=False)
+                        st.pyplot(fig_shap)
+                    else:
+                        # fallback: use KernelExplainer on small sample (very slow)
+                        explainer = shap.KernelExplainer(model_to_explain.predict, shap.sample(X_train, 100))
+                        shap_values = explainer.shap_values(X_shap_for, nsamples=100)
+                        fig_shap = plt.figure(figsize=(8,6))
+                        shap.summary_plot(shap_values, X_shap_for, show=False)
+                        st.pyplot(fig_shap)
+                    st.success("SHAP summary plotted.")
+                except Exception as e:
+                    st.error(f"SHAP failed: {e}")
+            # per-instance explanation waterfall
+            st.markdown("#### Explain a single prediction (waterfall):")
+            idx_choice = st.number_input("Row index (0..n_test-1)", min_value=0, max_value=X_shap.shape[0]-1, value=0)
+            try:
+                row = X_shap_for.iloc[[idx_choice]]
+                if explain_model_name in ["RandomForest","ExtraTrees","GradientBoosting"]:
+                  expl = shap.TreeExplainer(model_to_explain) 
+                  shap_vals_row = expl.shap_values(row)
+                  exp_val = expl.expected_value
+                  shap_vals = shap_vals_row
+
+                  # Handle tree models returning arrays for single target
+                  if isinstance(exp_val, (list, np.ndarray)) and not np.isscalar(exp_val):
+                      exp_val = exp_val[0]
+                  if isinstance(shap_vals, list):
+                      shap_vals = shap_vals[0]
+
+                  exp_val = expl.expected_value
+                  shap_vals = shap_vals_row
+
+                  # Handle multi-output case
+                  if isinstance(exp_val, (list, np.ndarray)) and not np.isscalar(exp_val):
+                      exp_val = exp_val[0]
+                  if isinstance(shap_vals, list):
+                      shap_vals = shap_vals[0]
+
+                  # Plot safely across SHAP versions
+                  try:
+                      explanation = shap.Explanation(
+                          values=shap_vals[0],
+                          base_values=exp_val,
+                          data=row.iloc[0],
+                          feature_names=row.columns.tolist()
+                      )
+                      plot_obj = shap.plots.waterfall(explanation, show=False)
+
+                      # If SHAP returns Axes instead of Figure, wrap it
+                      import matplotlib.pyplot as plt
+                      if hasattr(plot_obj, "figure"):
+                          fig2 = plot_obj.figure
+                      else:
+                          fig2 = plt.gcf()
+
+                      st.pyplot(fig2)
+                  except Exception as e:
+                      st.warning(f"Waterfall plotting failed gracefully: {e}")
+
+
+                else:
+                    st.info("Per-instance waterfall not available for this model type in fallback.")
+            except Exception as e:
+                st.warning(f"Could not plot waterfall: {e}")
+
+
+# ----- 📌 Target & Business Impact tab
+with tabs[5]:
+    st.subheader("🎯 Recommended Target Variables by Use Case")
+    st.markdown("Each use case maps to a practical target variable that drives measurable business impact.")
+
+    target_table = pd.DataFrame([
+        ["Predictive Maintenance (Mills, Motors, Compressors)", "bearing_temp / time_to_failure", "Rises before mechanical failure; early warning", "₹10–30 L per asset/year"],
+        ["Blast Furnace / EAF Data Intelligence", "furnace_temp / tap_temp", "Central control variable, linked to energy and quality", "₹20–60 L/year"],
+        ["Casting Quality Optimization", "defect_probability / solidification_rate", "Determines billet quality; control nozzle & cooling", "₹50 L/year yield gain"],
+        ["Rolling Mill Energy Optimization", "energy_per_ton / exit_temp", "Directly tied to energy efficiency", "₹5–10 L/year per kWh/t"],
+        ["Surface Defect Detection (Vision AI)", "defect_probability", "Quality metric from CNN", "1–2 % yield gain"],
+        ["Material Composition & Alloy Mix AI", "deviation_from_target_grade", "Predict deviation, suggest corrections", "₹20 L/year raw material savings"],
+        ["Inventory & Yield Optimization", "yield_ratio (output/input)", "Linked to WIP and process yield", "₹1 Cr+/year"],
+        ["Refractory & Cooling Loss Prediction", "lining_thickness / heat_loss_rate", "Predict wear for planned maintenance", "₹40 L/year downtime savings"]], columns=["Use Case", "Target Variable", "Why It’s Ideal", "Business Leverage"])
+
+    st.dataframe(target_table,  use_container_width=True)
+
+    st.markdown("---")
+    st.subheader(" Business Framing for Clients")
+    st.markdown("These metrics show approximate annual benefits from small process improvements.")
+
+    business_table = pd.DataFrame([
+        ["Energy consumption", "400 kWh/ton", "₹35–60 L"],
+        ["Electrode wear", "1.8 kg/ton", "₹10 L"],
+        ["Refractory wear", "3 mm/heat", "₹15 L"],
+        ["Oxygen usage", "40 Nm³/ton", "₹20 L"],
+        ["Yield loss", "2 %", "₹50 L – ₹1 Cr"],
+    ], columns=["Metric", "Typical Value (EAF India)", "5 % Improvement → Annual ₹ Value"])
+
+    st.dataframe(business_table, use_container_width=True)
+    st.info("These numbers are indicative averages; actual benefits depend on plant capacity and process efficiency.")
+
+# ----- 📚 Bibliography tab 
+with tabs[6]:
+    st.subheader("📚 Annotated Bibliography & Feature Justification")
+    st.markdown("""
+This section summarizes published research supporting the feature design and modeling choices.
+    """)
+
+    bib_data = [
+        ("A Survey of Data-Driven Soft Sensing in Ironmaking Systems", "Yan et al. (2024)", "Supports gas proxies, lags, PCA for off-gas and temperature correlation."),
+        ("Optimisation of Oxygen Blowing Process using RL", "Ojeda Roldan et al. (2022)", "Reinforcement learning for oxygen control; motivates surrogate predicted states & safety indices."),
+        ("Analyzing the Energy Efficiency of Electric Arc Furnace", "Zhuo et al. (2024)", "Energy KPIs (kWh/t) motivate power_density & energy_efficiency features."),
+        ("BOF/Endpoint Prediction Techniques", "Springer (2024)", "Endpoint prediction; supports temporal lags and cycle encoding."),
+        ("Dynamic EAF Modeling & Slag Foaming", "MacRosty et al.", "Physics priors for slag_foaming_index and refractory health modeling."),
+    ]
+
+    bib_df = pd.DataFrame(bib_data, columns=["Paper Title", "Authors / Year", "Relevance to Feature Engineering"])
+    st.dataframe(bib_df, use_container_width=True)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+    st.markdown("""
+**Feature-to-Research Mapping Summary:**
+- Gas probes & soft-sensing → `carbon_proxy`, `oxygen_utilization`
+- Power & energy proxies → `power_density`, `energy_efficiency`
+- Temporal features → rolling means, lags, cycle progress indicators
+- Surrogate features → `pred_temp_30s`, `pred_carbon_5min`
+- PCA / clustering → operating mode compression
+""")
+# -------------------------
+# Footer / Notes
+# -------------------------
+st.markdown("---")
+st.markdown("**Notes:** This dataset is synthetic and for demo/prototyping. Real plant integration requires NDA, data on-boarding, sensor mapping, and plant safety checks before any control actions.")