Update app.py

app.py

@@ -12,7 +12,7 @@ matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
 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)
@@ -22,6 +22,7 @@ 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"}
 
 # ---- Plot sizing controls (edit here) ----
@@ -29,14 +30,15 @@ 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 (Build + Validate)
-CROSS_NUDGE = 0.5                # push cross-plot to the RIGHT inside its band:
-                                  # inner columns [CROSS_NUDGE : 1] → bigger = more right
+CROSS_NUDGE = 0.5                 # 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)
+
+# Hide drag-n-drop helper texts inside uploaders; keep the Browse button
 st.markdown(
     """
     <style>
@@ -45,11 +47,23 @@ st.markdown(
       .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 { 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 copy and limit line in uploader */
+      [data-testid="stFileUploadDropzone"] [data-testid="stFileUploaderInstructions"],
+      [data-testid="stFileUploadDropzone"] [data-testid="stCaptionContainer"],
+      .stFileUploader .dz-message {display:none !important;}
+
+      /* Center our HTML tables */
+      .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; }
     </style>
     """,
     unsafe_allow_html=True
@@ -134,7 +148,18 @@ except AttributeError:
             return wrapper
         return deco
 
-def rmse(y_true, y_pred): return float(np.sqrt(mean_squared_error(y_true, y_pred)))
+def rmse(y_true, y_pred) -> float:
+    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)
+    a = a.replace([np.inf, -np.inf], np.nan).dropna()
+    b = b.replace([np.inf, -np.inf], np.nan).dropna()
+    n = min(len(a), len(b))
+    if n == 0:
+        return float("nan")
+    return float(np.corrcoef(a.iloc[:n], b.iloc[:n])[0, 1])
 
 @st.cache_resource(show_spinner=False)
 def load_model(model_path: str):
@@ -161,20 +186,36 @@ def find_sheet(book, names):
         if nm.lower() in low2orig: return low2orig[nm.lower()]
     return None
 
-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
+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
     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)
-    x0, x1 = lo - pad, hi + pad
+    lo -= pad; hi += pad
+    step = _nice_step(lo, hi, target_ticks=6)
+    tick0 = _nice_tick0(lo, step)
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -183,25 +224,28 @@ 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=[x0, x1], y=[x0, x1], mode="lines",
+        x=[lo, hi], y=[lo, hi], 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)
     )
-    fig.update_xaxes(title_text="<b>Actual UCS (psi)</b>", range=[x0, x1],
-                     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=[x0, x1],
-                     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)
+    # identical x & y ranges/ticks; stays locked on zoom
+    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)
     return fig
 
 def track_plot(df, include_actual=True):
@@ -224,7 +268,8 @@ def track_plot(df, include_actual=True):
     x_lo, x_hi = float(x_series.min()), float(x_series.max())
     x_pad = 0.03 * (x_hi - x_lo if x_hi > x_lo else 1.0)
     xmin, xmax = x_lo - x_pad, x_hi + x_pad
-    tick0 = _nice_tick0(xmin, step=100)  # sensible first tick at left border
+    x_step = _nice_step(xmin, xmax, target_ticks=6)
+    tick0 = _nice_tick0(xmin, x_step)
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
@@ -254,7 +299,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="auto", tick0=tick0,
+        tickmode="linear", tick0=tick0, dtick=x_step,
         showline=True, linewidth=1.2, linecolor="#444", mirror=True,
         showgrid=True, gridcolor="rgba(0,0,0,0.12)", automargin=True
     )
@@ -309,8 +354,10 @@ 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"})
-                st.dataframe(tbl.reset_index(names="Feature"), use_container_width=True)
+                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)
 
 # =========================
 # Load model (simple)
@@ -370,7 +417,7 @@ st.markdown(
       <img src="{inline_logo()}" class="brand" />
       <div>
         <h1>ST_GeoMech_UCS</h1>
-        <div class="tagline">Real-Time UCS Tracking While Drilling — Cloud Ready</div>
+        <div class="tagline">Real-Time UCS Tracking While Drilling</div>
       </div>
     </div>
     """,
@@ -396,7 +443,7 @@ if st.session_state.app_step == "intro":
 # CASE BUILDING
 # =========================
 if st.session_state.app_step == "dev":
-    st.sidebar.header("Case Building (Development)")
+    st.sidebar.header("Case Building")
     up = st.sidebar.file_uploader("Upload Train/Test Excel", type=["xlsx","xls"])
     if up is not None:
         st.session_state.dev_file_bytes = up.getvalue()
@@ -409,19 +456,22 @@ 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")
 
-    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
+    # 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
 
     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 (Development)")
+        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:
@@ -438,12 +488,21 @@ 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"]={"R2":r2_score(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"] ={"R2":r2_score(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": 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"])
+        }
 
         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}
@@ -451,22 +510,16 @@ if st.session_state.app_step == "dev":
 
     def _dev_block(df, m):
         c1,c2,c3 = st.columns(3)
-        c1.metric("R²", f"{m['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
+        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])  # 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"])
@@ -486,12 +539,18 @@ 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")
-    if st.sidebar.button("Preview data", use_container_width=True, disabled=(up is None)):
-        preview_modal(read_book_bytes(up.getvalue()))
+
+    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 st.sidebar.button("Proceed to Prediction ▶", use_container_width=True): st.session_state.app_step="predict"; st.rerun()
 
+    # pinned
     st.subheader("Validate the Model")
     st.write("Upload a dataset with the same **features** and **UCS** to evaluate performance.")
 
@@ -510,18 +569,23 @@ 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"]={"R2":r2_score(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": 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["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['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
+        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])  # same nudge
+            pad, plotcol = left.columns([CROSS_NUDGE, 1])
             with plotcol:
                 st.plotly_chart(
                     cross_plot(st.session_state.results["Validate"][TARGET],
@@ -538,7 +602,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):*")
-            st.dataframe(st.session_state.results["oor_tbl"], use_container_width=True)
+            html_table_center(st.session_state.results["oor_tbl"].reset_index(drop=True), index=False)
 
 # =========================
 # PREDICTION (no actual UCS)
@@ -551,11 +615,17 @@ 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()))
+
+    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()
 
+    # pinned
     st.subheader("Prediction")
     st.write("Upload a dataset with the feature columns (no **UCS**).")
 
@@ -584,12 +654,13 @@ 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}%']
             })
-            st.success("Predictions ready ✓")
-            st.dataframe(table, use_container_width=True, hide_index=True)
+            html_table_center(table, index=False)
             st.caption("**★ OOR** = % of rows whose input features fall outside the training min–max range.")
         with right:
             st.plotly_chart(