Update app.py

app.py

@@ -1,17 +1,16 @@
-# app.py — ST_Min_Horizontal_Stress (σhmin)
-# Self-contained Streamlit app that TRAINS a fixed, optimized ML pipeline in-app.
-# No external model files, no model-source UI. Upload Excel and go.
+# app_FP.py — ST_GeoMech_FP (Fracture Pressure)
+# Mirrors the SHmin app's specs & workflow (password gate, top preview panel, UI/metrics/exports).
+# Self-contained: trains a fixed, optimized RF pipeline in-app. No external model files.
 
-import io, json, os, base64, math
+import io, 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  # only used to cache pipeline inside session
 
-# Matplotlib for static previews & cross-plot
+# Matplotlib (static previews & cross-plot)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -26,18 +25,28 @@ from sklearn.impute import SimpleImputer
 # =========================
 # App constants / defaults
 # =========================
-APP_NAME = "ST_GeoMech_Shmin"
-TAGLINE  = "Real-Time Minimum Horizontal Stress Prediction"
-
-# -------- Canonical names (match your files) --------
-FEATURES   = ["Q (gpm)", "SPP (psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
-TARGET     = "MINStress_Actual"
-PRED_COL   = "MINStress_Pred"
-ACTUAL_COL = TARGET
-TRANSFORM  = "none"     # "none" | "log10" | "ln"
-UNITS      = "Psi"
-
-# ---- Fixed ("best") model params baked into the code ----
+APP_NAME = "ST_GeoMech_FP"
+TAGLINE  = "Real-Time Fracture Pressure Prediction"
+
+# Canonical feature names (match SHmin app)
+FEATURES = ["Q (gpm)", "SPP (psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
+
+# Canonical prediction/target labels (we'll auto-resolve target via aliases)
+TARGET_CANON = "FracPress_Actual"
+PRED_COL     = "FracPress_Pred"
+UNITS        = "Psi"
+
+# Target aliases (we'll accept any of these if present in sheets)
+TARGET_ALIASES = [
+    "FracPress_Actual", "FracturePressure_Actual", "Fracture Pressure (psi)",
+    "Frac Pressure (psi)", "FracPressure", "Frac_Pressure", "FracturePressure",
+    "FP_Actual", "FP (psi)"
+]
+
+# Model transform (kept for parity with SHmin; unused for RF by default)
+TRANSFORM = "none"  # "none" | "log10" | "ln"
+
+# Fixed "best" RF params (robust & fast; you can tweak if you have tuned FP params)
 BEST_PARAMS = dict(
     n_estimators=400,
     max_depth=None,
@@ -56,8 +65,6 @@ TRACK_H, TRACK_W = 1000, 500
 FONT_SZ = 13
 BOLD_FONT = "Arial Black, Arial, sans-serif"
 
-STRICT_VERSION_CHECK = False  # we now train in this env, so no version pin warnings
-
 # =========================
 # Page / CSS
 # =========================
@@ -87,13 +94,14 @@ TABLE_CENTER_CSS = [
 ]
 
 # =========================
-# Password gate (optional)
+# Password gate (same as SHmin)
 # =========================
 def inline_logo(path="logo.png") -> str:
     try:
         p = Path(path)
         if not p.exists(): return ""
-        return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
+        import base64 as _b64
+        return f"data:image/png;base64,{_b64.b64encode(p.read_bytes()).decode('ascii')}"
     except Exception:
         return ""
 
@@ -102,13 +110,10 @@ def add_password_gate() -> None:
         required = st.secrets.get("APP_PASSWORD", "")
     except Exception:
         required = os.environ.get("APP_PASSWORD", "")
-
     if not required:
-        return  # no password configured
-
+        return
     if st.session_state.get("auth_ok", False):
         return
-
     st.sidebar.markdown(f"""
         <div class="centered-container">
             <img src="{inline_logo('logo.png')}" class="brand-logo">
@@ -209,6 +214,14 @@ def _make_X(df: pd.DataFrame, features: list[str]) -> pd.DataFrame:
         X[c] = pd.to_numeric(X[c], errors="coerce")
     return X
 
+# ---------- Target resolver ----------
+def _resolve_target_col(df: pd.DataFrame) -> str | None:
+    cols_lower = {c.lower(): c for c in df.columns}
+    for cand in TARGET_ALIASES:
+        if cand.lower() in cols_lower:
+            return cols_lower[cand.lower()]
+    return None
+
 # =========================
 # Export helpers
 # =========================
@@ -263,13 +276,13 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
     if "Training" in selected and "Train" in res: _add("Training", res["Train"])
     if "Training_Metrics" in selected and res.get("m_train"): _add("Training_Metrics", pd.DataFrame([res["m_train"]]))
     if "Training_Summary" in selected and "Train" in res:
-        tr_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Train"].columns]
+        tr_cols = FEATURES + [c for c in [PRED_COL, st.session_state.get("tcol_train", TARGET_CANON)] if c in res["Train"].columns]
         _add("Training_Summary", _summary_table(res["Train"], tr_cols))
 
     if "Testing" in selected and "Test" in res: _add("Testing", res["Test"])
     if "Testing_Metrics" in selected and res.get("m_test"): _add("Testing_Metrics", pd.DataFrame([res["m_test"]]))
     if "Testing_Summary" in selected and "Test" in res:
-        te_cols = FEATURES + [c for c in [TARGET, PRED_COL] if c in res["Test"].columns]
+        te_cols = FEATURES + [c for c in [PRED_COL, st.session_state.get("tcol_test", TARGET_CANON)] if c in res["Test"].columns]
         _add("Testing_Summary", _summary_table(res["Test"], te_cols))
 
     if "Validation" in selected and "Validate" in res: _add("Validation", res["Validate"])
@@ -288,7 +301,7 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
         info = pd.DataFrame([
             {"Key": "AppName",    "Value": APP_NAME},
             {"Key": "Tagline",    "Value": TAGLINE},
-            {"Key": "Target",     "Value": TARGET},
+            {"Key": "Target",     "Value": st.session_state.get("tcol_train", TARGET_CANON)},
             {"Key": "PredColumn", "Value": PRED_COL},
             {"Key": "Features",   "Value": ", ".join(FEATURES)},
             {"Key": "ExportedAt", "Value": datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
@@ -305,7 +318,7 @@ def build_export_workbook(selected: list[str], ndigits: int = 3, do_autofit: boo
             df.to_excel(writer, sheet_name=sheet, index=False)
             if do_autofit: _excel_autofit(writer, sheet, df)
     bio.seek(0)
-    fname = f"MinStress_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+    fname = f"FracPressure_Export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
     return bio.getvalue(), fname, order
 
 def render_export_button(phase_key: str) -> None:
@@ -316,28 +329,27 @@ def render_export_button(phase_key: str) -> None:
     options = _available_sections()
     selected_sheets = st.multiselect(
         "Sheets to include",
-        options=options,
-        default=[],
+        options=options, default=[],
         placeholder="Choose option(s)",
         help="Pick the sheets you want in the Excel export.",
         key=f"sheets_{phase_key}",
     )
     if not selected_sheets:
         st.caption("Select one or more sheets above to enable export.")
-        st.download_button("⬇️ Export Excel", data=b"", file_name="MinStress_Export.xlsx",
+        st.download_button("⬇️ Export Excel", data=b"", file_name="FracPressure_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, ndigits=3, do_autofit=True)
     if names: st.caption("Will include: " + ", ".join(names))
-    st.download_button("⬇️ Export Excel", data=(data or b""), file_name=(fname or "MinStress_Export.xlsx"),
+    st.download_button("⬇️ Export Excel", data=(data or b""), file_name=(fname or "FracPressure_Export.xlsx"),
                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                        disabled=(data is None), key=f"download_{phase_key}")
 
 # =========================
-# Plots
+# Plots (integer x ticks)
 # =========================
-def cross_plot_static(actual, pred):
+def cross_plot_static(actual, pred, label="Fracture Pressure"):
     a = pd.Series(actual, dtype=float)
     p = pd.Series(pred,   dtype=float)
     lo = float(min(a.min(), p.min())); hi = float(max(a.max(), p.max()))
@@ -354,11 +366,11 @@ 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}")  # no decimals on cross-plot
+    fmt = FuncFormatter(lambda x, _: f"{x:.0f}")
     ax.xaxis.set_major_formatter(fmt); ax.yaxis.set_major_formatter(fmt)
 
-    ax.set_xlabel(f"Actual Min Stress ({UNITS})",  fontweight="bold", fontsize=10, color="black")
-    ax.set_ylabel(f"Predicted Min Stress ({UNITS})", fontweight="bold", fontsize=10, color="black")
+    ax.set_xlabel(f"Actual {label} ({UNITS})",  fontweight="bold", fontsize=10, color="black")
+    ax.set_ylabel(f"Predicted {label} ({UNITS})", fontweight="bold", fontsize=10, color="black")
     ax.tick_params(labelsize=6, colors="black")
     ax.grid(True, linestyle=":", alpha=0.3)
     for spine in ax.spines.values():
@@ -367,8 +379,8 @@ def cross_plot_static(actual, pred):
     fig.subplots_adjust(left=0.16, bottom=0.16, right=0.98, top=0.98)
     return fig
 
-def track_plot(df, include_actual=True):
-    depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
+def track_plot(df: pd.DataFrame, actual_col: str | None, include_actual=True):
+    depth_col = next((c for c in df.columns if 'depth' in str(c).lower() or 'tvd' in str(c).lower()), None)
     if depth_col is not None:
         y = pd.to_numeric(df[depth_col], errors="coerce"); ylab = depth_col
         y_range = [float(np.nanmax(y)), float(np.nanmin(y))]  # reversed
@@ -377,9 +389,9 @@ def track_plot(df, include_actual=True):
         y_range = [float(y.max()), float(y.min())]
 
     x_series = pd.Series(df.get(PRED_COL, pd.Series(dtype=float))).astype(float)
-    act_col = ACTUAL_COL if (ACTUAL_COL and ACTUAL_COL in df.columns) else TARGET
-    if include_actual and act_col in df.columns:
-        x_series = pd.concat([x_series, pd.Series(df[act_col]).astype(float)], ignore_index=True)
+    if include_actual and actual_col and actual_col in df.columns:
+        x_series = pd.concat([x_series, pd.Series(df[actual_col]).astype(float)], ignore_index=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
@@ -391,14 +403,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:.2f}<br>"+ylab+": %{y}<extra></extra>"
+            hovertemplate=f"{PRED_COL}: "+ "%{x:.0f}<br>" + ylab + ": %{y}<extra></extra>"
         ))
-    if include_actual and act_col in df.columns:
+    if include_actual and actual_col and actual_col in df.columns:
         fig.add_trace(go.Scatter(
-            x=df[act_col], y=y, mode="lines",
+            x=df[actual_col], y=y, mode="lines",
             line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
-            name=f"{act_col} (actual)",
-            hovertemplate=f"{act_col}: "+"%{x:.2f}<br>"+ylab+": %{y}<extra></extra>"
+            name=f"{actual_col} (actual)",
+            hovertemplate=f"{actual_col}: "+ "%{x:.0f}<br>" + ylab + ": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
@@ -411,13 +423,11 @@ def track_plot(df, include_actual=True):
         legend_title_text=""
     )
     fig.update_xaxes(
-        title_text=f"Min Stress ({UNITS})",
+        title_text=f"Fracture Pressure ({UNITS})",
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
         side="top", range=[xmin, xmax],
-        ticks="outside",
-        tickformat=",.0f",      # <— no decimals on ticks
-        tickmode="auto", tick0=tick0,
+        ticks="outside", tickformat=",.0f", tickmode="auto", tick0=tick0,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
@@ -440,7 +450,7 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
         ax.axis("off")
         return fig
 
-    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 'tvd' in str(c).lower()), None)
     if depth_col is not None:
         idx = pd.to_numeric(df[depth_col], errors="coerce")
         y_label = depth_col
@@ -475,12 +485,6 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
 # Fixed training pipeline
 # =========================
 def build_pipeline() -> Pipeline:
-    """
-    Fixed, optimized pipeline:
-      - Numeric imputation (median)
-      - RandomForestRegressor with tuned params (BEST_PARAMS)
-    Trees don't need scaling; robust to feature distributions.
-    """
     model = RandomForestRegressor(**BEST_PARAMS)
     pipe = Pipeline(steps=[
         ("imputer", SimpleImputer(strategy="median")),
@@ -489,7 +493,7 @@ def build_pipeline() -> Pipeline:
     return pipe
 
 # =========================
-# Session state
+# Session state (mirrors SHmin)
 # =========================
 st.session_state.setdefault("app_step", "intro")
 st.session_state.setdefault("results", {})
@@ -497,12 +501,11 @@ st.session_state.setdefault("train_ranges", None)
 st.session_state.setdefault("dev_file_name","")
 st.session_state.setdefault("dev_file_bytes",b"")
 st.session_state.setdefault("dev_file_loaded",False)
-st.session_state.setdefault("dev_preview",False)
-st.session_state.setdefault("fitted_model", None)      # cache trained pipeline
+st.session_state.setdefault("fitted_model", None)
 
-# NEW: persistent top-of-page preview panel state
+# Persistent top-of-page preview panel
 st.session_state.setdefault("show_preview_panel", False)
-st.session_state.setdefault("preview_book", {})        # parsed Excel sheets to preview
+st.session_state.setdefault("preview_book", {})
 
 # =========================
 # Sidebar branding
@@ -532,12 +535,10 @@ def sticky_header(title, message):
         unsafe_allow_html=True
     )
 
-# ---------- Top-of-page Preview Panel ----------
 def render_preview_panel():
-    """If enabled, draws a preview panel at the very top of the page."""
+    """Top-of-page preview panel (same behavior as SHmin)."""
     if not st.session_state.get("show_preview_panel"):
         return
-
     st.markdown("## 🔎 Data preview")
     book = st.session_state.get("preview_book", {}) or {}
     if not book:
@@ -581,7 +582,7 @@ def render_preview_panel():
 # =========================
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
-    st.markdown(f"This software is developed by *Smart Thinking AI-Solutions Team* to estimate **Minimum Horizontal Stress** ({UNITS}) from drilling/offset data.")
+    st.markdown(f"This software is developed by *Smart Thinking AI-Solutions Team* to estimate **Fracture Pressure** ({UNITS}) from drilling/offset data.")
     st.subheader("How It Works")
     st.markdown(
         "1) **Upload your data file** and click **Run Model** to fit the baked-in pipeline.  \n"
@@ -607,8 +608,11 @@ if st.session_state.app_step == "dev":
         st.session_state.dev_file_bytes = up.getvalue()
         st.session_state.dev_file_name = up.name
         st.session_state.dev_file_loaded = True
-        st.session_state.dev_preview = False
-        st.session_state.fitted_model = None  # reset
+        st.session_state.fitted_model = None
+        # show preview panel
+        st.session_state.preview_book = read_book_bytes(st.session_state.dev_file_bytes) if st.session_state.dev_file_bytes else {}
+        st.session_state.show_preview_panel = True
+        st.rerun()
 
     if st.session_state.dev_file_loaded:
         tmp = read_book_bytes(st.session_state.dev_file_bytes)
@@ -616,12 +620,6 @@ if st.session_state.app_step == "dev":
             df0 = next(iter(tmp.values()))
             st.sidebar.caption(f"**Data loaded:** {st.session_state.dev_file_name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
 
-    # PREVIEW button -> show preview panel at top
-    if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
-        st.session_state.preview_book = read_book_bytes(st.session_state.dev_file_bytes) if st.session_state.dev_file_bytes else {}
-        st.session_state.show_preview_panel = True
-        st.rerun()
-
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
     if st.sidebar.button("Proceed to Validation ▶", use_container_width=True): st.session_state.app_step="validate"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
@@ -633,7 +631,6 @@ if st.session_state.app_step == "dev":
     else:
         sticky_header("Case Building", "**Upload your data to build a case, then run the model to review performance.**")
 
-    # Render the preview panel at the very top (above results)
     render_preview_panel()
 
     if run and st.session_state.dev_file_bytes:
@@ -647,22 +644,27 @@ if st.session_state.app_step == "dev":
         tr0 = book[sh_train].copy()
         te0 = book[sh_test].copy()
 
-        # Ensure columns exist
-        if not (ensure_cols(tr0, FEATURES+[TARGET]) and ensure_cols(te0, FEATURES+[TARGET])):
-            st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True)
+        # Resolve target name per-sheet
+        tcol_tr = _resolve_target_col(tr0)
+        tcol_te = _resolve_target_col(te0)
+        if tcol_tr is None or tcol_te is None:
+            st.error(f"Missing target column. Expected one of: {TARGET_ALIASES}")
+            st.stop()
+
+        # Ensure features exist
+        if not (ensure_cols(tr0, FEATURES) and ensure_cols(te0, FEATURES)):
+            st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True)
             st.stop()
 
         # Prepare X,y
         X_tr = _make_X(tr0, FEATURES)
-        y_tr = pd.to_numeric(tr0[TARGET], errors="coerce")
+        y_tr = pd.to_numeric(tr0[tcol_tr], errors="coerce")
         X_te = _make_X(te0, FEATURES)
-        y_te = pd.to_numeric(te0[TARGET], errors="coerce")
+        y_te = pd.to_numeric(te0[tcol_te], errors="coerce")
 
         # Drop rows with NA in y
-        mask_tr = np.isfinite(y_tr)
-        X_tr, y_tr = X_tr.loc[mask_tr], y_tr.loc[mask_tr]
-        mask_te = np.isfinite(y_te)
-        X_te, y_te = X_te.loc[mask_te], y_te.loc[mask_te]
+        mask_tr = np.isfinite(y_tr); X_tr, y_tr = X_tr.loc[mask_tr], y_tr.loc[mask_tr]
+        mask_te = np.isfinite(y_te); X_te, y_te = X_te.loc[mask_te], y_te.loc[mask_te]
 
         pipe = build_pipeline()
         pipe.fit(X_tr, y_tr)
@@ -673,24 +675,31 @@ if st.session_state.app_step == "dev":
         tr[PRED_COL] = _inv_transform(pipe.predict(_make_X(tr0, FEATURES)), TRANSFORM)
         te[PRED_COL] = _inv_transform(pipe.predict(_make_X(te0, FEATURES)), TRANSFORM)
 
+        # Save results & metrics
         st.session_state.results["Train"] = tr
         st.session_state.results["Test"]  = te
         st.session_state.results["m_train"] = {
-            "R":    pearson_r(tr[TARGET], tr[PRED_COL]),
-            "RMSE": rmse(tr[TARGET], tr[PRED_COL]),
-            "MAPE%": mape(tr[TARGET], tr[PRED_COL]),
+            "R":    pearson_r(tr[tcol_tr], tr[PRED_COL]),
+            "RMSE": rmse(tr[tcol_tr], tr[PRED_COL]),
+            "MAPE%": mape(tr[tcol_tr], tr[PRED_COL]),
         }
         st.session_state.results["m_test"] = {
-            "R":    pearson_r(te[TARGET], te[PRED_COL]),
-            "RMSE": rmse(te[TARGET], te[PRED_COL]),
-            "MAPE%": mape(te[TARGET], te[PRED_COL]),
+            "R":    pearson_r(te[tcol_te], te[PRED_COL]),
+            "RMSE": rmse(te[tcol_te], te[PRED_COL]),
+            "MAPE%": mape(te[tcol_te], te[PRED_COL]),
         }
 
+        # Persist which target names we used (for export/plots)
+        st.session_state["tcol_train"] = tcol_tr
+        st.session_state["tcol_test"]  = tcol_te
+
+        # Training min–max ranges
         tr_min = tr[FEATURES].min().to_dict(); tr_max = tr[FEATURES].max().to_dict()
         st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
+
         st.markdown('<div class="st-message-box st-success">Case has been built and results are displayed below.</div>', unsafe_allow_html=True)
 
-    def _dev_block(df, m):
+    def _dev_block(df: pd.DataFrame, actual_col: str, m: dict):
         c1,c2,c3 = st.columns(3)
         c1.metric("R",     f"{m['R']:.3f}")
         c2.metric("RMSE",  f"{m['RMSE']:.2f}")
@@ -704,17 +713,17 @@ if st.session_state.app_step == "dev":
         """, unsafe_allow_html=True)
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
-            st.plotly_chart(track_plot(df, include_actual=True),
+            st.plotly_chart(track_plot(df, actual_col, include_actual=True),
                             use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
         with col_cross:
-            st.pyplot(cross_plot_static(df[TARGET], df[PRED_COL]), use_container_width=False)
+            st.pyplot(cross_plot_static(df[actual_col], df[PRED_COL], label="Fracture Pressure"), use_container_width=False)
 
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
-        if "Train" in st.session_state.results: 
-            with tab1: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
+        if "Train" in st.session_state.results:
+            with tab1: _dev_block(st.session_state.results["Train"], st.session_state.get("tcol_train", TARGET_CANON), 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"])
+            with tab2: _dev_block(st.session_state.results["Test"],  st.session_state.get("tcol_test", TARGET_CANON),  st.session_state.results["m_test"])
         render_export_button(phase_key="dev")
 
 # =========================
@@ -729,7 +738,7 @@ if st.session_state.app_step == "validate":
             df0 = next(iter(book.values()))
             st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
 
-    # PREVIEW button -> show preview panel at top
+    # preview panel on top
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
         st.session_state.preview_book = read_book_bytes(up.getvalue()) if up is not None else {}
         st.session_state.show_preview_panel = True
@@ -739,26 +748,30 @@ 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 **MINStress_Actual** to evaluate performance.")
-    render_preview_panel()  # top-of-page preview
+    sticky_header("Validate the Model", "Upload a dataset with the same **features** and an **actual fracture pressure** column.")
+    render_preview_panel()
 
     if go_btn and up is not None:
         if st.session_state.fitted_model is None:
-            st.error("Please train the model first in Case Building.")
-            st.stop()
+            st.error("Please train the model first in Case Building."); st.stop()
 
         book = read_book_bytes(up.getvalue())
         names = list(book.keys())
         name = next((s for s in names if s.lower() in ("validation","validate","validation2","val","val2")), names[0])
         df0 = book[name].copy()
 
-        if not ensure_cols(df0, FEATURES+[TARGET]):
-            st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
+        tcol = _resolve_target_col(df0)
+        if tcol is None:
+            st.error(f"Missing target column. Expected one of: {TARGET_ALIASES}")
+            st.stop()
+        if not ensure_cols(df0, FEATURES):
+            st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True); st.stop()
 
         df = df0.copy()
         df[PRED_COL] = _inv_transform(st.session_state.fitted_model.predict(_make_X(df0, FEATURES)), TRANSFORM)
         st.session_state.results["Validate"] = df
 
+        # Range checks
         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)
@@ -772,15 +785,16 @@ if st.session_state.app_step == "validate":
                 )
 
         st.session_state.results["m_val"] = {
-            "R":     pearson_r(df[TARGET], df[PRED_COL]),
-            "RMSE":  rmse(df[TARGET], df[PRED_COL]),
-            "MAPE%": mape(df[TARGET], df[PRED_COL]),
+            "R":     pearson_r(df[tcol], df[PRED_COL]),
+            "RMSE":  rmse(df[tcol], df[PRED_COL]),
+            "MAPE%": mape(df[tcol], df[PRED_COL]),
         }
         st.session_state.results["sv_val"] = {"n":len(df), "pred_min":float(df[PRED_COL].min()), "pred_max":float(df[PRED_COL].max()), "oor":oor_pct}
         st.session_state.results["oor_tbl"] = tbl
+        st.session_state["tcol_val"] = tcol
 
     if "Validate" in st.session_state.results:
-        m = st.session_state.results["m_val"]
+        m = st.session_state.results["m_val"]; tcol = st.session_state.get("tcol_val", TARGET_CANON)
         c1,c2,c3 = st.columns(3)
         c1.metric("R", f"{m['R']:.3f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAPE%", f"{m['MAPE%']:.2f}")
         st.markdown("""
@@ -793,11 +807,12 @@ if st.session_state.app_step == "validate":
 
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
-            st.plotly_chart(track_plot(st.session_state.results["Validate"], include_actual=True),
+            st.plotly_chart(track_plot(st.session_state.results["Validate"], tcol, include_actual=True),
                             use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
         with col_cross:
-            st.pyplot(cross_plot_static(st.session_state.results["Validate"][TARGET],
-                                        st.session_state.results["Validate"][PRED_COL]),
+            st.pyplot(cross_plot_static(st.session_state.results["Validate"][tcol],
+                                        st.session_state.results["Validate"][PRED_COL],
+                                        label="Fracture Pressure"),
                       use_container_width=False)
 
         render_export_button(phase_key="validate")
@@ -820,7 +835,7 @@ if st.session_state.app_step == "predict":
             df0 = next(iter(book.values()))
             st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
 
-    # PREVIEW button -> show preview panel at top
+    # preview panel on top
     if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
         st.session_state.preview_book = read_book_bytes(up.getvalue()) if up is not None else {}
         st.session_state.show_preview_panel = True
@@ -830,17 +845,17 @@ if st.session_state.app_step == "predict":
     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 5 feature columns (no actual column).")
-    render_preview_panel()  # top-of-page preview
+    render_preview_panel()
 
     if go_btn and up is not None:
         if st.session_state.fitted_model is None:
-            st.error("Please train the model first in Case Building.")
-            st.stop()
+            st.error("Please train the model first in Case Building."); st.stop()
 
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
         df0 = book[name].copy()
         if not ensure_cols(df0, FEATURES):
             st.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
+
         df = df0.copy()
         df[PRED_COL] = _inv_transform(st.session_state.fitted_model.predict(_make_X(df0, FEATURES)), TRANSFORM)
         st.session_state.results["PredictOnly"] = df
@@ -871,7 +886,7 @@ if st.session_state.app_step == "predict":
             df_centered_rounded(table, hide_index=True)
             st.caption("**★ OOR** = % of rows with input features outside the training min–max range.")
         with col_right:
-            st.plotly_chart(track_plot(df, include_actual=False),
+            st.plotly_chart(track_plot(df, actual_col=None, include_actual=False),
                             use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
         render_export_button(phase_key="predict")
 
@@ -882,7 +897,6 @@ st.markdown("""
 <br><br><br>
 <hr>
 <div style='text-align:center;color:#6b7280;font-size:1.0em;'>
-    © 2025 Smart Thinking AI-Solutions Team. All rights reserved.<br>
-    Website: <a href="https://smartthinking.com.sa" target="_blank" rel="noopener noreferrer">smartthinking.com.sa</a>
+    © 2025 Smart Thinking AI-Solutions Team. All rights reserved.
 </div>
 """, unsafe_allow_html=True)