Update app.py

app.py

@@ -6,16 +6,17 @@ import pandas as pd
 import numpy as np
 import joblib
 
-# matplotlib only for PREVIEW modal
+# matplotlib for PREVIEW modal and for the CROSS-PLOT (static)
 import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
+from matplotlib.ticker import FuncFormatter
 
 import plotly.graph_objects as go
-from sklearn.metrics import r2_score, mean_squared_error, mean_absolute_error
+from sklearn.metrics import mean_squared_error, mean_absolute_error
 
 # =========================
-# Constants (simple & robust)
+# Constants
 # =========================
 FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
 TARGET = "UCS"
@@ -24,46 +25,35 @@ DEFAULT_MODEL = MODELS_DIR / "ucs_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
-# ---- Plot sizing controls (edit here) ----
-CROSS_W = 450; CROSS_H = 450      # square cross-plot (Build + Validate)
-TRACK_W = 400; TRACK_H = 950      # log-strip style (all pages)
+# ---- Plot sizing controls ----
+CROSS_W = 450; CROSS_H = 450      # square cross-plot
+TRACK_W = 400; TRACK_H = 950      # log-strip style
 FONT_SZ  = 15
-PLOT_COLS = [30, 1, 20]           # 3-column band: left • spacer • right (Build + Validate)
-CROSS_NUDGE = 0.02                # push cross-plot to the RIGHT inside its band
+PLOT_COLS = [30, 1, 20]           # left • spacer • right
+CROSS_NUDGE = 0.02
 
 # =========================
 # Page / CSS
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
+
+# Hide file-uploader helper text + center dataframes (headers & cells)
 st.markdown("""
 <style>
-/* ✅ Hide the helper text in file uploader */
+/* Hide 'Drag and drop file here' and limit note in uploader */
 section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"] {
-    display: none !important;
+  display: none !important;
 }
+/* Center st.dataframe headers and cells */
+div[data-testid="stDataFrame"] div[role="columnheader"] { justify-content: center; }
+div[data-testid="stDataFrame"] div[role="gridcell"]     { justify-content: center; }
+/* Remove default app header/footer */
+header, footer { visibility: hidden !important; }
 </style>
 """, unsafe_allow_html=True)
-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; }
-      .stButton>button { background:#007bff; color:#fff; font-weight:600; border-radius:8px; border:none; }
-      .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; }
-    </style>
-    """,
-    unsafe_allow_html=True
-)
 
 # =========================
-# Password gate (define first, then call)
+# Password gate
 # =========================
 def inline_logo(path="logo.png") -> str:
     try:
@@ -80,44 +70,16 @@ def add_password_gate() -> None:
         required = os.environ.get("APP_PASSWORD", "")
 
     if not required:
-        st.markdown(
-            f"""
-            <div style="display:flex;align-items:center;gap:14px;margin:8px 0 6px 0;">
-              <img src="{inline_logo()}" style="width:56px;height:56px;object-fit:contain"/>
-              <div>
-                <div style="font-size:1.9rem;font-weight:800;">ST_GeoMech_UCS</div>
-                <div style="color:#667085;">Smart Thinking • Secure Access</div>
-              </div>
-            </div>
-            <div style="font-size:1.25rem;font-weight:700;margin:8px 0 4px 0;">Protected Area</div>
-            <div style="color:#6b7280;margin-bottom:14px;">
-              Set <code>APP_PASSWORD</code> in <b>Settings → Secrets</b> (or environment) and restart.
-            </div>
-            """,
-            unsafe_allow_html=True,
-        )
+        st.warning("Set APP_PASSWORD in Secrets (or environment) and restart.")
         st.stop()
 
     if st.session_state.get("auth_ok", False):
         return
 
-    st.markdown(
-        f"""
-        <div style="display:flex;align-items:center;gap:14px;margin:8px 0 6px 0;">
-          <img src="{inline_logo()}" style="width:56px;height:56px;object-fit:contain"/>
-          <div>
-            <div style="font-size:1.9rem;font-weight:800;">ST_GeoMech_UCS</div>
-            <div style="color:#667085;">Smart Thinking • Secure Access</div>
-          </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>
-        """,
-        unsafe_allow_html=True
-    )
-
-    pwd = st.text_input("Access key", type="password", placeholder="••••••••")
-    if st.button("Unlock", type="primary"):
+    st.sidebar.image("logo.png", use_column_width=True)
+    st.sidebar.markdown("### ST_GeoMech_UCS\nSmart Thinking • Secure Access")
+    pwd = st.sidebar.text_input("Access key", type="password", placeholder="••••••••")
+    if st.sidebar.button("Unlock", type="primary"):
         if pwd == required:
             st.session_state.auth_ok = True
             st.rerun()
@@ -141,17 +103,14 @@ except AttributeError:
             return wrapper
         return deco
 
-def rmse(y_true, y_pred):
+def rmse(y_true, y_pred) -> float:
     return float(np.sqrt(mean_squared_error(y_true, y_pred)))
 
-def r_value(y_true, y_pred):
-    """Pearson correlation coefficient (R)."""
-    y_true = np.asarray(y_true, dtype=float)
-    y_pred = np.asarray(y_pred, dtype=float)
-    mask = np.isfinite(y_true) & np.isfinite(y_pred)
-    if mask.sum() < 2:
-        return float("nan")
-    return float(np.corrcoef(y_true[mask], y_pred[mask])[0, 1])
+def pearson_r(y_true, y_pred) -> float:
+    a = np.asarray(y_true, dtype=float)
+    p = np.asarray(y_pred, dtype=float)
+    if a.size < 2: return float("nan")
+    return float(np.corrcoef(a, p)[0, 1])
 
 @st.cache_resource(show_spinner=False)
 def load_model(model_path: str):
@@ -163,8 +122,7 @@ def parse_excel(data_bytes: bytes):
     xl = pd.ExcelFile(bio)
     return {sh: xl.parse(sh) for sh in xl.sheet_names}
 
-def read_book_bytes(b: bytes):
-    return parse_excel(b) if b else {}
+def read_book_bytes(b: bytes): return parse_excel(b) if b else {}
 
 def ensure_cols(df, cols):
     miss = [c for c in cols if c not in df.columns]
@@ -176,116 +134,99 @@ def ensure_cols(df, cols):
 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
 
 def _nice_tick0(xmin: float, step: int = 100) -> float:
     return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
 
-# ---------- cross_plot ----------
-def cross_plot(actual, pred):
+# =========================
+# Cross-plot (Matplotlib, static)
+# =========================
+def cross_plot_static(actual, pred):
     a = pd.Series(actual).astype(float)
     p = pd.Series(pred).astype(float)
 
-    # Fixed extents + identical tick settings
-    AX_MIN, AX_MAX = 6000, 10000
-    TICK0, DTICK = 6000, 1000
+    fixed_min, fixed_max = 6000, 10000
+    ticks = np.arange(6000, 10001, 1000)
 
-    fig = go.Figure()
+    fig, ax = plt.subplots(figsize=(CROSS_W/100, CROSS_H/100), dpi=100)
 
-    # Points
-    fig.add_trace(go.Scatter(
-        x=a, y=p, mode="markers",
-        marker=dict(size=6, color=COLORS["pred"]),
-        hovertemplate="Actual: %{x:.0f}<br>Pred: %{y:.0f}<extra></extra>",
-        showlegend=False
-    ))
+    ax.scatter(a, p, s=14, c=COLORS["pred"], alpha=0.9, edgecolors="none")
 
-    # 1:1 reference line (full diagonal)
-    fig.add_trace(go.Scatter(
-        x=[AX_MIN, AX_MAX], y=[AX_MIN, AX_MAX], mode="lines",
-        line=dict(color=COLORS["ref"], width=1.2, dash="dash"),
-        hoverinfo="skip", showlegend=False
-    ))
+    # 1:1 diagonal
+    ax.plot([fixed_min, fixed_max], [fixed_min, fixed_max],
+            linestyle="--", linewidth=1.2, color=COLORS["ref"])
 
-    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)
-    )
+    # Limits and ticks
+    ax.set_xlim(fixed_min, fixed_max)
+    ax.set_ylim(fixed_min, fixed_max)
+    ax.set_xticks(ticks)
+    ax.set_yticks(ticks)
 
-    # Make the two axes identical: same range, same ticks, same aspect
-    fig.update_xaxes(
-        title_text="<b>Actual UCS (psi)</b>",
-        title_font=dict(size=18, family="Arial", color="#000"),
-        range=[AX_MIN, AX_MAX],
-        tick0=TICK0, dtick=DTICK, tickformat=",.0f", ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        scaleanchor="y", scaleratio=1,  # lock aspect to keep 45° line exact
-        fixedrange=True,                 # keep the range fixed (no zoom/pan)
-        automargin=True
-    )
-    fig.update_yaxes(
-        title_text="<b>Predicted UCS (psi)</b>",
-        title_font=dict(size=18, family="Arial", color="#000"),
-        range=[AX_MIN, AX_MAX],
-        tick0=TICK0, dtick=DTICK, tickformat=",.0f", ticks="outside",
-        showline=True, linewidth=1.2, linecolor="#444", mirror=True,
-        showgrid=True, gridcolor="rgba(0,0,0,0.12)",
-        fixedrange=True,                 # same fixed range
-        automargin=True
-    )
+    # Equal aspect for true 45°
+    ax.set_aspect('equal', adjustable='box')
 
-    return fig
+    # Thousands formatter
+    fmt = FuncFormatter(lambda x, _: f"{int(x):,}")
+    ax.xaxis.set_major_formatter(fmt)
+    ax.yaxis.set_major_formatter(fmt)
+
+    # Labels (bold, larger)
+    ax.set_xlabel("Actual UCS (psi)", fontweight="bold", fontsize=16)
+    ax.set_ylabel("Predicted UCS (psi)", fontweight="bold", fontsize=16)
 
+    # Grid & frame
+    ax.grid(True, linestyle=":", alpha=0.35)
+    for spine in ax.spines.values():
+        spine.set_visible(True)
+        spine.set_linewidth(1.2)
+        spine.set_color("#444")
 
-# ---------- track_plot ----------
+    fig.tight_layout()
+    return fig
+
+# =========================
+# Track plot (Plotly)
+# =========================
 def track_plot(df, include_actual=True):
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
-    if depth_col:
+    if depth_col is not None:
         y = pd.Series(df[depth_col]).astype(float)
         ylab = depth_col
+        y_range = [float(y.max()), float(y.min())]  # reverse
     else:
         y = pd.Series(np.arange(1, len(df) + 1))
         ylab = "Point Index"
+        y_range = [float(y.max()), float(y.min())]
 
-    y_range = [float(y.max()), float(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
     tick0 = _nice_tick0(xmin, step=100)
 
     fig = go.Figure()
-
     fig.add_trace(go.Scatter(
         x=df["UCS_Pred"], y=y, mode="lines",
         line=dict(color=COLORS["pred"], width=1.8),
         name="UCS_Pred",
-        hovertemplate="UCS_Pred: %{x:.0f}<br>" + ylab + ": %{y}<extra></extra>"
+        hovertemplate="UCS_Pred: %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
     ))
-
     if include_actual and TARGET in df.columns:
         fig.add_trace(go.Scatter(
             x=df[TARGET], y=y, mode="lines",
             line=dict(color=COLORS["actual"], width=2.0, dash="dot"),
             name="UCS (actual)",
-            hovertemplate="UCS (actual): %{x:.0f}<br>" + ylab + ": %{y}<extra></extra>"
+            hovertemplate="UCS (actual): %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        width=TRACK_W, height=TRACK_H,
-        paper_bgcolor="#fff", plot_bgcolor="#fff",
-        margin=dict(l=72, r=18, t=36, b=48),
-        hovermode="closest",
+        width=TRACK_W, height=TRACK_H, paper_bgcolor="#fff", plot_bgcolor="#fff",
+        margin=dict(l=72, r=18, t=36, b=48), hovermode="closest",
         font=dict(size=FONT_SZ),
         legend=dict(
             x=0.98, y=0.05, xanchor="right", yanchor="bottom",
@@ -293,26 +234,19 @@ def track_plot(df, include_actual=True):
         ),
         legend_title_text=""
     )
-
     fig.update_xaxes(
-        title_text="<b>UCS (psi)</b>",
-        title_font=dict(size=18, family="Arial", color="#000"),
+        title_text="<b>UCS (psi)</b>", title_font=dict(size=18),
         side="top", range=[xmin, xmax],
-        tick0=tick0, tickmode="auto", tickformat=",.0f",
-        ticks="outside",
+        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
     )
-
     fig.update_yaxes(
-        title_text=f"<b>{ylab}</b>",
-        title_font=dict(size=18, family="Arial", color="#000"),
-        range=y_range,
-        ticks="outside",
+        title_text=f"<b>{ylab}</b>", title_font=dict(size=18),
+        range=y_range, ticks="outside",
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
-
     return fig
 
 # ---------- Preview modal (matplotlib) ----------
@@ -358,11 +292,13 @@ 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"})
+                tbl = df[FEATURES].agg(['min','max','mean','std']).T.rename(
+                    columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}
+                ).round(2)
                 st.dataframe(tbl.reset_index(names="Feature"), use_container_width=True)
 
 # =========================
-# Load model (simple)
+# Load model
 # =========================
 def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
@@ -411,19 +347,13 @@ st.session_state.setdefault("dev_file_loaded",False)
 st.session_state.setdefault("dev_preview",False)
 
 # =========================
-# Hero
+# Branding in Sidebar
 # =========================
-st.markdown(
-    f"""
-    <div class="st-hero">
-      <img src="{inline_logo()}" class="brand" />
-      <div>
-        <h1>ST_GeoMech_UCS</h1>
-        <div class="tagline">Real-Time UCS Tracking While Drilling</div>
-      </div>
-    </div>
-    """,
-    unsafe_allow_html=True,
+st.sidebar.image("logo.png", use_column_width=True)
+st.sidebar.markdown(
+    "<div style='font-weight:800;font-size:1.2rem;'>ST_GeoMech_UCS</div>"
+    "<div style='color:#667085;'>Real-Time UCS Tracking While Drilling</div>",
+    unsafe_allow_html=True
 )
 
 # =========================
@@ -463,11 +393,11 @@ if st.session_state.app_step == "dev":
         st.session_state.dev_preview = True
 
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
-    # always available nav
+    # 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 ----
+    # ---- Pinned helper at the very top ----
     helper_top = st.container()
     with helper_top:
         st.subheader("Case Building")
@@ -490,16 +420,14 @@ if st.session_state.app_step == "dev":
         tr["UCS_Pred"] = model.predict(tr[FEATURES])
         te["UCS_Pred"] = model.predict(te[FEATURES])
 
-        # ---- metrics (R, RMSE, MAE) ----
-        st.session_state.results["Train"]=tr
-        st.session_state.results["Test"]=te
+        st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
         st.session_state.results["m_train"]={
-            "R": r_value(tr[TARGET], tr["UCS_Pred"]),
+            "R": pearson_r(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": r_value(te[TARGET], te["UCS_Pred"]),
+            "R": pearson_r(te[TARGET], te["UCS_Pred"]),
             "RMSE": rmse(te[TARGET], te["UCS_Pred"]),
             "MAE": mean_absolute_error(te[TARGET], te["UCS_Pred"])
         }
@@ -510,18 +438,13 @@ if st.session_state.app_step == "dev":
 
     def _dev_block(df, m):
         c1,c2,c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
+        c1.metric("R", f"{m['R']:.2f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
+
         left, spacer, right = st.columns(PLOT_COLS)
         with left:
-            pad, plotcol = left.columns([CROSS_NUDGE, 1])  # shift cross-plot right inside its band
+            pad, plotcol = left.columns([CROSS_NUDGE, 1])
             with plotcol:
-                st.plotly_chart(
-                    cross_plot(df[TARGET], df["UCS_Pred"]),
-                    use_container_width=False,
-                    config={"displayModeBar": False, "scrollZoom": True}
-                )
+                st.pyplot(cross_plot_static(df[TARGET], df["UCS_Pred"]), use_container_width=False)
         with right:
             st.plotly_chart(
                 track_plot(df, include_actual=True),
@@ -570,38 +493,31 @@ if st.session_state.app_step == "validate":
             oor_pct = float(any_viol.mean()*100.0)
             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
-                )
+                for c in FEATURES:
+                    if pd.api.types.is_numeric_dtype(tbl[c]):
+                        tbl[c] = tbl[c].round(2)
+                tbl["Violations"] = pd.DataFrame({f:(df[f]<ranges[f][0])|(df[f]>ranges[f][1]) for f in FEATURES}).loc[any_viol].apply(lambda r:", ".join([c for c,v in r.items() if v]), axis=1)
         st.session_state.results["m_val"]={
-            "R": r_value(df[TARGET], df["UCS_Pred"]),
+            "R": pearson_r(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["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:
         m = st.session_state.results["m_val"]
         c1,c2,c3 = st.columns(3)
-        c1.metric("R", f"{m['R']:.2f}")
-        c2.metric("RMSE", f"{m['RMSE']:.2f}")
-        c3.metric("MAE", f"{m['MAE']:.2f}")
+        c1.metric("R", f"{m['R']:.2f}"); c2.metric("RMSE", f"{m['RMSE']:.2f}"); c3.metric("MAE", f"{m['MAE']:.2f}")
 
         left, spacer, right = st.columns(PLOT_COLS)
         with left:
             pad, plotcol = left.columns([CROSS_NUDGE, 1])
             with plotcol:
-                st.plotly_chart(
-                    cross_plot(st.session_state.results["Validate"][TARGET],
-                               st.session_state.results["Validate"]["UCS_Pred"]),
-                    use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
+                st.pyplot(
+                    cross_plot_static(st.session_state.results["Validate"][TARGET],
+                                      st.session_state.results["Validate"]["UCS_Pred"]),
+                    use_container_width=False
                 )
         with right:
             st.plotly_chart(
@@ -656,12 +572,16 @@ if st.session_state.app_step == "predict":
 
     if "PredictOnly" in st.session_state.results:
         df = st.session_state.results["PredictOnly"]; sv = st.session_state.results["sv_pred"]
-
         left, spacer, right = st.columns(PLOT_COLS)
         with left:
             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"],
+                           round(sv["pred_min"],2),
+                           round(sv["pred_max"],2),
+                           round(sv["pred_mean"],2),
+                           round(sv["pred_std"],2),
+                           f'{sv["oor"]:.1f}%']
             })
             st.success("Predictions ready ✓")
             st.dataframe(table, use_container_width=True, hide_index=True)
@@ -684,4 +604,4 @@ st.markdown(
     </div>
     """,
     unsafe_allow_html=True
-)
+)