Update app.py

app.py

@@ -12,10 +12,11 @@ matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
 import plotly.graph_objects as go
-from sklearn.metrics import mean_squared_error, mean_absolute_error
+from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
+from scipy.stats import pearsonr
 
 # =========================
-# Constants
+# Constants (simple & robust)
 # =========================
 FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
 TARGET = "UCS"
@@ -25,62 +26,40 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
 # ---- Plot sizing controls (edit here) ----
-CROSS_W = 420; CROSS_H = 420      # square cross-plot (original look)
+CROSS_W = 500; CROSS_H = 500      # square cross-plot (Build + Validate)
 TRACK_W = 400; TRACK_H = 950      # log-strip style (all pages)
-FONT_SZ  = 13
-PLOT_COLS = [14, 0.5, 10]         # 3-column band: left • spacer • right
-CROSS_NUDGE = 0.5                 # inner columns [CROSS_NUDGE : 1] → bigger = more right
+FONT_SZ = 13
+PLOT_COLS = [14, 0.5, 10]          # 3-column band: left • spacer • right (Build + Validate)
+CROSS_NUDGE = 0.5                  # push cross-plot to the RIGHT inside its band:
+                                   # inner columns [CROSS_NUDGE : 1] → bigger = more right
 
 # =========================
 # Page / CSS
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
 st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
-
 st.markdown(
     """
     <style>
       .stApp { background:#fff; }
       section[data-testid="stSidebar"] { background:#F6F9FC; }
       .block-container { padding-top:.5rem; padding-bottom:.5rem; }
-
-      /* Buttons look */
       .stButton>button { background:#007bff; color:#fff; font-weight:600; border-radius:8px; border:none; }
       .stButton>button:hover { background:#0056b3; }
-
-      /* Brand header */
-      .st-hero { display:flex; align-items:center; gap:16px; padding-top:4px; }
+      .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; }
-
-      /* Remove drag & drop + limit lines — keep Browse button */
-      [data-testid="stFileUploadDropzone"] p,
-      [data-testid="stFileUploadDropzone"] [data-testid="stFileUploaderInstructions"],
-      [data-testid="stFileUploadDropzone"] [data-testid="stCaptionContainer"]{
-        display:none !important;
-      }
-
-      /* Pinned title/helper area */
-      .pinned-top{
-        position:sticky; top:0; z-index:999; background:#fff; padding-top:4px;
-      }
-
-      /* Center every table cell we render via HTML */
-      .table-center table { margin-left:auto; margin-right:auto; border-collapse:collapse; }
-      .table-center table th, .table-center table td {
-        text-align:center !important; padding:6px 10px; border:1px solid #e5e7eb;
-      }
-      .table-center table thead th { background:#f8fafc; }
+      /* Center align text in table cells */
+      .st-emotion-cache-1wq06yv { text-align: center; }
     </style>
     """,
     unsafe_allow_html=True
 )
 
 # =========================
-# Password gate
+# Password gate (define first, then call)
 # =========================
 def inline_logo(path="logo.png") -> str:
     try:
@@ -147,15 +126,21 @@ add_password_gate()
 # =========================
 # Utilities
 # =========================
-def rmse(y_true, y_pred) -> float:
-    return float(np.sqrt(mean_squared_error(y_true, y_pred)))
+try:
+    dialog = st.dialog
+except AttributeError:
+    def dialog(title):
+        def deco(fn):
+            def wrapper(*args, **kwargs):
+                with st.expander(title, expanded=True):
+                    return fn(*args, **kwargs)
+            return wrapper
+        return deco
+
+def rmse(y_true, y_pred): return float(np.sqrt(mean_squared_error(y_true, y_pred)))
 
-def corrcoef_safe(y_true, y_pred) -> float:
-    a = pd.Series(y_true, dtype=float)
-    b = pd.Series(y_pred, dtype=float)
-    m = np.isfinite(a) & np.isfinite(b)
-    if not m.any(): return float("nan")
-    return float(np.corrcoef(a[m], b[m])[0, 1])
+def correlation_coefficient(y_true, y_pred):
+    return pearsonr(y_true, y_pred)[0]
 
 @st.cache_resource(show_spinner=False)
 def load_model(model_path: str):
@@ -182,36 +167,25 @@ def find_sheet(book, names):
         if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-def _nice_step(lo: float, hi: float, target_ticks: int = 6) -> float:
-    rng = max(hi - lo, 1.0)
-    raw = rng / max(target_ticks, 1)
-    mag = 10 ** math.floor(math.log10(raw))
-    for m in [1, 2, 2.5, 5, 10]:
-        step = m * mag
-        if raw <= step:
-            return step
-    return mag * 10
-
-def _nice_tick0(xmin: float, step: float) -> float:
-    if not np.isfinite(xmin): return xmin
+def _nice_tick0(xmin: float, step: int = 100) -> float:
+    """Round xmin down to a sensible multiple so the first tick sits at the left edge."""
+    if not np.isfinite(xmin):
+        return xmin
     return step * math.floor(xmin / step)
 
-def html_table_center(df: pd.DataFrame, index: bool = False):
-    html = df.to_html(index=index, classes="table-center")
-    st.markdown(html, unsafe_allow_html=True)
-
 # ---------- Plot builders ----------
 def cross_plot(actual, pred):
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
-
-    # Symmetric / identical axis range & ticks
     lo = float(np.nanmin([a.min(), p.min()]))
     hi = float(np.nanmax([a.max(), p.max()]))
     pad = 0.03 * (hi - lo if hi > lo else 1.0)
-    lo -= pad; hi += pad
-    step = _nice_step(lo, hi, target_ticks=6)
-    tick0 = _nice_tick0(lo, step)
+    x0, x1 = lo - pad, hi + pad
+    
+    # Get the global min and max of all data points for consistent scaling
+    all_values = pd.concat([a, p]).dropna()
+    global_min = all_values.min()
+    global_max = all_values.max()
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -220,27 +194,25 @@ def cross_plot(actual, pred):
         hovertemplate="Actual: %{x:.0f}<br>Pred: %{y:.0f}<extra></extra>",
         showlegend=False
     ))
-    # 45° reference
     fig.add_trace(go.Scatter(
-        x=[lo, hi], y=[lo, hi], mode="lines",
+        x=[global_min, global_max], y=[global_min, global_max], mode="lines",
         line=dict(color=COLORS["ref"], width=1.2, dash="dash"),
         hoverinfo="skip", showlegend=False
     ))
-
     fig.update_layout(
         width=CROSS_W, height=CROSS_H, paper_bgcolor="#fff", plot_bgcolor="#fff",
         margin=dict(l=64, r=18, t=10, b=48), hovermode="closest",
         font=dict(size=FONT_SZ)
     )
-    axis_common = dict(
-        range=[lo, hi], ticks="outside", tickformat=",.0f",
-        tick0=tick0, dtick=step,
-        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
-    )
-    fig.update_xaxes(title_text="<b>Actual UCS (psi)</b>", **axis_common)
-    fig.update_yaxes(title_text="<b>Predicted UCS (psi)</b>", **axis_common,
-                     scaleanchor="x", scaleratio=1)
+    fig.update_xaxes(title_text="<b>Actual UCS (psi)</b>", range=[global_min, global_max],
+                     ticks="outside", tickformat=",.0f",
+                     showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+                     showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True)
+    fig.update_yaxes(title_text="<b>Predicted UCS (psi)</b>", range=[global_min, global_max],
+                     ticks="outside", tickformat=",.0f",
+                     showline=True, linewidth=1.2, linecolor="#444", mirror=True,
+                     showgrid=True, gridcolor="rgba(0,0,0,0.12)",
+                     scaleanchor="x", scaleratio=1, automargin=True)
     return fig
 
 def track_plot(df, include_actual=True):
@@ -249,21 +221,21 @@ def track_plot(df, include_actual=True):
         y = pd.Series(df[depth_col]).astype(float)
         ylab = depth_col
         y_min, y_max = float(y.min()), float(y.max())
-        y_range = [y_max, y_min]
+        y_range = [y_max, y_min]   # reversed for log profile style
     else:
         y = pd.Series(np.arange(1, len(df) + 1))
         ylab = "Point Index"
         y_min, y_max = float(y.min()), float(y.max())
         y_range = [y_max, y_min]
 
+    # X (UCS) range & ticks
     x_series = pd.Series(df.get("UCS_Pred", pd.Series(dtype=float))).astype(float)
     if include_actual and TARGET in df.columns:
         x_series = pd.concat([x_series, pd.Series(df[TARGET]).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
-    x_step = _nice_step(xmin, xmax, target_ticks=6)
-    tick0 = _nice_tick0(xmin, x_step)
+    tick0 = _nice_tick0(xmin, step=100)  # sensible first tick at left border
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -293,7 +265,7 @@ def track_plot(df, include_actual=True):
     fig.update_xaxes(
         title_text="<b>UCS (psi)</b>", side="top", range=[xmin, xmax],
         ticks="outside", tickformat=",.0f",
-        tickmode="linear", tick0=tick0, dtick=x_step,
+        tickmode="auto", tick0=tick0,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
@@ -312,7 +284,8 @@ def preview_tracks(df: pd.DataFrame, cols: list[str]):
     if n == 0:
         fig, ax = plt.subplots(figsize=(4, 2))
         ax.text(0.5,0.5,"No selected columns",ha="center",va="center")
-        ax.axis("off"); return fig
+        ax.axis("off")
+        return fig
     fig, axes = plt.subplots(1, n, figsize=(2.2*n, 7.0), sharey=True, dpi=100)
     if n == 1: axes = [axes]
     idx = np.arange(1, len(df) + 1)
@@ -347,13 +320,11 @@ def preview_modal(book: dict[str, pd.DataFrame]):
             t1, t2 = st.tabs(["Tracks", "Summary"])
             with t1: st.pyplot(preview_tracks(df, FEATURES), use_container_width=True)
             with t2:
-                tbl = df[FEATURES].agg(['min','max','mean','std']).T.rename(
-                    columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}
-                ).reset_index(names="Feature")
-                html_table_center(tbl, index=False)
+                tbl = df[FEATURES].agg(['min','max','mean','std']).T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"})
+                st.dataframe(tbl.reset_index(names="Feature"), use_container_width=True)
 
 # =========================
-# Load model
+# Load model (simple)
 # =========================
 def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
@@ -425,7 +396,7 @@ 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("How It Works")
     st.markdown(
-        "1) **Upload your data to build the case and preview the performance of our model.**  \n"
+        "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) **Proceed to Validation** (with actual UCS) or **Proceed to Prediction** (no UCS)."
     )
@@ -449,29 +420,26 @@ 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")
 
-    # ---- Pinned title/helper FIRST (so it never appears below preview) ----
-    st.markdown('<div class="pinned-top">', unsafe_allow_html=True)
-    st.subheader("Case Building")
-    if st.session_state.dev_file_loaded and st.session_state.dev_preview:
-        st.info("Previewed ✓ — now click **Run Model**.")
-    elif st.session_state.dev_file_loaded:
-        st.info("📄 **Preview uploaded data** using the sidebar button, then click **Run Model**.")
-    else:
-        st.write("**Upload your data to build a case, then run the model to review development performance.**")
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    # Preview button ALWAYS enabled
-    if st.sidebar.button("Preview data", use_container_width=True):
-        if not st.session_state.dev_file_loaded:
-            st.warning("Upload an Excel file first, then preview.")
-        else:
-            preview_modal(read_book_bytes(st.session_state.dev_file_bytes))
-            st.session_state.dev_preview = True
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=not st.session_state.dev_file_loaded):
+        preview_modal(read_book_bytes(st.session_state.dev_file_bytes))
+        st.session_state.dev_preview = True
 
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+    # always available nav
     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()
 
+    # ---- Pinned helper at the very top of the page ----
+    helper_top = st.container()
+    with helper_top:
+        st.subheader("Case Building")
+        if st.session_state.dev_file_loaded and st.session_state.dev_preview:
+            st.info("Previewed ✓ — now click **Run Model**.")
+        elif st.session_state.dev_file_loaded:
+            st.info("📄 **Preview uploaded data** using the sidebar button, then click **Run Model**.")
+        else:
+            st.write("**Upload your data to build a case, then run the model to review development performance.**")
+
     if run and st.session_state.dev_file_bytes:
         book = read_book_bytes(st.session_state.dev_file_bytes)
         sh_train = find_sheet(book, ["Train","Training","training2","train","training"])
@@ -481,21 +449,12 @@ if st.session_state.app_step == "dev":
         tr = book[sh_train].copy(); te = book[sh_test].copy()
         if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])):
             st.error("Missing required columns."); st.stop()
-
         tr["UCS_Pred"] = model.predict(tr[FEATURES])
         te["UCS_Pred"] = model.predict(te[FEATURES])
 
         st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
-        st.session_state.results["m_train"]={
-            "R": corrcoef_safe(tr[TARGET], tr["UCS_Pred"]),
-            "RMSE": rmse(tr[TARGET], tr["UCS_Pred"]),
-            "MAE": mean_absolute_error(tr[TARGET], tr["UCS_Pred"])
-        }
-        st.session_state.results["m_test"] ={
-            "R": corrcoef_safe(te[TARGET], te["UCS_Pred"]),
-            "RMSE": rmse(te[TARGET], te["UCS_Pred"]),
-            "MAE": mean_absolute_error(te[TARGET], te["UCS_Pred"])
-        }
+        st.session_state.results["m_train"]={"R":correlation_coefficient(tr[TARGET],tr["UCS_Pred"]), "RMSE":rmse(tr[TARGET],tr["UCS_Pred"]), "MAE":mean_absolute_error(tr[TARGET],tr["UCS_Pred"])}
+        st.session_state.results["m_test"] ={"R":correlation_coefficient(te[TARGET],te["UCS_Pred"]), "RMSE":rmse(te[TARGET],te["UCS_Pred"]), "MAE":mean_absolute_error(te[TARGET],te["UCS_Pred"])}
 
         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}
@@ -506,13 +465,19 @@ if st.session_state.app_step == "dev":
         c1.metric("R", f"{m['R']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
         left, spacer, right = st.columns(PLOT_COLS)
         with left:
-            pad, plotcol = left.columns([CROSS_NUDGE, 1])
+            pad, plotcol = left.columns([CROSS_NUDGE, 1])  # shift cross-plot right inside its band
             with plotcol:
-                st.plotly_chart(cross_plot(df[TARGET], df["UCS_Pred"]),
-                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+                st.plotly_chart(
+                    cross_plot(df[TARGET], df["UCS_Pred"]),
+                    use_container_width=False,
+                    config={"displayModeBar": False, "scrollZoom": True}
+                )
         with right:
-            st.plotly_chart(track_plot(df, include_actual=True),
-                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+            st.plotly_chart(
+                track_plot(df, include_actual=True),
+                use_container_width=False,
+                config={"displayModeBar": False, "scrollZoom": True}
+            )
 
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
@@ -532,22 +497,15 @@ if st.session_state.app_step == "validate":
         if book:
             df0 = next(iter(book.values()))
             st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
-
-    # pinned title/helper first
-    st.markdown('<div class="pinned-top">', unsafe_allow_html=True)
-    st.subheader("Validate the Model")
-    st.write("Upload a dataset with the same **features** and **UCS** to evaluate performance.")
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    if st.sidebar.button("Preview data", use_container_width=True):
-        if up is None:
-            st.warning("Upload an Excel file first, then preview.")
-        else:
-            preview_modal(read_book_bytes(up.getvalue()))
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
+        preview_modal(read_book_bytes(up.getvalue()))
     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()
     if st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
+    st.subheader("Validate the Model")
+    st.write("Upload a dataset with the same **features** and **UCS** 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]
@@ -563,13 +521,8 @@ if st.session_state.app_step == "validate":
             if any_viol.any():
                 tbl = df.loc[any_viol, FEATURES].copy()
                 tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(lambda r:", ".join([c for c,v in r.items() if v]), axis=1)
-        st.session_state.results["m_val"]={
-            "R": corrcoef_safe(df[TARGET], df["UCS_Pred"]),
-            "RMSE": rmse(df[TARGET], df["UCS_Pred"]),
-            "MAE": mean_absolute_error(df[TARGET], df["UCS_Pred"])
-        }
-        st.session_state.results["sv_val"]={"n":len(df),"pred_min":float(df["UCS_Pred"].min()),
-                                            "pred_max":float(df["UCS_Pred"].max()),"oor":oor_pct}
+        st.session_state.results["m_val"]={"R":correlation_coefficient(df[TARGET],df["UCS_Pred"]), "RMSE":rmse(df[TARGET],df["UCS_Pred"]), "MAE":mean_absolute_error(df[TARGET],df["UCS_Pred"])}
+        st.session_state.results["sv_val"]={"n":len(df),"pred_min":float(df["UCS_Pred"].min()),"pred_max":float(df["UCS_Pred"].max()),"oor":oor_pct}
         st.session_state.results["oor_tbl"]=tbl
 
     if "Validate" in st.session_state.results:
@@ -579,7 +532,7 @@ if st.session_state.app_step == "validate":
 
         left, spacer, right = st.columns(PLOT_COLS)
         with left:
-            pad, plotcol = left.columns([CROSS_NUDGE, 1])
+            pad, plotcol = left.columns([CROSS_NUDGE, 1])  # same nudge
             with plotcol:
                 st.plotly_chart(
                     cross_plot(st.session_state.results["Validate"][TARGET],
@@ -596,7 +549,7 @@ if st.session_state.app_step == "validate":
         if sv["oor"] > 0: st.warning("Some inputs fall outside **training min–max** ranges.")
         if st.session_state.results["oor_tbl"] is not None:
             st.write("*Out-of-range rows (vs. Training min–max):*")
-            html_table_center(st.session_state.results["oor_tbl"].reset_index(drop=True), index=False)
+            st.dataframe(st.session_state.results["oor_tbl"], use_container_width=True)
 
 # =========================
 # PREDICTION (no actual UCS)
@@ -609,20 +562,13 @@ if st.session_state.app_step == "predict":
         if book:
             df0 = next(iter(book.values()))
             st.sidebar.caption(f"**Data loaded:** {up.name} • {df0.shape[0]} rows × {df0.shape[1]} cols")
+    if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
+        preview_modal(read_book_bytes(up.getvalue()))
+    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()
 
-    # pinned title/helper first
-    st.markdown('<div class="pinned-top">', unsafe_allow_html=True)
     st.subheader("Prediction")
     st.write("Upload a dataset with the feature columns (no **UCS**).")
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    if st.sidebar.button("Preview data", use_container_width=True):
-        if up is None:
-            st.warning("Upload an Excel file first, then preview.")
-        else:
-            preview_modal(read_book_bytes(up.getvalue()))
-    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()
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
@@ -649,13 +595,12 @@ if st.session_state.app_step == "predict":
 
         left, spacer, right = st.columns(PLOT_COLS)
         with left:
-            st.success("Predictions ready ✓")
             table = pd.DataFrame({
                 "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
-                "Value":  [sv["n"], sv["pred_min"], sv["pred_max"],
-                           sv["pred_mean"], sv["pred_std"], f'{sv["oor"]:.1f}%']
+                "Value":  [sv["n"], sv["pred_min"], sv["pred_max"], sv["pred_mean"], sv["pred_std"], f'{sv["oor"]:.1f}%']
             })
-            html_table_center(table, index=False)
+            st.success("Predictions ready ✓")
+            st.dataframe(table, use_container_width=True, hide_index=True)
             st.caption("**★ OOR** = % of rows whose input features fall outside the training min–max range.")
         with right:
             st.plotly_chart(
@@ -675,4 +620,4 @@ st.markdown(
     </div>
     """,
     unsafe_allow_html=True
-)
+)