Update app.py

app.py

@@ -20,20 +20,23 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 # Page / Theme
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
+
+# Hide Streamlit default header/footer
 st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
+
+# Compact page, bigger logo, tidy hero
 st.markdown(
     """
     <style>
     .stApp { background: #FFFFFF; }
     section[data-testid="stSidebar"] { background: #F6F9FC; }
+    .block-container { padding-top: .5rem; padding-bottom: .5rem; } /* less vertical padding */
     .stButton>button{ background:#007bff; color:#fff; font-weight:bold; border-radius:8px; border:none; padding:10px 24px; }
     .stButton>button:hover{ background:#0056b3; }
-    /* Hero header */
-    .st-hero { display:flex; align-items:center; gap:14px; padding: 6px 0 0 0; }
-    .st-hero .brand { width:70px; height:70px; object-fit:contain; }
+    .st-hero { display:flex; align-items:center; gap:16px; padding-top: 4px; }
+    .st-hero .brand { width:110px; height:110px; object-fit:contain; }  /* enlarged logo */
     .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; }
-    /* Ensure hero is tight to the top */
     [data-testid="stBlock"]{ margin-top:0 !important; }
     </style>
     """,
@@ -44,11 +47,8 @@ st.markdown(
 # Small helpers
 # =========================
 def _get_model_url():
-    """Avoid Streamlit secrets error when secrets.toml is absent."""
-    try:
-        return (st.secrets.get("MODEL_URL", "") or os.environ.get("MODEL_URL", "") or "").strip()
-    except Exception:
-        return (os.environ.get("MODEL_URL", "") or "").strip()
+    """HuggingFace exposes Space variables via environment; avoid st.secrets to prevent red banner."""
+    return (os.environ.get("MODEL_URL", "") or "").strip()
 
 def rmse(y_true, y_pred):
     return float(np.sqrt(mean_squared_error(y_true, y_pred)))
@@ -86,12 +86,16 @@ def find_sheet(book, names):
             return low2orig[nm.lower()]
     return None
 
-def cross_plot(actual, pred, title, size=(5.6, 5.6)):
-    fig, ax = plt.subplots(figsize=size)
-    ax.scatter(actual, pred, s=16, alpha=0.7)
+def cross_plot(actual, pred, title, size=(5.0, 5.0)):
+    fig, ax = plt.subplots(figsize=size, dpi=100)
+    ax.scatter(actual, pred, s=14, alpha=0.75)
     lo = float(np.nanmin([actual.min(), pred.min()]))
     hi = float(np.nanmax([actual.max(), pred.max()]))
-    ax.plot([lo, hi], [lo, hi], '--')
+    pad = 0.03 * (hi - lo if hi > lo else 1.0)
+    ax.plot([lo - pad, hi + pad], [lo - pad, hi + pad], '--', lw=1.2, color=(0.35, 0.35, 0.35))
+    ax.set_xlim(lo - pad, hi + pad)
+    ax.set_ylim(lo - pad, hi + pad)
+    ax.set_aspect('equal', 'box')  # perfect 1:1
     ax.set_xlabel("Actual UCS")
     ax.set_ylabel("Predicted UCS")
     ax.set_title(title)
@@ -99,35 +103,35 @@ def cross_plot(actual, pred, title, size=(5.6, 5.6)):
     return fig
 
 def depth_or_index_track(df, title, include_actual=True):
-    # If a depth-like column exists, plot UCS vs Depth (depth downward); else index track
+    # depth-like column?
     depth_col = None
     for c in df.columns:
         if 'depth' in str(c).lower():
             depth_col = c
             break
-    fig, ax = plt.subplots(figsize=(5.8, 7.5))
+    # taller for a log-profile look
+    fig_h = 8.8 if depth_col is not None else 8.0
+    fig, ax = plt.subplots(figsize=(6.2, fig_h), dpi=100)
+
     if depth_col is not None:
-        ax.plot(df["UCS_Pred"], df[depth_col], label="UCS_Pred")
+        ax.plot(df["UCS_Pred"], df[depth_col], '--', lw=1.6, label="UCS_Pred")
         if include_actual and TARGET in df.columns:
-            ax.plot(df[TARGET], df[depth_col], alpha=0.7, label="UCS (actual)")
+            ax.plot(df[TARGET], df[depth_col], '-', lw=2.0, alpha=0.8, label="UCS (actual)")
         ax.set_ylabel(depth_col)
         ax.set_xlabel("UCS")
-        ax.xaxis.set_label_position('top')
-        ax.xaxis.tick_top()
-        ax.invert_yaxis()
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
     else:
         idx = np.arange(1, len(df) + 1)
-        ax.plot(df["UCS_Pred"], idx, label="UCS_Pred")
+        ax.plot(df["UCS_Pred"], idx, '--', lw=1.6, label="UCS_Pred")
         if include_actual and TARGET in df.columns:
-            ax.plot(df[TARGET], idx, alpha=0.7, label="UCS (actual)")
+            ax.plot(df[TARGET], idx, '-', lw=2.0, alpha=0.8, label="UCS (actual)")
         ax.set_ylabel("Point Index")
         ax.set_xlabel("UCS")
-        ax.xaxis.set_label_position('top')
-        ax.xaxis.tick_top()
-        ax.invert_yaxis()
+        ax.xaxis.set_label_position('top'); ax.xaxis.tick_top(); ax.invert_yaxis()
+
     ax.grid(True, linestyle=":", alpha=0.4)
-    ax.set_title(title, pad=12)
-    ax.legend()
+    ax.set_title(title, pad=10)
+    ax.legend(loc="best")
     return fig
 
 def export_workbook(sheets_dict, summary_df=None):
@@ -180,18 +184,13 @@ MODEL_URL = _get_model_url()
 
 def ensure_model_present() -> Path:
     """Return a local model path, trying local files first, then (optionally) downloading with timeout."""
-    # Check local paths first
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
         if p.exists() and p.stat().st_size > 0:
             return p
-
-    # If no URL set, we cannot download
     if not MODEL_URL:
         return None
-
-    # Try to download with a short timeout so startup can't hang
     try:
-        import requests  # only when needed
+        import requests
         DEFAULT_MODEL.parent.mkdir(parents=True, exist_ok=True)
         with st.status("Downloading model…", expanded=False):
             with requests.get(MODEL_URL, stream=True, timeout=30) as r:
@@ -210,7 +209,6 @@ if not model_path:
     st.error("Model not found. Upload models/ucs_rf.joblib (or set MODEL_URL in Settings → Variables).")
     st.stop()
 
-# Load model (fix: correct try/except block)
 try:
     model = load_model(str(model_path))
 except Exception as e:
@@ -278,7 +276,7 @@ if st.session_state.app_step == "intro":
     st.markdown(
         "1. *Upload the Model Development Data.* This should contain your training and testing sets.\n"
         "2. Click *Run Model* to view metrics, cross-plots, and a track plot.\n"
-        "3. Click *Go to Prediction* and upload a new dataset to get predictions.\n"
+        "3. Click *Proceed to Prediction* and upload a new dataset to get predictions.\n"
         "4. *Export* everything to Excel for further analysis."
     )
     if st.button("Start Showcase", type="primary", key="start_showcase"):
@@ -290,10 +288,18 @@ if st.session_state.app_step == "intro":
 # =========================
 if st.session_state.app_step == "dev":
     st.sidebar.header("Model Development Data")
-    train_test_file = st.sidebar.file_uploader("Upload Train/Test Excel", type=["xlsx", "xls"], key="dev_upload")
+    train_test_file = st.sidebar.file_uploader("Upload Data (Excel)", type=["xlsx", "xls"], key="dev_upload")
+
+    # Always show the nav button, disabled until results exist once.
+    ready_for_pred = ("Train" in st.session_state.results) or ("Test" in st.session_state.results)
+    st.sidebar.button(
+        "Proceed to Prediction ▶",
+        use_container_width=True,
+        disabled=not ready_for_pred,
+        on_click=(lambda: st.session_state.update(app_step="predict")) if ready_for_pred else None,
+    )
+
     run_btn = st.sidebar.button("Run Model", type="primary", use_container_width=True)
-    if "Train" in st.session_state.results or "Test" in st.session_state.results:
-        st.sidebar.button("Go to Prediction ▶", use_container_width=True, on_click=lambda: st.session_state.update(app_step="predict"))
 
     st.subheader("Model Development")
     if run_btn and train_test_file is not None:
@@ -304,91 +310,82 @@ if st.session_state.app_step == "dev":
                 st.stop()
             status.update(label="Workbook read ✓")
 
+            # still expect Train/Test sheets internally
             sh_train = find_sheet(book, ["Train", "Training", "training2", "train", "training"])
-            sh_test = find_sheet(book, ["Test", "Testing", "testing2", "test", "testing"])
+            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()
+            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()
+                status.update(label="Missing required columns.", state="error"); st.stop()
 
             status.update(label="Columns validated ✓")
             status.update(label="Predicting…")
 
             df_tr["UCS_Pred"] = model.predict(df_tr[FEATURES])
             df_te["UCS_Pred"] = model.predict(df_te[FEATURES])
-            st.session_state.results["Train"] = df_tr
-            st.session_state.results["Test"] = df_te
+            st.session_state.results["Train"] = df_tr; st.session_state.results["Test"] = df_te
 
             st.session_state.results["metrics_train"] = {
                 "R2": r2_score(df_tr[TARGET], df_tr["UCS_Pred"]),
                 "RMSE": rmse(df_tr[TARGET], df_tr["UCS_Pred"]),
                 "MAE": mean_absolute_error(df_tr[TARGET], df_tr["UCS_Pred"]),
             }
-            st.session_state.results["metrics_test"] = {
+            st.session_state.results["metrics_test"]  = {
                 "R2": r2_score(df_te[TARGET], df_te["UCS_Pred"]),
                 "RMSE": rmse(df_te[TARGET], df_te["UCS_Pred"]),
                 "MAE": mean_absolute_error(df_te[TARGET], df_te["UCS_Pred"]),
             }
 
-            tr_min = df_tr[FEATURES].min().to_dict()
-            tr_max = df_tr[FEATURES].max().to_dict()
-            st.session_state.train_ranges = {f: (float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
+            tr_min = df_tr[FEATURES].min().to_dict(); tr_max = df_tr[FEATURES].max().to_dict()
+            st.session_state.train_ranges = {f:(float(tr_min[f]), float(tr_max[f])) for f in FEATURES}
 
-            status.update(label="Done ✓", state="complete")
-            toast("Model run complete 🚀")
+            status.update(label="Done ✓", state="complete"); toast("Model run complete 🚀")
 
-    if "Train" in st.session_state.results or "Test" in st.session_state.results:
+    if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
         tab1, tab2 = st.tabs(["Training", "Testing"])
         if "Train" in st.session_state.results:
             with tab1:
-                df = st.session_state.results["Train"]
-                m = st.session_state.results["metrics_train"]
-                c1, c2, c3 = st.columns(3)
+                df = st.session_state.results["Train"]; m = st.session_state.results["metrics_train"]
+                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}")
-                left, right = st.columns(2)
+                left,right = st.columns([1,1])
                 with left:
                     st.pyplot(cross_plot(df[TARGET], df["UCS_Pred"], "Training: Actual vs Predicted"), use_container_width=True)
                 with right:
                     st.pyplot(depth_or_index_track(df, "Training: Depth/Index Track", include_actual=True), use_container_width=True)
+
         if "Test" in st.session_state.results:
             with tab2:
-                df = st.session_state.results["Test"]
-                m = st.session_state.results["metrics_test"]
-                c1, c2, c3 = st.columns(3)
+                df = st.session_state.results["Test"]; m = st.session_state.results["metrics_test"]
+                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}")
-                left, right = st.columns(2)
+                left,right = st.columns([1,1])
                 with left:
                     st.pyplot(cross_plot(df[TARGET], df["UCS_Pred"], "Testing: Actual vs Predicted"), use_container_width=True)
                 with right:
                     st.pyplot(depth_or_index_track(df, "Testing: Depth/Index Track", include_actual=True), use_container_width=True)
 
         st.markdown("---")
-        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()}})
+            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()}})
+            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:
             data_bytes = export_workbook(sheets, summary_df)
-            st.download_button(
-                "Export Train/Test Results to Excel",
-                data=data_bytes,
-                file_name="UCS_Dev_Results.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            )
+            st.download_button("Export Train/Test Results to Excel",
+                data=data_bytes, file_name="UCS_Dev_Results.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
         except RuntimeError as e:
             st.warning(str(e))
 
@@ -397,7 +394,7 @@ if st.session_state.app_step == "dev":
 # =========================
 if st.session_state.app_step == "predict":
     st.sidebar.header("Prediction (Validation)")
-    validation_file = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx", "xls"], key="val_upload")
+    validation_file = st.sidebar.file_uploader("Upload Validation Excel", type=["xlsx","xls"], key="val_upload")
     predict_btn = st.sidebar.button("Predict", type="primary", use_container_width=True)
     st.sidebar.button("⬅ Back", on_click=lambda: st.session_state.update(app_step="dev"), use_container_width=True)
 
@@ -407,83 +404,55 @@ if st.session_state.app_step == "predict":
     if predict_btn and validation_file is not None:
         with st.status("Predicting…", expanded=False) as status:
             vbook = read_book(validation_file)
-            if not vbook:
-                status.update(label="Could not read the Validation Excel.", state="error")
-                st.stop()
+            if not vbook: status.update(label="Could not read the Validation Excel.", state="error"); st.stop()
             status.update(label="Workbook read ✓")
-            vname = find_sheet(vbook, ["Validation", "Validate", "validation2", "Val", "val"]) or list(vbook.keys())[0]
+            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): 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
 
-            # OOR check against training min–max
-            ranges = st.session_state.train_ranges
-            oor_table = None
-            oor_pct = 0.0
+            ranges = st.session_state.train_ranges; oor_table = None; oor_pct = 0.0
             if ranges:
                 viol = {f: (df_val[f] < ranges[f][0]) | (df_val[f] > ranges[f][1]) for f in FEATURES}
-                any_viol = pd.DataFrame(viol).any(axis=1)
-                oor_pct = float(any_viol.mean() * 100.0)
+                any_viol = pd.DataFrame(viol).any(axis=1); oor_pct = float(any_viol.mean()*100.0)
                 if any_viol.any():
                     offenders = df_val.loc[any_viol, FEATURES].copy()
-                    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
+                    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"]),
+                    "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),
                 "pred_min": float(df_val["UCS_Pred"].min()),
                 "pred_max": float(df_val["UCS_Pred"].max()),
-                "oor_pct": oor_pct,
+                "oor_pct": oor_pct
             }
             st.session_state.results["oor_table"] = oor_table
             status.update(label="Predictions ready ✓", state="complete")
 
     if "Validate" in st.session_state.results:
         st.subheader("Validation Results")
-        sv = st.session_state.results["summary_val"]
-        oor_table = st.session_state.results.get("oor_table")
-        c1, c2, c3, c4 = st.columns(4)
-        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}")
-        c4.metric("OOR %", f"{sv['oor_pct']:.1f}%")
-        left, right = st.columns(2)
+        sv = st.session_state.results["summary_val"]; oor_table = st.session_state.results.get("oor_table")
+        c1,c2,c3,c4 = st.columns(4)
+        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}"); c4.metric("OOR %", f"{sv['oor_pct']:.1f}%")
+        left,right = st.columns([1,1])
         with left:
             if TARGET in st.session_state.results["Validate"].columns:
-                st.pyplot(
-                    cross_plot(
-                        st.session_state.results["Validate"][TARGET],
-                        st.session_state.results["Validate"]["UCS_Pred"],
-                        "Validation: Actual vs Predicted",
-                    ),
-                    use_container_width=True,
-                )
+                st.pyplot(cross_plot(st.session_state.results["Validate"][TARGET], st.session_state.results["Validate"]["UCS_Pred"], "Validation: Actual vs Predicted"), use_container_width=True)
             else:
                 st.info("Actual UCS values are not available in the validation data. Cross-plot cannot be generated.")
         with right:
-            st.pyplot(
-                depth_or_index_track(
-                    st.session_state.results["Validate"],
-                    "Validation: Depth/Index Track",
-                    include_actual=(TARGET in st.session_state.results["Validate"].columns),
-                ),
-                use_container_width=True,
-            )
+            st.pyplot(depth_or_index_track(st.session_state.results["Validate"], "Validation: Depth/Index Track", include_actual=(TARGET in st.session_state.results["Validate"].columns)), use_container_width=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)
@@ -491,19 +460,15 @@ if st.session_state.app_step == "predict":
         st.markdown("---")
         sheets = {"Validate_with_pred": st.session_state.results["Validate"]}
         rows = []
-        for name, key in [("Train", "metrics_train"), ("Test", "metrics_test"), ("Validate", "metrics_val")]:
+        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()}})
+            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:
             data_bytes = export_workbook(sheets, summary_df)
-            st.download_button(
-                "Export Validation Results to Excel",
-                data=data_bytes,
-                file_name="UCS_Validation_Results.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            )
+            st.download_button("Export Validation Results to Excel",
+                data=data_bytes, file_name="UCS_Validation_Results.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
         except RuntimeError as e:
             st.warning(str(e))
 
@@ -511,7 +476,4 @@ if st.session_state.app_step == "predict":
 # Footer
 # =========================
 st.markdown("---")
-st.markdown(
-    "<div style='text-align:center; color:#6b7280;'>ST_GeoMech_UCS • © Smart Thinking</div>",
-    unsafe_allow_html=True,
-)
+st.markdown("<div style='text-align:center; color:#6b7280;'>ST_GeoMech_UCS • © Smart Thinking</div>", unsafe_allow_html=True)