Update app.py

app.py

@@ -1,12 +1,14 @@
-# app_ucs.py — ST_GeoMech_UCS (Unified workflow like Tc) — MAPE instead of MAE
+# ST_TOC — Total Organic Carbon Estimation Using AI
+# Abbrev-only UI + model-order-safe predictions (bypass sklearn feature-name check)
 
 import io, json, os, base64, math
 from pathlib import Path
+from datetime import datetime
+
 import streamlit as st
 import pandas as pd
 import numpy as np
 import joblib
-from datetime import datetime
 
 # Matplotlib (preview + cross-plot)
 import matplotlib
@@ -15,7 +17,7 @@ import matplotlib.pyplot as plt
 from matplotlib.ticker import FuncFormatter
 
 import plotly.graph_objects as go
-from sklearn.metrics import mean_squared_error  # MAE removed
+from sklearn.metrics import mean_squared_error
 
 # =========================
 # Constants / Defaults
@@ -23,16 +25,16 @@ from sklearn.metrics import mean_squared_error  # MAE removed
 APP_NAME = "ST_TOC"
 TAGLINE  = "Total Organic Carbon Estimation Using AI"
 
+# UI feature list (abbreviations only)
 FEATURES = ["AHT90", "DT", "GR", "K", "RHOB", "TNPH", "Th", "Ur"]
 TARGET    = "TOC"
 PRED_COL  = "TOC_Pred"
 
 MODELS_DIR = Path("models")
 DEFAULT_MODEL = MODELS_DIR / "toc_rf.joblib"
-
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
-COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
+COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 STRICT_VERSION_CHECK = False  # optional env banner
 
 # ---- Plot sizing ----
@@ -131,10 +133,6 @@ def pearson_r(y_true, y_pred) -> float:
     return float(np.corrcoef(a, p)[0, 1])
 
 def mape(y_true, y_pred, eps: float = 1e-8) -> float:
-    """
-    Mean Absolute Percentage Error in PERCENT.
-    Ignores rows where |y_true| < eps to avoid division blowups.
-    """
     a = np.asarray(y_true, dtype=float)
     p = np.asarray(y_pred, dtype=float)
     denom = np.where(np.abs(a) < eps, np.nan, np.abs(a))
@@ -155,68 +153,87 @@ def parse_excel(data_bytes: bytes):
 def read_book_bytes(b: bytes):
     return parse_excel(b) if b else {}
 
-# ---- Canonical feature aliasing (accept legacy headers) ----
-def _build_alias_map(canonical_features: list[str], target_name: str) -> dict:
-    # Helper: prefer a canonical name from FEATURES if present
-    def pick(expected, variants):
-        for v in variants:
-            if v in expected:
-                return v
-        return variants[0]  # fall back
-
-    # Canonical abbreviations (what we WANT in the DataFrame)
-    can_AHT  = pick(canonical_features, ["AHT90"])
-    can_DT   = pick(canonical_features, ["DT"])
-    can_GR   = pick(canonical_features, ["GR"])
-    can_K    = pick(canonical_features, ["K"])
-    can_RHOB = pick(canonical_features, ["RHOB"])
-    can_TNPH = pick(canonical_features, ["TNPH"])
-    can_Th   = pick(canonical_features, ["Th"])
-    can_Ur   = pick(canonical_features, ["Ur"])
-
+# ---------- Header normalization (to abbreviations for UI) ----------
+def _strip_parens(name: str) -> str:
+    s = str(name).strip()
+    if "(" in s and s.endswith(")"):
+        s = s.split("(", 1)[0].strip()
+    return s
+
+def _abbr(name: str) -> str:
+    """Turn any variant into the canonical abbreviation used in UI FEATURES."""
+    n = _strip_parens(name)
+    n = n.replace(" ", "").replace("_", "").replace("-", "")
     alias = {
-        # Abbrev ↔ variants (map everything to the abbrev)
-        "AHT90": can_AHT, "AHT_90": can_AHT, "AHT-90": can_AHT,
-        "AHT90 (Average Hydrocarbon Tool 90° Phase)": can_AHT,
-
-        "DT": can_DT, "AC": can_DT, "DT (us/ft)": can_DT,
-        "DT (Delta-T Sonic Travel Time)": can_DT,
-
-        "GR": can_GR, "Gamma Ray": can_GR, "GR (API)": can_GR,
-        "GR (Gamma Ray)": can_GR,
-
-        "K": can_K, "Potassium": can_K, "K (%)": can_K,
-
-        "RHOB": can_RHOB, "Bulk Density": can_RHOB, "RHOB (g/cc)": can_RHOB,
-        "RHOB (Bulk Density)": can_RHOB,
-
-        "TNPH": can_TNPH, "NPHI": can_TNPH, "TNPH (%)": can_TNPH,
-        "TNPH (Thermal Neutron Porosity)": can_TNPH,
-
-        "Th": can_Th, "Thorium": can_Th, "Th (ppm)": can_Th,
-
-        "Ur": can_Ur, "U": can_Ur, "U (ppm)": can_Ur,
-
-        # Optional depth aliases (if you add later)
-        "Depth": "Depth", "Depth (ft)": "Depth", "DEPTH": "Depth", "MD (ft)": "Depth",
-
-        # Target aliases → canonical TARGET
-        "TOC": target_name, "TOC (%)": target_name, "Total Organic Carbon": target_name,
+        "AC": "DT",
+        "DTus/ft": "DT", "DTusft": "DT",
+        "NPHI": "TNPH", "TNPHPercent": "TNPH", "TNPH%": "TNPH",
+        "GammaRay": "GR", "GRAPI": "GR",
+        "BulkDensity": "RHOB", "RHOBgcc": "RHOB",
+        "Thorium": "Th", "TH": "Th",
+        "U": "Ur", "UR": "Ur", "Uranium": "Ur",
+        "KPercent": "K", "K%": "K", "Potassium": "K",
+        "AHT_90": "AHT90", "AHT90AverageHydrocarbonTool90°Phase": "AHT90",
     }
-    return alias
+    # preserve core mnemonics
+    if n.upper() in {"GR", "DT", "RHOB"}: return n.upper() if n.upper() != "DT" else "DT"
+    if n.upper() == "AHT90": return "AHT90"
+    if n.upper() == "TNPH": return "TNPH"
+    if n.capitalize() == "Th": return "Th"
+    if n.capitalize() == "Ur": return "Ur"
+    return alias.get(n, n)
+
+def normalize_to_abbr(df: pd.DataFrame) -> pd.DataFrame:
+    out = df.copy()
+    newcols = []
+    for c in out.columns:
+        ac = _abbr(c)
+        if ac in FEATURES:            # map features to their abbreviations
+            newcols.append(ac)
+        elif str(c).strip().lower() in {"toc", "toc (%)", "totalorganiccarbon"}:
+            newcols.append(TARGET)
+        elif "depth" in str(c).lower():
+            newcols.append("Depth")    # for track plotting only
+        else:
+            newcols.append(str(c))
+    out.columns = newcols
+    return out
 
+# ---- Build X in the model's training order & avoid name check ----
+def _make_X_for_model(df: pd.DataFrame, model, fallback_features: list[str]) -> np.ndarray:
+    """
+    Returns a NumPy array with columns ordered exactly as in model training.
+    Using np.ndarray bypasses sklearn's feature-name validation.
+    """
+    df_abbr = normalize_to_abbr(df)
+    # mapping abbr -> actual column present
+    colmap = { _abbr(c): c for c in df_abbr.columns }
+
+    train_names = list(getattr(model, "feature_names_in_", fallback_features))
+    order_cols = []
+    missing = []
+    for nm in train_names:
+        ab = _abbr(nm)
+        if ab in colmap:
+            order_cols.append(colmap[ab])
+        else:
+            missing.append(nm)
 
-def _normalize_columns(df: pd.DataFrame, canonical_features: list[str], target_name: str) -> pd.DataFrame:
-    out = df.copy()
-    out.columns = [str(c).strip().replace(" ,", ",").replace(",  ", ", ").replace("  ", " ") for c in out.columns]
-    alias = _build_alias_map(canonical_features, target_name)
-    actual = {k: v for k, v in alias.items() if k in out.columns and k != v}
-    return out.rename(columns=actual)
+    if missing:
+        st.markdown('<div class="st-message-box st-error">Missing required columns for prediction (by model training): '
+                    + ", ".join(missing) + '</div>', unsafe_allow_html=True)
+        st.stop()
+
+    X = df_abbr[order_cols].apply(pd.to_numeric, errors="coerce")
+    return X.to_numpy()
 
-def ensure_cols(df: pd.DataFrame, cols: list[str]) -> bool:
-    miss = [c for c in cols if c not in df.columns]
+def ensure_required_features(df: pd.DataFrame, model, fallback_features: list[str]) -> bool:
+    df_abbr = normalize_to_abbr(df)
+    need = [_abbr(nm) for nm in list(getattr(model, "feature_names_in_", fallback_features))]
+    have = {_abbr(c) for c in df_abbr.columns}
+    miss = [n for n in need if n not in have]
     if miss:
-        st.error(f"Missing columns: {miss}\nFound: {list(df.columns)}")
+        st.error(f"Missing columns: {miss}\nFound: {sorted(list(have))}")
         return False
     return True
 
@@ -240,182 +257,6 @@ def df_centered_rounded(df: pd.DataFrame, hide_index=True):
     )
     st.dataframe(styler, use_container_width=True, hide_index=hide_index)
 
-# ---------- Build X exactly as trained ----------
-def _make_X(df: pd.DataFrame, features: list[str]) -> pd.DataFrame:
-    X = df.reindex(columns=features, copy=False)
-    for c in features:
-        X[c] = pd.to_numeric(X[c], errors="coerce")
-    return X
-
-# === Excel export helpers =================================================
-def _excel_engine() -> str:
-    try:
-        import xlsxwriter  # noqa: F401
-        return "xlsxwriter"
-    except Exception:
-        return "openpyxl"
-
-def _excel_safe_name(name: str) -> str:
-    bad = '[]:*?/\\'
-    safe = ''.join('_' if ch in bad else ch for ch in str(name))
-    return safe[:31]
-
-def _round_numeric(df: pd.DataFrame, ndigits: int = 2) -> pd.DataFrame:
-    out = df.copy()
-    for c in out.columns:
-        if pd.api.types.is_float_dtype(out[c]) or pd.api.types.is_integer_dtype(out[c]):
-            out[c] = pd.to_numeric(out[c], errors="coerce").round(ndigits)
-    return out
-
-def _summary_table(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame:
-    cols = [c for c in cols if c in df.columns]
-    if not cols:
-        return pd.DataFrame()
-    tbl = (df[cols]
-            .agg(['min','max','mean','std'])
-            .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
-            .reset_index(names="Field"))
-    return _round_numeric(tbl)
-
-def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
-    if not ranges:
-        return pd.DataFrame()
-    df = pd.DataFrame(ranges).T.reset_index()
-    df.columns = ["Feature", "Min", "Max"]
-    return _round_numeric(df)
-
-def _available_sections() -> list[str]:
-    res = st.session_state.get("results", {})
-    sections = []
-    if "Train" in res:        sections += ["Training","Training_Metrics","Training_Summary"]
-    if "Test" in res:         sections += ["Testing","Testing_Metrics","Testing_Summary"]
-    if "Validate" in res:     sections += ["Validation","Validation_Metrics","Validation_Summary","Validation_OOR"]
-    if "PredictOnly" in res:  sections += ["Prediction","Prediction_Summary"]
-    if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
-    sections += ["Info"]
-    return sections
-
-def build_export_workbook(selected: list[str] | None = None) -> tuple[bytes|None, str|None, list[str]]:
-    res = st.session_state.get("results", {})
-    if not res: return None, None, []
-
-    sheets: dict[str, pd.DataFrame] = {}
-    order: list[str] = []
-
-    # Training
-    if ("Training" in (selected or _available_sections())) and "Train" in res:
-        tr = _round_numeric(res["Train"])
-        sheets["Training"] = tr; order.append("Training")
-        m = res.get("m_train", {})
-        if m:
-            sheets["Training_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Training_Metrics")
-        tr_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in tr.columns]
-        s = _summary_table(tr, tr_cols)
-        if not s.empty:
-            sheets["Training_Summary"] = s; order.append("Training_Summary")
-
-    # Testing
-    if ("Testing" in (selected or _available_sections())) and "Test" in res:
-        te = _round_numeric(res["Test"])
-        sheets["Testing"] = te; order.append("Testing")
-        m = res.get("m_test", {})
-        if m:
-            sheets["Testing_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Testing_Metrics")
-        te_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in te.columns]
-        s = _summary_table(te, te_cols)
-        if not s.empty:
-            sheets["Testing_Summary"] = s; order.append("Testing_Summary")
-
-    # Validation
-    if ("Validation" in (selected or _available_sections())) and "Validate" in res:
-        va = _round_numeric(res["Validate"])
-        sheets["Validation"] = va; order.append("Validation")
-        m = res.get("m_val", {})
-        if m:
-            sheets["Validation_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Validation_Metrics")
-        sv = res.get("sv_val", {})
-        if sv:
-            sheets["Validation_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Validation_Summary")
-        oor_tbl = res.get("oor_tbl")
-        if oor_tbl is not None and isinstance(oor_tbl, pd.DataFrame) and not oor_tbl.empty:
-            sheets["Validation_OOR"] = _round_numeric(oor_tbl.reset_index(drop=True)); order.append("Validation_OOR")
-
-    # Prediction
-    if ("Prediction" in (selected or _available_sections())) and "PredictOnly" in res:
-        pr = _round_numeric(res["PredictOnly"])
-        sheets["Prediction"] = pr; order.append("Prediction")
-        sv = res.get("sv_pred", {})
-        if sv:
-            sheets["Prediction_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Prediction_Summary")
-
-    # Ranges
-    tr_ranges = st.session_state.get("train_ranges")
-    if ("Training_Ranges" in (selected or _available_sections())) and tr_ranges:
-        rr = _train_ranges_df(tr_ranges)
-        if not rr.empty:
-            sheets["Training_Ranges"] = rr; order.append("Training_Ranges")
-
-    # Info
-    info = pd.DataFrame([
-        {"Key": "AppName",    "Value": APP_NAME},
-        {"Key": "Tagline",    "Value": TAGLINE},
-        {"Key": "Target",     "Value": TARGET},
-        {"Key": "PredColumn", "Value": PRED_COL},
-        {"Key": "Features",   "Value": ", ".join(FEATURES)},
-        {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
-    ])
-    sheets["Info"] = info; order.append("Info")
-
-    bio = io.BytesIO()
-    with pd.ExcelWriter(bio, engine=_excel_engine()) as writer:
-        for name in order:
-            df = sheets[name]
-            df.to_excel(writer, sheet_name=_excel_safe_name(name), index=False)
-    bio.seek(0)
-
-    fname = f"TOC_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-    return bio.getvalue(), fname, order
-
-def render_export_button(phase_key: str) -> None:
-    res = st.session_state.get("results", {})
-    if not res: return
-    st.divider()
-    st.markdown("### Export to Excel")
-
-    options = _available_sections()
-    selected_sheets = st.multiselect(
-        "Sheets to include",
-        options=options,
-        default=[],
-        placeholder="Choose option(s)",
-        help="Pick the sheets you want to include in the Excel export.",
-        key=f"sheets_{phase_key}",
-    )
-
-    if not selected_sheets:
-        st.caption("Select one or more sheets above to enable the export.")
-        st.download_button(
-            label="⬇️ Export Excel",
-            data=b"",
-            file_name="TOC_Export.xlsx",
-            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            disabled=True,
-            key=f"download_{phase_key}",
-        )
-        return
-
-    data, fname, names = build_export_workbook(selected=selected_sheets)
-    if names:
-        st.caption("Will include: " + ", ".join(names))
-    st.download_button(
-        "⬇️ Export Excel",
-        data=(data or b""),
-        file_name=(fname or "TOC_Export.xlsx"),
-        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        disabled=(data is None),
-        key=f"download_{phase_key}",
-    )
-
 # =========================
 # Cross plot (Matplotlib)
 # =========================
@@ -439,7 +280,7 @@ def cross_plot_static(actual, pred):
     ax.set_xticks(ticks);  ax.set_yticks(ticks)
     ax.set_aspect("equal", adjustable="box")
 
-    fmt = FuncFormatter(lambda x, _: f"{x:,.0f}")
+    fmt = FuncFormatter(lambda x, _: f"{x:,.1f}")
     ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
 
     ax.set_xlabel("Actual TOC (%)",    fontweight="bold", fontsize=10, color="black")
@@ -457,7 +298,8 @@ def cross_plot_static(actual, pred):
 # Track plot (Plotly)
 # =========================
 def track_plot(df, include_actual=True):
-    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
+    df = normalize_to_abbr(df)
+    depth_col = next((c for c in df.columns if 'depth' in str(c).lower() or c == "Depth"), None)
     if depth_col is not None:
         y = pd.Series(df[depth_col]).astype(float); ylab = depth_col
         y_range = [float(y.max()), float(y.min())]  # reversed
@@ -471,7 +313,7 @@ def track_plot(df, include_actual=True):
     x_lo, x_hi = float(x_series.min()), float(x_series.max())
     x_pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
     xmin, xmax = x_lo - x_pad, x_hi + x_pad
-    tick0 = _nice_tick0(xmin, step=100)
+    tick0 = _nice_tick0(xmin, step=0.5)
 
     fig = go.Figure()
     if PRED_COL in df.columns:
@@ -479,14 +321,14 @@ def track_plot(df, include_actual=True):
             x=df[PRED_COL], y=y, mode="lines",
             line=dict(color=COLORS["pred"], width=1.8),
             name=PRED_COL,
-            hovertemplate=f"{PRED_COL}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
+            hovertemplate=f"{PRED_COL}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
         ))
     if include_actual and TARGET in df.columns:
         fig.add_trace(go.Scatter(
             x=df[TARGET], y=y, mode="lines",
             line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
             name=f"{TARGET} (actual)",
-            hovertemplate=f"{TARGET}: "+"%{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
+            hovertemplate=f"{TARGET}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
@@ -497,13 +339,13 @@ def track_plot(df, include_actual=True):
         legend=dict(x=0.98, y=0.05, xanchor="right", yanchor="bottom",
                     bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1),
         legend_title_text=""
-    )  
+    )
     fig.update_xaxes(
         title_text="TOC (%)",
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=12, family=BOLD_FONT, color="#000"),
         side="top", range=[xmin, xmax],
-        ticks="outside", tickformat=",.0f", tickmode="auto", tick0=tick0,
+        ticks="outside", tickformat=",.2f", tickmode="auto", tick0=tick0,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
@@ -517,13 +359,9 @@ def track_plot(df, include_actual=True):
     )
     return fig
 
-# ---------- Preview (Matplotlib) ----------
+# ---------- Preview tracks (Matplotlib) ----------
 def preview_tracks(df: pd.DataFrame, cols: list[str]):
-    """
-    Multi-track quick-look:
-      - distinct color per input (stable tab20 palette)
-      - shared Y & reversed (Depth down if available)
-    """
+    df = normalize_to_abbr(df)
     cols = [c for c in cols if c in df.columns]
     n = len(cols)
     if n == 0:
@@ -531,8 +369,7 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
         ax.text(0.5, 0.5, "No selected columns", ha="center", va="center"); ax.axis("off")
         return fig
 
-    # Depth or fallback
-    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
+    depth_col = next((c for c in df.columns if 'depth' in str(c).lower() or c == "Depth"), None)
     if depth_col is not None:
         idx = pd.to_numeric(df[depth_col], errors="coerce")
         y_label = depth_col
@@ -550,8 +387,9 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
     for i, (ax, col) in enumerate(zip(axes, cols)):
         x = pd.to_numeric(df[col], errors="coerce")
         ax.plot(x, idx, '-', lw=1.8, color=col_colors[col])
-        ax.set_xlabel(col); ax.xaxis.set_label_position('top'); ax.xaxis.tick_top()
-        ax.set_ylim(y_max, y_min)  # reversed
+        ax.set_xlabel(col)          # abbreviations only
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top()
+        ax.set_ylim(y_max, y_min)   # reversed
         ax.grid(True, linestyle=":", alpha=0.3)
         if i == 0:
             ax.set_ylabel(y_label)
@@ -591,7 +429,7 @@ except Exception as e:
     st.error(f"Failed to load model: {e}")
     st.stop()
 
-# Prefer toc-specific meta
+# Optional meta to override defaults
 meta = {}
 meta_candidates = [MODELS_DIR / "toc_meta.json", MODELS_DIR / "meta.json"]
 meta_path = next((p for p in meta_candidates if p.exists()), None)
@@ -604,7 +442,6 @@ if meta_path:
     except Exception as e:
         st.warning(f"Could not parse meta file ({meta_path.name}): {e}")
 
-# Optional: version banner
 if STRICT_VERSION_CHECK and meta.get("versions"):
     import numpy as _np, sklearn as _skl
     mv = meta["versions"]; msg=[]
@@ -711,15 +548,17 @@ if st.session_state.app_step == "dev":
             st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets.</div>', unsafe_allow_html=True)
             st.stop()
 
-        tr = _normalize_columns(book[sh_train].copy(), FEATURES, TARGET)
-        te = _normalize_columns(book[sh_test].copy(),  FEATURES, TARGET)
+        tr_raw = book[sh_train].copy()
+        te_raw = book[sh_test].copy()
 
-        if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])):
-            st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True)
+        if not (ensure_required_features(tr_raw, model, FEATURES) and ensure_required_features(te_raw, model, FEATURES)):
             st.stop()
 
-        tr[PRED_COL] = model.predict(_make_X(tr, FEATURES))
-        te[PRED_COL] = model.predict(_make_X(te, FEATURES))
+        tr = normalize_to_abbr(tr_raw)
+        te = normalize_to_abbr(te_raw)
+
+        tr[PRED_COL] = model.predict(_make_X_for_model(tr_raw, model, FEATURES))
+        te[PRED_COL] = model.predict(_make_X_for_model(te_raw, model, FEATURES))
 
         st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
         st.session_state.results["m_train"]={
@@ -761,10 +600,137 @@ if st.session_state.app_step == "dev":
             with tab1: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
         if "Test" in st.session_state.results:
             with tab2: _dev_block(st.session_state.results["Test"], st.session_state.results["m_test"])
-        render_export_button(phase_key="dev")
+        st.divider()
+        st.markdown("### Export to Excel")
+
+        # Export builder
+        def _excel_engine() -> str:
+            try:
+                import xlsxwriter  # noqa: F401
+                return "xlsxwriter"
+            except Exception:
+                return "openpyxl"
+
+        def _excel_safe_name(name: str) -> str:
+            bad = '[]:*?/\\'
+            safe = ''.join('_' if ch in bad else ch for ch in str(name))
+            return safe[:31]
+
+        def _round_numeric(df: pd.DataFrame, ndigits: int = 2) -> pd.DataFrame:
+            out = df.copy()
+            for c in out.columns:
+                if pd.api.types.is_float_dtype(out[c]) or pd.api.types.is_integer_dtype(out[c]):
+                    out[c] = pd.to_numeric(out[c], errors="coerce").round(ndigits)
+            return out
+
+        def _summary_table(df: pd.DataFrame, cols: list[str]) -> pd.DataFrame:
+            cols = [c for c in cols if c in df.columns]
+            if not cols:
+                return pd.DataFrame()
+            tbl = (df[cols]
+                    .agg(['min','max','mean','std'])
+                    .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
+                    .reset_index(names="Field"))
+            return _round_numeric(tbl)
+
+        def _train_ranges_df(ranges: dict[str, tuple[float, float]]) -> pd.DataFrame:
+            if not ranges:
+                return pd.DataFrame()
+            df = pd.DataFrame(ranges).T.reset_index()
+            df.columns = ["Feature", "Min", "Max"]
+            return _round_numeric(df)
+
+        def _available_sections() -> list[str]:
+            res = st.session_state.get("results", {})
+            sections = []
+            if "Train" in res:        sections += ["Training","Training_Metrics","Training_Summary"]
+            if "Test" in res:         sections += ["Testing","Testing_Metrics","Testing_Summary"]
+            if "Validate" in res:     sections += ["Validation","Validation_Metrics","Validation_Summary","Validation_OOR"]
+            if "PredictOnly" in res:  sections += ["Prediction","Prediction_Summary"]
+            if st.session_state.get("train_ranges"): sections += ["Training_Ranges"]
+            sections += ["Info"]
+            return sections
+
+        def build_export_workbook(selected: list[str] | None = None) -> tuple[bytes|None, str|None, list[str]]:
+            res = st.session_state.get("results", {})
+            if not res: return None, None, []
+            sheets: dict[str, pd.DataFrame] = {}
+            order: list[str] = []
+
+            if ("Training" in (selected or _available_sections())) and "Train" in res:
+                tr = _round_numeric(res["Train"]); sheets["Training"] = tr; order.append("Training")
+                m = st.session_state.get("results", {}).get("m_train", {})
+                if m: sheets["Training_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Training_Metrics")
+                s = _summary_table(tr, FEATURES + [c for c in [TARGET, PRED_COL] if c in tr.columns])
+                if not s.empty: sheets["Training_Summary"] = s; order.append("Training_Summary")
+
+            if ("Testing" in (selected or _available_sections())) and "Test" in res:
+                te = _round_numeric(res["Test"]); sheets["Testing"] = te; order.append("Testing")
+                m = st.session_state.get("results", {}).get("m_test", {})
+                if m: sheets["Testing_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Testing_Metrics")
+                s = _summary_table(te, FEATURES + [c for c in [TARGET, PRED_COL] if c in te.columns])
+                if not s.empty: sheets["Testing_Summary"] = s; order.append("Testing_Summary")
+
+            if ("Validation" in (selected or _available_sections())) and "Validate" in res:
+                va = _round_numeric(res["Validate"]); sheets["Validation"] = va; order.append("Validation")
+                m = st.session_state.get("results", {}).get("m_val", {})
+                if m: sheets["Validation_Metrics"] = _round_numeric(pd.DataFrame([m])); order.append("Validation_Metrics")
+                sv = st.session_state.get("results", {}).get("sv_val", {})
+                if sv: sheets["Validation_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Validation_Summary")
+                oor_tbl = st.session_state.get("results", {}).get("oor_tbl")
+                if isinstance(oor_tbl, pd.DataFrame) and not oor_tbl.empty:
+                    sheets["Validation_OOR"] = _round_numeric(oor_tbl.reset_index(drop=True)); order.append("Validation_OOR")
+
+            if ("Prediction" in (selected or _available_sections())) and "PredictOnly" in res:
+                pr = _round_numeric(res["PredictOnly"]); sheets["Prediction"] = pr; order.append("Prediction")
+                sv = st.session_state.get("results", {}).get("sv_pred", {})
+                if sv: sheets["Prediction_Summary"] = _round_numeric(pd.DataFrame([sv])); order.append("Prediction_Summary")
+
+            tr_ranges = st.session_state.get("train_ranges")
+            if ("Training_Ranges" in (selected or _available_sections())) and tr_ranges:
+                rr = _train_ranges_df(tr_ranges)
+                if not rr.empty: sheets["Training_Ranges"] = rr; order.append("Training_Ranges")
+
+            info = pd.DataFrame([
+                {"Key": "AppName",    "Value": APP_NAME},
+                {"Key": "Tagline",    "Value": TAGLINE},
+                {"Key": "Target",     "Value": TARGET},
+                {"Key": "PredColumn", "Value": PRED_COL},
+                {"Key": "Features",   "Value": ", ".join(FEATURES)},
+                {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+            ])
+            sheets["Info"] = info; order.append("Info")
+
+            bio = io.BytesIO()
+            with pd.ExcelWriter(bio, engine=_excel_engine()) as writer:
+                for name in order:
+                    sheets[name].to_excel(writer, sheet_name=_excel_safe_name(name), index=False)
+            bio.seek(0)
+            fname = f"TOC_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+            return bio.getvalue(), fname, order
+
+        options = _available_sections()
+        selected_sheets = st.multiselect(
+            "Sheets to include",
+            options=options, default=[],
+            placeholder="Choose option(s)",
+            help="Pick the sheets you want to include in the Excel export.",
+            key="sheets_dev",
+        )
+        if not selected_sheets:
+            st.caption("Select one or more sheets above to enable the export.")
+            st.download_button("⬇️ Export Excel", data=b"", file_name="TOC_Export.xlsx",
+                               mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                               disabled=True, key="download_dev_disabled")
+        else:
+            data, fname, names = build_export_workbook(selected=selected_sheets)
+            if names: st.caption("Will include: " + ", ".join(names))
+            st.download_button("⬇️ Export Excel", data=(data or b""), file_name=(fname or "TOC_Export.xlsx"),
+                               mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                               disabled=(data is None), key="download_dev")
 
 # =========================
-# VALIDATION (with actual UCS)
+# VALIDATION (with actual TOC)
 # =========================
 if st.session_state.app_step == "validate":
     st.sidebar.header("Validate the Model")
@@ -780,26 +746,29 @@ if st.session_state.app_step == "validate":
     if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
-    sticky_header("Validate the Model", "Upload a dataset with the same **features** and **UCS** to evaluate performance.")
+    sticky_header("Validate the Model", "Upload a dataset with the same **features** and **TOC** to evaluate performance.")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue())
         name = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
-        df = _normalize_columns(book[name].copy(), FEATURES, TARGET)
-        if not ensure_cols(df, FEATURES+[TARGET]):
-            st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
-        df[PRED_COL] = model.predict(_make_X(df, FEATURES))
+        df_raw = book[name].copy()
+
+        if not ensure_required_features(df_raw, model, FEATURES):
+            st.stop()
+
+        df = normalize_to_abbr(df_raw)
+        df[PRED_COL] = model.predict(_make_X_for_model(df_raw, model, FEATURES))
         st.session_state.results["Validate"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
         if ranges:
-            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES if f in df.columns}).any(axis=1)
             oor_pct = float(any_viol.mean()*100.0)
             if any_viol.any():
-                tbl = df.loc[any_viol, FEATURES].copy()
-                for c in FEATURES:
+                tbl = df.loc[any_viol, [c for c in FEATURES if c in df.columns]].copy()
+                for c in [c for c in FEATURES if c in tbl.columns]:
                     if pd.api.types.is_numeric_dtype(tbl[c]): tbl[c] = tbl[c].round(2)
-                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(
+                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES if f in df.columns}).loc[any_viol].apply(
                     lambda r:", ".join([c for c,v in r.items() if v]), axis=1
                 )
         st.session_state.results["m_val"]={
@@ -833,7 +802,40 @@ if st.session_state.app_step == "validate":
                                         st.session_state.results["Validate"][PRED_COL]),
                       use_container_width=False)
 
-        render_export_button(phase_key="validate")
+        st.divider()
+        st.markdown("### Export to Excel")
+        # Reuse export from dev by enabling chosen sections
+        def _available_sections_val():
+            res = st.session_state.get("results", {})
+            sections = ["Validation","Validation_Metrics","Validation_Summary"]
+            if isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
+                sections += ["Validation_OOR"]
+            sections += ["Info"]
+            return sections
+        # Minimal export for validation
+        def _export_val():
+            res = st.session_state.get("results", {})
+            sheets = {}
+            sheets["Validation"] = res["Validate"]
+            sheets["Validation_Metrics"] = pd.DataFrame([res.get("m_val", {})])
+            if "sv_val" in res: sheets["Validation_Summary"] = pd.DataFrame([res["sv_val"]])
+            if isinstance(res.get("oor_tbl"), pd.DataFrame) and not res["oor_tbl"].empty:
+                sheets["Validation_OOR"] = res["oor_tbl"].reset_index(drop=True)
+            sheets["Info"] = pd.DataFrame([
+                {"Key":"AppName","Value":APP_NAME},
+                {"Key":"Target","Value":TARGET},
+                {"Key":"PredColumn","Value":PRED_COL},
+                {"Key":"ExportedAt","Value":datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+            ])
+            bio = io.BytesIO()
+            with pd.ExcelWriter(bio, engine="xlsxwriter") as writer:
+                for k,v in sheets.items():
+                    v.to_excel(writer, sheet_name=k[:31], index=False)
+            bio.seek(0)
+            return bio.getvalue(), f"TOC_Validation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+        data_x, fn_x = _export_val()
+        st.download_button("⬇️ Export Excel", data=data_x, file_name=fn_x,
+                           mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
 
         sv = st.session_state.results["sv_val"]
         if sv["oor"] > 0: st.markdown('<div class="st-message-box st-warning">Some inputs fall outside **training min–max** ranges.</div>', unsafe_allow_html=True)
@@ -842,10 +844,10 @@ if st.session_state.app_step == "validate":
             df_centered_rounded(st.session_state.results["oor_tbl"])
 
 # =========================
-# PREDICTION (no actual UCS)
+# PREDICTION (no actual TOC)
 # =========================
 if st.session_state.app_step == "predict":
-    st.sidebar.header("Prediction (No Actual UCS)")
+    st.sidebar.header("Prediction (No Actual TOC)")
     up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"])
     if up is not None:
         book = read_book_bytes(up.getvalue())
@@ -857,19 +859,22 @@ if st.session_state.app_step == "predict":
     go_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
     if st.sidebar.button("⬅ Back to Case Building", use_container_width=True): st.session_state.app_step="dev"; st.rerun()
 
-    sticky_header("Prediction", "Upload a dataset with the feature columns (no **UCS**).")
+    sticky_header("Prediction", "Upload a dataset with the feature columns (no **TOC**).")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
-        df = _normalize_columns(book[name].copy(), FEATURES, TARGET)
-        if not ensure_cols(df, FEATURES):
-            st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
-        df[PRED_COL] = model.predict(_make_X(df, FEATURES))
+        df_raw = book[name].copy()
+
+        if not ensure_required_features(df_raw, model, FEATURES):
+            st.stop()
+
+        df = normalize_to_abbr(df_raw)
+        df[PRED_COL] = model.predict(_make_X_for_model(df_raw, model, FEATURES))
         st.session_state.results["PredictOnly"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0
         if ranges:
-            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).any(axis=1)
+            any_viol = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES if f in df.columns}).any(axis=1)
             oor_pct = float(any_viol.mean()*100.0)
         st.session_state.results["sv_pred"]={
             "n":len(df),
@@ -897,7 +902,26 @@ if st.session_state.app_step == "predict":
             st.plotly_chart(track_plot(df, include_actual=False),
                             use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
 
-        render_export_button(phase_key="predict")
+        st.divider()
+        # Simple export
+        def _export_pred():
+            res = st.session_state.get("results", {})
+            sheets = {"Prediction": res["PredictOnly"], "Prediction_Summary": pd.DataFrame([sv])}
+            sheets["Info"] = pd.DataFrame([
+                {"Key":"AppName","Value":APP_NAME},
+                {"Key":"Target","Value":TARGET},
+                {"Key":"PredColumn","Value":PRED_COL},
+                {"Key":"ExportedAt","Value":datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
+            ])
+            bio = io.BytesIO()
+            with pd.ExcelWriter(bio, engine="xlsxwriter") as writer:
+                for k,v in sheets.items():
+                    v.to_excel(writer, sheet_name=k[:31], index=False)
+            bio.seek(0)
+            return bio.getvalue(), f"TOC_Prediction_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+        data_x, fn_x = _export_pred()
+        st.download_button("⬇️ Export Excel", data=data_x, file_name=fn_x,
+                           mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
 
 # =========================
 # Preview modal
@@ -917,7 +941,7 @@ if st.session_state.show_preview_modal:
             tabs = st.tabs(names)
             for t, name in zip(tabs, names):
                 with t:
-                    df = _normalize_columns(book_to_preview[name], FEATURES, TARGET)
+                    df = normalize_to_abbr(book_to_preview[name])
                     t1, t2 = st.tabs(["Tracks", "Summary"])
                     with t1:
                         st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)