Update app.py

app.py

@@ -6,7 +6,7 @@ import pandas as pd
 import numpy as np
 import joblib
 
-# matplotlib only for preview modal thumbnails
+# matplotlib only for PREVIEW modal (static thumbnails)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
@@ -14,75 +14,63 @@ import matplotlib.pyplot as plt
 import plotly.graph_objects as go
 from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
 
-
 # =========================
 # Defaults / Constants
 # =========================
 FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
 TARGET = "UCS"
-
 MODELS_DIR = Path("models")
 DEFAULT_MODEL = MODELS_DIR / "ucs_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
-# Fixed pixel sizes to keep appearance stable across pages
-CROSS_W, CROSS_H = 390, 390          # cross-plot = square
-TRACK_W, TRACK_H = 220, 700          # slim/tall log-style track
-
+# ——— Exact pixel sizes (match preview strip & square cross-plot) ———
+CROSS_W, CROSS_H = 420, 420            # square cross-plot (px)
+TRACK_W, TRACK_H = 220, 700            # match preview strip look (px)
+FONT_SIZE = 13
 
 # =========================
 # Page / Theme
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
+
+# ---- CSS ----
+st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
 st.markdown(
     """
     <style>
-      header, footer { visibility: hidden !important; }
-      .stApp { background: #FFFFFF; }
-      section[data-testid="stSidebar"] { background: #F6F9FC; }
-      .block-container { padding-top: .5rem; padding-bottom: .5rem; }
-      .stButton>button{
-        background:#007bff; color:#fff; font-weight:bold;
-        border-radius:8px; border:none; padding:10px 24px;
-      }
-      .stButton>button:hover{ background:#0056b3; }
-      .st-hero { display:flex; align-items:center; gap:16px; padding-top: 4px; }
-      .st-hero .brand { width:110px; height:110px; object-fit:contain; }
-      .st-hero h1 { margin:0; line-height:1.05; }
-      .st-hero .tagline { margin:2px 0 0 2px; color:#6b7280; font-size:1.05rem; font-style:italic; }
-      [data-testid="stBlock"]{ margin-top:0 !important; }
-      .help-foot { color:#6b7280; font-size:0.95rem; }
+    .stApp { background: #FFFFFF; }
+    section[data-testid="stSidebar"] { background: #F6F9FC; }
+    .block-container { padding-top: .5rem; padding-bottom: .5rem; }
+    /* primary buttons */
+    .stButton>button{ background:#007bff; color:#fff; font-weight:bold; border-radius:8px; border:none; padding:10px 24px; }
+    .stButton>button:hover{ background:#0056b3; }
+    /* hero */
+    .st-hero { display:flex; align-items:center; gap:16px; padding-top: 4px; }
+    .st-hero .brand { width:110px; height:110px; object-fit:contain; }
+    .st-hero h1 { margin:0; line-height:1.05; }
+    .st-hero .tagline { margin:2px 0 0 2px; color:#6b7280; font-size:1.05rem; font-style:italic; }
+    /* tighter top margin for first block */
+    [data-testid="stBlock"]{ margin-top:0 !important; }
     </style>
     """,
     unsafe_allow_html=True
 )
 
-
 # =========================
-# Small helpers (used by password gate too)
+# Password gate (define first, then call)
 # =========================
 def inline_logo(path="logo.png") -> str:
     try:
         p = Path(path)
-        if not p.exists():
-            return ""
+        if not p.exists(): return ""
         return f"data:image/png;base64,{base64.b64encode(p.read_bytes()).decode('ascii')}"
     except Exception:
         return ""
 
-
-# =========================
-# Password gate (branded)
-# =========================
 def add_password_gate() -> bool:
-    """
-    Ask for a password (APP_PASSWORD in Secrets or Env) before rendering the app.
-    If not configured, block with a clear admin message.
-    """
-    # pull required password
-    required = ""
+    """Branded access screen until correct APP_PASSWORD in Secrets/Env is entered."""
     try:
         required = st.secrets.get("APP_PASSWORD", "")
     except Exception:
@@ -121,26 +109,30 @@ def add_password_gate() -> bool:
           </div>
         </div>
         <div style="font-size:1.25rem;font-weight:700;margin:8px 0 4px 0;">Protected</div>
-        <div style="color:#6b7280;margin-bottom:14px;">Please enter your access key to continue.</div>
+        <div style="color:#6b7280;margin-bottom:14px;">
+          Please enter your access key to continue.
+        </div>
         """,
         unsafe_allow_html=True
     )
+
     pwd = st.text_input("Access key", type="password", placeholder="••••••••")
-    if st.button("Unlock", type="primary"):
-        if pwd == required:
-            st.session_state.auth_ok = True
-            st.rerun()
-        else:
-            st.error("Incorrect key. Please try again.")
-    st.stop()
+    col1, _ = st.columns([1, 3])
+    with col1:
+        if st.button("Unlock", type="primary", use_container_width=True):
+            if pwd == required:
+                st.session_state.auth_ok = True
+                st.rerun()
+            else:
+                st.error("Incorrect key. Please try again.")
 
+    st.stop()
 
-# Call the password gate before anything else is drawn
+# call it now
 add_password_gate()
 
-
 # =========================
-# General helpers
+# Helpers
 # =========================
 try:
     dialog = st.dialog
@@ -177,27 +169,17 @@ def parse_excel(data_bytes: bytes):
 
 def read_book_bytes(data_bytes: bytes):
     if not data_bytes: return {}
-    try:
-        return parse_excel(data_bytes)
+    try: return parse_excel(data_bytes)
     except Exception as e:
-        st.error(f"Failed to read Excel: {e}")
-        return {}
+        st.error(f"Failed to read Excel: {e}"); return {}
 
 def find_sheet(book, names):
     low2orig = {k.lower(): k for k in book.keys()}
     for nm in names:
-        if nm.lower() in low2orig:
-            return low2orig[nm.lower()]
+        if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-
-# ---------- Plot helpers (interactive, fixed size, full outline) ----------
-def _add_full_frame(fig):
-    fig.update_layout(shapes=[dict(
-        type="rect", xref="paper", yref="paper", x0=0, y0=0, x1=1, y1=1,
-        line=dict(color="#444", width=1), fillcolor="rgba(0,0,0,0)"
-    )])
-
+# ---------- Interactive plotting (fixed sizes, full outline, crisp fonts) ----------
 def cross_plot_interactive(actual, pred):
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
@@ -221,30 +203,34 @@ def cross_plot_interactive(actual, pred):
 
     fig.update_layout(
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=50, r=12, t=8, b=40),
-        hovermode="closest", font=dict(size=13),
+        margin=dict(l=64, r=16, t=10, b=48),
+        hovermode="closest", font=dict(size=FONT_SIZE),
         width=CROSS_W, height=CROSS_H
     )
     fig.update_xaxes(
-        title_text="<b>Actual UCS</b>", range=[x0, x1], tickformat=",.0f",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+        title_text="<b>Actual UCS</b>",
+        range=[x0, x1], ticks="outside",
+        showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", tickformat=",.0f",
+        automargin=True
     )
     fig.update_yaxes(
-        title_text="<b>Predicted UCS</b>", range=[x0, x1], tickformat=",.0f",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", scaleanchor="x", scaleratio=1,
-        automargin=True
+        title_text="<b>Predicted UCS</b>",
+        range=[x0, x1], ticks="outside",
+        showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", tickformat=",.0f",
+        scaleanchor="x", scaleratio=1, automargin=True
     )
-    _add_full_frame(fig)
     return fig
 
 def depth_or_index_track_interactive(df, include_actual=True):
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
     if depth_col is not None:
         y = df[depth_col]; y_label = depth_col
+        autorange = "reversed"
     else:
         y = np.arange(1, len(df) + 1); y_label = "Point Index"
+        autorange = "reversed"
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -263,27 +249,28 @@ def depth_or_index_track_interactive(df, include_actual=True):
 
     fig.update_layout(
         paper_bgcolor="#ffffff", plot_bgcolor="#ffffff",
-        margin=dict(l=44, r=6, t=6, b=36),
-        hovermode="closest", font=dict(size=13),
-        legend=dict(x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-                    bgcolor="rgba(255,255,255,0.75)", bordercolor="#cccccc", borderwidth=1),
+        margin=dict(l=72, r=18, t=36, b=48),
+        hovermode="closest", font=dict(size=FONT_SIZE),
+        legend=dict(
+            x=0.98, y=0.05, xanchor="right", yanchor="bottom",
+            bgcolor="rgba(255,255,255,0.75)", bordercolor="#cccccc", borderwidth=1
+        ),
         legend_title_text="",
         width=TRACK_W, height=TRACK_H
     )
     fig.update_xaxes(
-        title_text="<b>UCS</b>", side="top", tickformat=",.0f",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
+        title_text="<b>UCS</b>", side="top",
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
+        showgrid=True, gridcolor="rgba(0,0,0,0.12)", tickformat=",.0f",
+        automargin=True
     )
     fig.update_yaxes(
-        title_text=f"<b>{y_label}</b>", autorange="reversed",
-        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+        title_text=f"<b>{y_label}</b>", autorange=autorange,
+        ticks="outside", showline=True, linewidth=1.2, linecolor="#444", mirror="allticks",
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
-    _add_full_frame(fig)
     return fig
 
-
 # ---------- Preview modal helpers (matplotlib static) ----------
 def make_index_tracks(df: pd.DataFrame, cols: list[str]):
     cols = [c for c in cols if c in df.columns]
@@ -302,6 +289,8 @@ def make_index_tracks(df: pd.DataFrame, cols: list[str]):
         ax.set_xlabel(col)
         ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
         ax.grid(True, linestyle=":", alpha=0.3)
+        # draw full box
+        for spine in ax.spines.values(): spine.set_visible(True)
     axes[0].set_ylabel("Point Index")
     return fig
 
@@ -325,6 +314,7 @@ def preview_modal_dev(book: dict[str, pd.DataFrame], feature_cols: list[str]):
     if not tabs:
         first_name = list(book.keys())[0]
         tabs = [first_name]; data = [book[first_name]]
+    st.write("Use the tabs to switch between Train/Test views (if available).")
     t_objs = st.tabs(tabs)
     for t, df in zip(t_objs, data):
         with t:
@@ -333,21 +323,19 @@ def preview_modal_dev(book: dict[str, pd.DataFrame], feature_cols: list[str]):
             with t2: st.dataframe(stats_table(df, FEATURES), use_container_width=True)
 
 @dialog("Preview data")
-def preview_modal_single(book: dict[str, pd.DataFrame], feature_cols: list[str], names=("Validation","Validate","validation2","Val","val","Prediction","Pred")):
+def preview_modal_val(book: dict[str, pd.DataFrame], feature_cols: list[str]):
     if not book:
         st.info("No data loaded yet."); return
-    vname = find_sheet(book, list(names)) or list(book.keys())[0]
+    vname = find_sheet(book, ["Validation","Validate","validation2","Val","val"]) or list(book.keys())[0]
     df = book[vname]
     t1, t2 = st.tabs(["Tracks", "Summary"])
     with t1: st.pyplot(make_index_tracks(df, feature_cols), use_container_width=True)
     with t2: st.dataframe(stats_table(df, feature_cols), use_container_width=True)
 
-
 # =========================
 # Model presence
 # =========================
 MODEL_URL = _get_model_url()
-
 def ensure_model_present() -> Path:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
         if p.exists() and p.stat().st_size > 0:
@@ -379,16 +367,29 @@ except Exception as e:
     st.error(f"Failed to load model: {model_path}\n{e}")
     st.stop()
 
-# meta overrides / inference
+# Meta override/infer
 meta_path = MODELS_DIR / "meta.json"
 if meta_path.exists():
     try:
         meta = json.loads(meta_path.read_text(encoding="utf-8"))
-        FEATURES = meta.get("features", FEATURES)
-        TARGET = meta.get("target", TARGET)
+        FEATURES = meta.get("features", FEATURES); TARGET = meta.get("target", TARGET)
     except Exception:
         pass
-
+else:
+    def infer_features_from_model(m):
+        try:
+            if hasattr(m, "feature_names_in_") and len(getattr(m, "feature_names_in_")):
+                return [str(x) for x in m.feature_names_in_]
+        except Exception: pass
+        try:
+            if hasattr(m, "steps") and len(m.steps):
+                last = m.steps[-1][1]
+                if hasattr(last, "feature_names_in_") and len(last.feature_names_in_):
+                    return [str(x) for x in last.feature_names_in_]
+        except Exception: pass
+        return None
+    infer = infer_features_from_model(model)
+    if infer: FEATURES = infer
 
 # =========================
 # Session state
@@ -397,7 +398,7 @@ if "app_step" not in st.session_state: st.session_state.app_step = "intro"
 if "results" not in st.session_state: st.session_state.results = {}
 if "train_ranges" not in st.session_state: st.session_state.train_ranges = None
 
-# persist dev file
+# Dev page file state
 for k, v in {
     "dev_ready": False,
     "dev_file_loaded": False,
@@ -411,9 +412,8 @@ for k, v in {
 }.items():
     if k not in st.session_state: st.session_state[k] = v
 
-
 # =========================
-# Hero header
+# Hero
 # =========================
 st.markdown(
     f"""
@@ -428,7 +428,6 @@ st.markdown(
     unsafe_allow_html=True,
 )
 
-
 # =========================
 # INTRO
 # =========================
@@ -437,24 +436,23 @@ if st.session_state.app_step == "intro":
     st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data.")
     st.subheader("Expected Input Features (in Order)")
     st.markdown(
-        "- Q, gpm — Flow rate (gallons per minute)\n"
-        "- SPP(psi) — Stand pipe pressure\n"
-        "- T (kft.lbf) — Torque (thousand foot-pounds)\n"
-        "- WOB (klbf) — Weight on bit\n"
+        "- Q, gpm — Flow rate (gallons per minute)  \n"
+        "- SPP(psi) — Stand pipe pressure  \n"
+        "- T (kft.lbf) — Torque (thousand foot-pounds)  \n"
+        "- WOB (klbf) — Weight on bit  \n"
         "- ROP (ft/h) — Rate of penetration"
     )
     st.subheader("How It Works")
     st.markdown(
         "1. **Upload your data to build the case and preview the performance of our model.**  \n"
         "2. Click **Run Model** to compute metrics and plots.  \n"
-        "3. Click **Proceed to Validation** to validate on a new dataset (with actual UCS, if available).  \n"
-        "4. Click **Proceed to Prediction** to generate predictions only (no actuals).  \n"
+        "3. Click **Proceed to Validation** to evaluate on a new dataset.  \n"
+        "4. Click **Proceed to Prediction** for prediction-only (no actual UCS).  \n"
         "5. Export results to Excel at any time."
     )
-    if st.button("Start Showcase", type="primary"):
+    if st.button("Start Showcase", type="primary", key="start_showcase"):
         st.session_state.app_step = "dev"; st.rerun()
 
-
 # =========================
 # CASE BUILDING (Development)
 # =========================
@@ -463,7 +461,6 @@ if st.session_state.app_step == "dev":
     dev_label = "Upload Data (Excel)" if not st.session_state.dev_file_name else "Replace data (Excel)"
     train_test_file = st.sidebar.file_uploader(dev_label, type=["xlsx","xls"], key="dev_upload")
 
-    # Detect new/changed file and PERSIST BYTES
     if train_test_file is not None:
         try:
             file_bytes = train_test_file.getvalue(); size = len(file_bytes)
@@ -489,16 +486,18 @@ if st.session_state.app_step == "dev":
             f"{st.session_state.dev_file_rows} rows × {st.session_state.dev_file_cols} cols"
         )
 
-    # Sidebar actions (proceed buttons enabled always)
-    if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
+    preview_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded)
+    if preview_btn and st.session_state.dev_file_loaded:
         st.session_state.dev_preview_request = True
+
     run_btn = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+    # Always show navigation buttons (enabled feel)
     if st.sidebar.button("Proceed to Validation ▶", use_container_width=True):
-        st.session_state.app_step = "val"; st.rerun()
+        st.session_state.app_step = "validate"; st.rerun()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step = "pred"; st.rerun()
+        st.session_state.app_step = "predict"; st.rerun()
 
-    # Title + helper
+    # helper bar at top
     st.subheader("Case Building (Development)")
     if st.session_state.dev_ready:
         st.success("Case has been built and results are displayed below.")
@@ -509,25 +508,21 @@ if st.session_state.app_step == "dev":
     else:
         st.write("**Upload your data to build a case, then run the model to review development performance.**")
 
-    # open preview dialog if requested
     if st.session_state.dev_preview_request and st.session_state.dev_file_bytes:
         _book = read_book_bytes(st.session_state.dev_file_bytes)
         st.session_state.dev_previewed = True
         st.session_state.dev_preview_request = False
         preview_modal_dev(_book, FEATURES)
 
-    # Run
     if run_btn and st.session_state.dev_file_bytes:
         with st.status("Processing…", expanded=False) as status:
             book = read_book_bytes(st.session_state.dev_file_bytes)
-            if not book:
-                status.update(label="Failed to read workbook.", state="error"); st.stop()
+            if not book: status.update(label="Failed to read workbook.", state="error"); st.stop()
             status.update(label="Workbook read ✓")
             sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
             sh_test  = find_sheet(book, ["Test","Testing","testing2","test","testing"])
             if sh_train is None or sh_test is None:
                 status.update(label="Workbook must include Train/Training/training2 and Test/Testing/testing2.", state="error"); st.stop()
-
             df_tr = book[sh_train].copy(); df_te = book[sh_test].copy()
             if not (ensure_cols(df_tr, FEATURES + [TARGET]) and ensure_cols(df_te, FEATURES + [TARGET])):
                 status.update(label="Missing required columns.", state="error"); st.stop()
@@ -552,53 +547,49 @@ if st.session_state.app_step == "dev":
             st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
 
             st.session_state.dev_ready = True
-            status.update(label="Done ✓", state="complete")
-            st.rerun()
+            status.update(label="Done ✓", state="complete"); st.rerun()
 
     # Results
     if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
         tab1, tab2 = st.tabs(["Training", "Testing"])
 
-        def _result_block(df, metrics):
+        def dev_block(df, metrics):
             c1,c2,c3 = st.columns(3)
             c1.metric("R²", f"{metrics['R2']:.4f}")
             c2.metric("RMSE", f"{metrics['RMSE']:.4f}")
             c3.metric("MAE", f"{metrics['MAE']:.4f}")
 
-            # center band with two equal columns
-            sp_l, main, sp_r = st.columns([1, 8, 1])
-            with main:
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.plotly_chart(
-                        cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
-                        use_container_width=False,
-                        config={"displayModeBar": False, "scrollZoom": True}
-                    )
-                with col2:
-                    st.plotly_chart(
-                        depth_or_index_track_interactive(df, include_actual=True),
-                        use_container_width=False,
-                        config={"displayModeBar": False, "scrollZoom": True}
-                    )
+            # layout: spacer | crossplot | spacer | track
+            sp_left, col_cross, sp_mid, col_track, sp_right = st.columns([0.2, 0.6, 0.05, 0.35, 0.2])
+            with col_cross:
+                st.plotly_chart(
+                    cross_plot_interactive(df[TARGET], df["UCS_Pred"]),
+                    use_container_width=False,
+                    config={"displayModeBar": False, "scrollZoom": True}
+                )
+            with col_track:
+                st.plotly_chart(
+                    depth_or_index_track_interactive(df, include_actual=True),
+                    use_container_width=False,
+                    config={"displayModeBar": False, "scrollZoom": True}
+                )
 
         if "Train" in st.session_state.results:
             with tab1:
-                _result_block(st.session_state.results["Train"], st.session_state.results["metrics_train"])
+                dev_block(st.session_state.results["Train"], st.session_state.results["metrics_train"])
         if "Test" in st.session_state.results:
             with tab2:
-                _result_block(st.session_state.results["Test"], st.session_state.results["metrics_test"])
+                dev_block(st.session_state.results["Test"], st.session_state.results["metrics_test"])
 
         st.markdown("---")
-        # export
-        sheets = {}
-        rows = []
+        sheets = {}; rows = []
         if "Train" in st.session_state.results:
             sheets["Train_with_pred"] = st.session_state.results["Train"]
             rows.append({"Split":"Train", **{k:round(v,6) for k,v in st.session_state.results["metrics_train"].items()}})
         if "Test" in st.session_state.results:
             sheets["Test_with_pred"] = st.session_state.results["Test"]
             rows.append({"Split":"Test", **{k:round(v,6) for k,v in st.session_state.results["metrics_test"].items()}})
+
         summary_df = pd.DataFrame(rows) if rows else None
         try:
             buf = io.BytesIO()
@@ -616,12 +607,11 @@ if st.session_state.app_step == "dev":
         except Exception as e:
             st.warning(str(e))
 
-
 # =========================
-# VALIDATION (with actuals if present)
+# VALIDATION (with actual UCS)
 # =========================
-if st.session_state.app_step == "val":
-    st.sidebar.header("Validate the model")
+if st.session_state.app_step == "validate":
+    st.sidebar.header("Validate the Model")
     validation_file = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"], key="val_upload")
     if validation_file is not None:
         _book_tmp = read_book_bytes(validation_file.getvalue())
@@ -629,18 +619,19 @@ if st.session_state.app_step == "val":
             first_df = next(iter(_book_tmp.values()))
             st.sidebar.caption(f"**Data loaded:** {validation_file.name} • {first_df.shape[0]} rows × {first_df.shape[1]} cols")
 
-    if st.sidebar.button("Preview data", use_container_width=True, disabled=(validation_file is None)):
+    preview_val_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=(validation_file is None))
+    if preview_val_btn and validation_file is not None:
         _book = read_book_bytes(validation_file.getvalue())
-        preview_modal_single(_book, FEATURES)
+        preview_modal_val(_book, FEATURES)
 
     predict_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
-    if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True):
-        st.session_state.app_step = "pred"; st.rerun()
     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()
 
-    st.subheader("Validation")
-    st.write("Upload a dataset to generate UCS predictions and evaluate performance on unseen data.")
+    st.subheader("Validate the Model")
+    st.write("Upload a dataset containing the same feature columns and **UCS** to evaluate model performance.")
 
     if predict_btn and validation_file is not None:
         with st.status("Predicting…", expanded=False) as status:
@@ -649,8 +640,7 @@ if st.session_state.app_step == "val":
             status.update(label="Workbook read ✓")
             vname = find_sheet(vbook, ["Validation","Validate","validation2","Val","val"]) or list(vbook.keys())[0]
             df_val = vbook[vname].copy()
-            if not ensure_cols(df_val, FEATURES):
-                status.update(label="Missing required columns.", state="error"); st.stop()
+            if not ensure_cols(df_val, FEATURES + [TARGET]): status.update(label="Missing required columns.", state="error"); st.stop()
             status.update(label="Columns validated ✓")
             df_val["UCS_Pred"] = model.predict(df_val[FEATURES])
             st.session_state.results["Validate"] = df_val
@@ -664,13 +654,11 @@ if st.session_state.app_step == "val":
                     offenders["Violations"] = pd.DataFrame(viol).loc[any_viol].apply(lambda r: ", ".join([c for c,v in r.items() if v]), axis=1)
                     offenders.index = offenders.index + 1; oor_table = offenders
 
-            metrics_val = None
-            if TARGET in df_val.columns:
-                metrics_val = {
-                    "R2": r2_score(df_val[TARGET], df_val["UCS_Pred"]),
-                    "RMSE": rmse(df_val[TARGET], df_val["UCS_Pred"]),
-                    "MAE": mean_absolute_error(df_val[TARGET], df_val["UCS_Pred"])
-                }
+            metrics_val = {
+                "R2": r2_score(df_val[TARGET], df_val["UCS_Pred"]),
+                "RMSE": rmse(df_val[TARGET], df_val["UCS_Pred"]),
+                "MAE": mean_absolute_error(df_val[TARGET], df_val["UCS_Pred"])
+            }
             st.session_state.results["metrics_val"] = metrics_val
             st.session_state.results["summary_val"] = {
                 "n_points": len(df_val),
@@ -682,58 +670,50 @@ if st.session_state.app_step == "val":
             status.update(label="Predictions ready ✓", state="complete")
 
     if "Validate" in st.session_state.results:
-        dfv = st.session_state.results["Validate"]
-        sv  = st.session_state.results["summary_val"]
-        oor_table = st.session_state.results.get("oor_table")
-        metrics_val = st.session_state.results.get("metrics_val")
+        metrics_val = st.session_state.results.get("metrics_val", {})
+        c1, c2, c3 = st.columns(3)
+        c1.metric("R²",   f"{metrics_val.get('R2',0):.4f}")
+        c2.metric("RMSE", f"{metrics_val.get('RMSE',0):.4f}")
+        c3.metric("MAE",  f"{metrics_val.get('MAE',0):.4f}")
+
+        left_sp, col_cross, sp_mid, col_track, sp_right = st.columns([0.2, 0.6, 0.05, 0.35, 0.2])
+        with col_cross:
+            st.plotly_chart(
+                cross_plot_interactive(
+                    st.session_state.results["Validate"][TARGET],
+                    st.session_state.results["Validate"]["UCS_Pred"]),
+                use_container_width=False,
+                config={"displayModeBar": False, "scrollZoom": True}
+            )
+        with col_track:
+            st.plotly_chart(
+                depth_or_index_track_interactive(
+                    st.session_state.results["Validate"], include_actual=True),
+                use_container_width=False,
+                config={"displayModeBar": False, "scrollZoom": True}
+            )
 
+        sv = st.session_state.results["summary_val"]; oor_table = st.session_state.results.get("oor_table")
         if sv["oor_pct"] > 0:
             st.warning("Some validation inputs fall outside the **training min–max** ranges. Interpret predictions with caution.")
-
-        if metrics_val is not None:
-            c1, c2, c3 = st.columns(3)
-            c1.metric("R²",   f"{metrics_val['R2']:.4f}")
-            c2.metric("RMSE", f"{metrics_val['RMSE']:.4f}")
-            c3.metric("MAE",  f"{metrics_val['MAE']:.4f}")
-        else:
-            c1, c2, c3 = st.columns(3)
-            c1.metric("# points", f"{sv['n_points']}")
-            c2.metric("Pred min", f"{sv['pred_min']:.2f}")
-            c3.metric("Pred max", f"{sv['pred_max']:.2f}")
-
-        sp_l, main, sp_r = st.columns([1, 8, 1])
-        with main:
-            col1, col2 = st.columns(2)
-            with col1:
-                if TARGET in dfv.columns:
-                    st.plotly_chart(
-                        cross_plot_interactive(dfv[TARGET], dfv["UCS_Pred"]),
-                        use_container_width=False,
-                        config={"displayModeBar": False, "scrollZoom": True}
-                    )
-                else:
-                    st.info("Actual UCS values are not available in the validation data. Cross-plot cannot be generated.")
-            with col2:
-                st.plotly_chart(
-                    depth_or_index_track_interactive(dfv, include_actual=(TARGET in dfv.columns)),
-                    use_container_width=False,
-                    config={"displayModeBar": False, "scrollZoom": True}
-                )
-
         if oor_table is not None:
             st.write("*Out-of-range rows (vs. Training min–max):*")
             st.dataframe(oor_table, use_container_width=True)
 
         st.markdown("---")
-        # export
+        sheets = {"Validate_with_pred": st.session_state.results["Validate"]}
+        rows = []
+        for name, key in [("Train","metrics_train"), ("Test","metrics_test"), ("Validate","metrics_val")]:
+            m = st.session_state.results.get(key)
+            if m: rows.append({"Split": name, **{k: round(v,6) for k,v in m.items()}})
+        summary_df = pd.DataFrame(rows) if rows else None
         try:
             buf = io.BytesIO()
             with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                dfv.to_excel(xw, sheet_name="Validate_with_pred", index=False)
-                if metrics_val is not None:
-                    pd.DataFrame([{"Split":"Validate", **{k: round(v,6) for k,v in metrics_val.items()}}]).to_excel(
-                        xw, sheet_name="Summary", index=False
-                    )
+                for name, frame in sheets.items():
+                    frame.to_excel(xw, sheet_name=name[:31], index=False)
+                if summary_df is not None:
+                    summary_df.to_excel(xw, sheet_name="Summary", index=False)
             st.download_button(
                 "Export Validation Results to Excel",
                 data=buf.getvalue(),
@@ -743,12 +723,11 @@ if st.session_state.app_step == "val":
         except Exception as e:
             st.warning(str(e))
 
-
 # =========================
-# PREDICTION (no actuals)
+# PREDICTION-ONLY (no actual UCS)
 # =========================
-if st.session_state.app_step == "pred":
-    st.sidebar.header("Prediction")
+if st.session_state.app_step == "predict":
+    st.sidebar.header("Prediction (No Actual UCS)")
     pred_file = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"], key="pred_upload")
     if pred_file is not None:
         _book_tmp = read_book_bytes(pred_file.getvalue())
@@ -756,88 +735,75 @@ if st.session_state.app_step == "pred":
             first_df = next(iter(_book_tmp.values()))
             st.sidebar.caption(f"**Data loaded:** {pred_file.name} • {first_df.shape[0]} rows × {first_df.shape[1]} cols")
 
-    if st.sidebar.button("Preview data", use_container_width=True, disabled=(pred_file is None)):
+    preview_pred_btn = st.sidebar.button("Preview data", use_container_width=True, disabled=(pred_file is None))
+    if preview_pred_btn and pred_file is not None:
         _book = read_book_bytes(pred_file.getvalue())
-        preview_modal_single(_book, FEATURES, names=("Prediction","Pred","Sheet1","Data"))
+        preview_modal_val(_book, FEATURES)
 
-    pred_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
-    if st.sidebar.button("⬅ Back to Validation", use_container_width=True):
-        st.session_state.app_step = "val"; st.rerun()
+    do_pred = 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()
 
     st.subheader("Prediction")
-    st.write("Upload a dataset to generate UCS predictions (no actuals required).")
+    st.write("Upload a dataset with the feature columns (no **UCS**). You’ll get predicted UCS, a UCS track, and a compact summary.")
 
-    if pred_btn and pred_file is not None:
+    if do_pred and pred_file is not None:
         with st.status("Predicting…", expanded=False) as status:
             pbook = read_book_bytes(pred_file.getvalue())
-            if not pbook: status.update(label="Could not read the Prediction Excel.", state="error"); st.stop()
+            if not pbook: status.update(label="Could not read the Excel.", state="error"); st.stop()
             status.update(label="Workbook read ✓")
-            pname = find_sheet(pbook, ["Prediction","Pred"]) or list(pbook.keys())[0]
+            pname = list(pbook.keys())[0]
             dfp = pbook[pname].copy()
-            if not ensure_cols(dfp, FEATURES):
-                status.update(label="Missing required columns.", state="error"); st.stop()
+            if not ensure_cols(dfp, FEATURES): status.update(label="Missing required columns.", state="error"); st.stop()
             status.update(label="Columns validated ✓")
             dfp["UCS_Pred"] = model.predict(dfp[FEATURES])
             st.session_state.results["PredictOnly"] = dfp
 
-            ranges = st.session_state.train_ranges
-            oor_pct = None
+            ranges = st.session_state.train_ranges; oor_pct = 0.0
             if ranges:
-                viol = {f: (dfp[f] < ranges[f][0]) | (dfp[f] > ranges[f][1]) for f in FEATURES}
-                any_viol = pd.DataFrame(viol).any(axis=1)
+                any_viol = pd.DataFrame({f: (dfp[f] < ranges[f][0]) | (dfp[f] > ranges[f][1]) for f in FEATURES}).any(axis=1)
                 oor_pct = float(any_viol.mean()*100.0)
 
-            st.session_state.results["summary_pred"] = {
+            st.session_state.results["summary_predonly"] = {
                 "n_points": len(dfp),
                 "pred_min": float(dfp["UCS_Pred"].min()),
                 "pred_max": float(dfp["UCS_Pred"].max()),
                 "pred_mean": float(dfp["UCS_Pred"].mean()),
                 "pred_std": float(dfp["UCS_Pred"].std(ddof=0)),
-                "oor_pct": oor_pct if oor_pct is not None else None
+                "oor_pct": oor_pct,
             }
             status.update(label="Predictions ready ✓", state="complete")
 
     if "PredictOnly" in st.session_state.results:
         dfp = st.session_state.results["PredictOnly"]
-        sp = st.session_state.results["summary_pred"]
-
-        # summary table (left) + track (right)
-        sp_l, main, sp_r = st.columns([1, 8, 1])
-        with main:
-            col1, col2 = st.columns([1, 1])
-            with col1:
-                table = pd.DataFrame({
-                    "Metric": ["# points", "Pred min", "Pred max", "Pred mean", "Pred std", "OOR %"],
-                    "Value": [
-                        sp["n_points"],
-                        f"{sp['pred_min']:.2f}",
-                        f"{sp['pred_max']:.2f}",
-                        f"{sp['pred_mean']:.2f}",
-                        f"{sp['pred_std']:.2f}",
-                        (f"{sp['oor_pct']:.1f}%" if sp["oor_pct"] is not None else "N/A")
-                    ]
-                })
-                st.write("✅ Predictions ready ✓")
-                st.dataframe(table, use_container_width=True)
-                st.markdown(
-                    "<div class='help-foot'>* OOR% = percentage of rows with any input feature outside the "
-                    "training min–max range (computed when Case Building has been run).</div>",
-                    unsafe_allow_html=True
-                )
-            with col2:
-                st.plotly_chart(
-                    depth_or_index_track_interactive(dfp, include_actual=False),
-                    use_container_width=False,
-                    config={"displayModeBar": False, "scrollZoom": True}
-                )
+        sv = st.session_state.results["summary_predonly"]
+
+        # Left summary table (in place of cross-plot), right UCS track
+        left_sp, col_summary, sp_mid, col_track, sp_right = st.columns([0.18, 0.42, 0.05, 0.35, 0.2])
+
+        with col_summary:
+            tbl = pd.DataFrame({
+                "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
+                "Value":  [sv["n_points"], sv["pred_min"], sv["pred_max"], sv["pred_mean"], sv["pred_std"], f'{sv["oor_pct"]:.1f}%']
+            })
+            st.success("Predictions ready ✓")
+            st.dataframe(tbl, use_container_width=True, hide_index=True)
+
+            st.caption("**★ OOR** = percentage of rows whose input features fall outside the training min–max range.")
+
+        with col_track:
+            st.plotly_chart(
+                depth_or_index_track_interactive(dfp, include_actual=False),
+                use_container_width=False,
+                config={"displayModeBar": False, "scrollZoom": True}
+            )
 
         st.markdown("---")
-        # export
         try:
             buf = io.BytesIO()
             with pd.ExcelWriter(buf, engine="openpyxl") as xw:
-                dfp.to_excel(xw, sheet_name="Prediction_with_pred", index=False)
-                pd.DataFrame([sp]).to_excel(xw, sheet_name="Summary", index=False)
+                dfp.to_excel(xw, sheet_name="Predictions", index=False)
+                pd.DataFrame([sv]).to_excel(xw, sheet_name="Summary", index=False)
             st.download_button(
                 "Export Prediction Results to Excel",
                 data=buf.getvalue(),
@@ -847,7 +813,6 @@ if st.session_state.app_step == "pred":
         except Exception as e:
             st.warning(str(e))
 
-
 # =========================
 # Footer
 # =========================