Update app.py

app.py

@@ -21,10 +21,8 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 # =========================
 st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
 
-# Hide Streamlit default header/footer
+# Hide Streamlit default header/footer and tighten layout
 st.markdown("<style>header, footer{visibility:hidden !important;}</style>", unsafe_allow_html=True)
-
-# Compact page, bigger logo, tidy hero
 st.markdown(
     """
     <style>
@@ -44,14 +42,13 @@ st.markdown(
 )
 
 # =========================
-# Small helpers
+# Helpers
 # =========================
 def _get_model_url():
-    """HuggingFace exposes Space variables via environment; avoid st.secrets to prevent red banner."""
+    """Read optional MODEL_URL from environment only (avoid st.secrets 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)))
+def rmse(y_true, y_pred): return float(np.sqrt(mean_squared_error(y_true, y_pred)))
 
 def ensure_cols(df, cols):
     miss = [c for c in cols if c not in df.columns]
@@ -71,24 +68,20 @@ def parse_excel(data_bytes: bytes):
     return {sh: xl.parse(sh) for sh in xl.sheet_names}
 
 def read_book(upload):
-    if upload is None:
-        return {}
-    try:
-        return parse_excel(upload.getvalue())
+    if upload is None: return {}
+    try: return parse_excel(upload.getvalue())
     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
 
-def cross_plot(actual, pred, title, size=(5.0, 5.0)):
+def cross_plot(actual, pred, title, size=(4.6, 4.6)):
     fig, ax = plt.subplots(figsize=size, dpi=100)
-    ax.scatter(actual, pred, s=14, alpha=0.75)
+    ax.scatter(actual, pred, s=14, alpha=0.8)
     lo = float(np.nanmin([actual.min(), pred.min()]))
     hi = float(np.nanmax([actual.max(), pred.max()]))
     pad = 0.03 * (hi - lo if hi > lo else 1.0)
@@ -96,94 +89,80 @@ def cross_plot(actual, pred, title, size=(5.0, 5.0)):
     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)
+    ax.set_xlabel("Actual UCS"); ax.set_ylabel("Predicted UCS"); ax.set_title(title)
     ax.grid(True, ls=":", alpha=0.4)
     return fig
 
-def depth_or_index_track(df, title, include_actual=True):
-    # depth-like column?
+def depth_or_index_track(df, title=None, include_actual=True):
+    # Find depth-like column if available
     depth_col = None
     for c in df.columns:
         if 'depth' in str(c).lower():
-            depth_col = c
-            break
-    # 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)
+            depth_col = c; break
+
+    fig_h = 7.4 if depth_col is not None else 7.0  # taller track; still fits most screens
+    fig, ax = plt.subplots(figsize=(6.0, fig_h), dpi=100)
 
     if depth_col is not None:
         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], '-', lw=2.0, alpha=0.8, label="UCS (actual)")
-        ax.set_ylabel(depth_col)
-        ax.set_xlabel("UCS")
+            ax.plot(df[TARGET], df[depth_col], '-', lw=2.0, alpha=0.85, 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()
     else:
         idx = np.arange(1, len(df) + 1)
         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, '-', lw=2.0, alpha=0.8, label="UCS (actual)")
-        ax.set_ylabel("Point Index")
-        ax.set_xlabel("UCS")
+            ax.plot(df[TARGET], idx, '-', lw=2.0, alpha=0.85, 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.grid(True, linestyle=":", alpha=0.4)
-    ax.set_title(title, pad=10)
+    if title: ax.set_title(title, pad=8)  # no title if None/empty
     ax.legend(loc="best")
     return fig
 
 def export_workbook(sheets_dict, summary_df=None):
-    try:
-        import openpyxl  # noqa
-    except Exception:
-        raise RuntimeError("Export requires openpyxl. Please add it to requirements or install it.")
+    try: import openpyxl  # noqa
+    except Exception: raise RuntimeError("Export requires openpyxl. Please add it to requirements or install it.")
     buf = io.BytesIO()
     with pd.ExcelWriter(buf, engine="openpyxl") as xw:
         for name, frame in sheets_dict.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)
+        if summary_df is not None: summary_df.to_excel(xw, sheet_name="Summary", index=False)
     return buf.getvalue()
 
 def toast(msg):
-    try:
-        st.toast(msg)
-    except Exception:
-        st.info(msg)
+    try: st.toast(msg)
+    except Exception: st.info(msg)
 
 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
+    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
+    except Exception: pass
     return None
 
 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 ""
 
 # =========================
-# Model availability (download on cloud if needed)
+# Model presence (local or optional download)
 # =========================
 MODEL_URL = _get_model_url()
 
 def ensure_model_present() -> Path:
-    """Return a local model path, trying local files first, then (optionally) downloading with timeout."""
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
         if p.exists() and p.stat().st_size > 0:
             return p
@@ -196,9 +175,8 @@ def ensure_model_present() -> Path:
             with requests.get(MODEL_URL, stream=True, timeout=30) as r:
                 r.raise_for_status()
                 with open(DEFAULT_MODEL, "wb") as f:
-                    for chunk in r.iter_content(chunk_size=1 << 20):
-                        if chunk:
-                            f.write(chunk)
+                    for chunk in r.iter_content(chunk_size=1<<20):
+                        if chunk: f.write(chunk)
         return DEFAULT_MODEL
     except Exception as e:
         st.error(f"Failed to download model from MODEL_URL: {e}")
@@ -220,24 +198,25 @@ 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)
-    except Exception:
-        pass
+        FEATURES = meta.get("features", FEATURES); TARGET = meta.get("target", TARGET)
+    except Exception: pass
 else:
     infer = infer_features_from_model(model)
-    if infer:
-        FEATURES = infer
+    if infer: FEATURES = infer
 
 # =========================
 # Session state
 # =========================
-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
+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
+# Track when dev run has completed at least once (for enabling the Proceed button immediately)
+if "dev_ready" not in st.session_state:
+    st.session_state.dev_ready = False
+
+# If results already exist (page refresh) mark ready
+if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
+    st.session_state.dev_ready = True
 
 # =========================
 # Hero header (logo + title)
@@ -261,8 +240,7 @@ st.markdown(
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
     st.markdown(
-        "This software is developed by *Smart Thinking AI-Solutions Team* "
-        "to predict the UCS of the underlying formations while drilling using the drilling data."
+        "This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data."
     )
     st.subheader("Required Input Columns")
     st.markdown(
@@ -274,55 +252,50 @@ if st.session_state.app_step == "intro":
     )
     st.subheader("How It Works")
     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 *Proceed to Prediction* and upload a new dataset to get predictions.\n"
-        "4. *Export* everything to Excel for further analysis."
+        "1. **Upload your development data (Excel)** and click **Run Model** to compute metrics and review plots.  \n"
+        "2. Click **Proceed to Prediction** to upload a new dataset for validation and view results.  \n"
+        "3. Export results to Excel at any time."
     )
     if st.button("Start Showcase", type="primary", key="start_showcase"):
-        st.session_state.app_step = "dev"
-        st.rerun()
+        st.session_state.app_step = "dev"; st.rerun()
 
 # =========================
 # MODEL DEVELOPMENT (Train/Test)
 # =========================
 if st.session_state.app_step == "dev":
     st.sidebar.header("Model Development Data")
-    train_test_file = st.sidebar.file_uploader("Upload Data (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)
+    run_btn = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+
+    # Proceed button BELOW run, always visible; enables immediately after first successful run
     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,
+        disabled=not st.session_state.dev_ready,
+        on_click=(lambda: st.session_state.update(app_step="predict")) if st.session_state.dev_ready else None,
     )
 
-    run_btn = st.sidebar.button("Run Model", type="primary", use_container_width=True)
+    st.caption("Upload your data to train the model and review the development performance.")
 
     st.subheader("Model Development")
     if run_btn and train_test_file is not None:
         with st.status("Processing…", expanded=False) as status:
             book = read_book(train_test_file)
-            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 ✓")
 
-            # 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"])
+            # Internally still expect Train/Test sheets
+            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()
+                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()
 
-            status.update(label="Columns validated ✓")
-            status.update(label="Predicting…")
+            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])
@@ -342,7 +315,9 @@ if st.session_state.app_step == "dev":
             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}
 
+            st.session_state.dev_ready = True  # enable Proceed button immediately
             status.update(label="Done ✓", state="complete"); toast("Model run complete 🚀")
+            st.rerun()  # refresh to enable the sidebar button without a second click
 
     if ("Train" in st.session_state.results) or ("Test" in st.session_state.results):
         tab1, tab2 = st.tabs(["Training", "Testing"])
@@ -350,27 +325,24 @@ if st.session_state.app_step == "dev":
             with tab1:
                 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}")
+                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([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)
+                    # no title on the track (cleaner)
+                    st.pyplot(depth_or_index_track(df, title=None, 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)
-                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['R2']:.4f}"); c2.metric("RMSE", f"{m['RMSE']:.4f}"); c3.metric("MAE", f"{m['MAE']:.4f}")
                 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.pyplot(depth_or_index_track(df, title=None, include_actual=True), use_container_width=True)
 
         st.markdown("---")
         sheets = {}; rows = []
@@ -383,7 +355,7 @@ if st.session_state.app_step == "dev":
         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",
+            st.download_button("Export Development Results to Excel",
                 data=data_bytes, file_name="UCS_Dev_Results.xlsx",
                 mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
         except RuntimeError as e:
@@ -399,7 +371,7 @@ if st.session_state.app_step == "predict":
     st.sidebar.button("⬅ Back", on_click=lambda: st.session_state.update(app_step="dev"), use_container_width=True)
 
     st.subheader("Prediction")
-    st.write("Upload a new dataset to get UCS predictions and see how the model performs on new data.")
+    st.write("Upload a new dataset to generate UCS predictions and evaluate performance on unseen data.")
 
     if predict_btn and validation_file is not None:
         with st.status("Predicting…", expanded=False) as status:
@@ -452,7 +424,7 @@ if st.session_state.app_step == "predict":
             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"], title=None, 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)