Update app.py

app.py

@@ -25,10 +25,11 @@ MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
 
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
-# exact pixel sizes (no container stretching)
-CROSS_W = 420; CROSS_H = 420    # square cross-plot
-TRACK_W = 220; TRACK_H = 700    # match preview strip
+# ---- Plot sizing controls (edit here) ----
+CROSS_W = 520; CROSS_H = 520      # square cross-plot
+TRACK_W = 260; TRACK_H = 950      # log-strip style (tall, slightly wider)
 FONT_SZ = 13
+PLOT_COLS = [10, 3, 10]           # 3-column band: left • spacer • right
 
 # =========================
 # Page / CSS
@@ -48,6 +49,14 @@ st.markdown(
       .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; }
+
+      /* sticky helper notice */
+      .helper-sticky { position: sticky; top: 64px; z-index: 50; }
+      .helper-sticky .box {
+        border-radius: 8px; padding: 12px 14px; margin: 6px 0 10px 0; font-size: 0.98rem;
+      }
+      .helper-sticky .info    { background:#eaf2ff; border:1px solid #c9defa; color:#0b4aa2; }
+      .helper-sticky .success { background:#eaf7ea; border:1px solid #c7e8c8; color:#1b6e22; }
     </style>
     """,
     unsafe_allow_html=True
@@ -145,7 +154,14 @@ def parse_excel(data_bytes: bytes):
     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 ensure_cols(df, cols): return not [c for c in cols if c not in df.columns] or False
+
+def ensure_cols(df, cols):
+    miss = [c for c in cols if c not in df.columns]
+    if miss:
+        st.error(f"Missing columns: {miss}")
+        return False
+    return True
+
 def find_sheet(book, names):
     low2orig = {k.lower(): k for k in book.keys()}
     for nm in names:
@@ -175,14 +191,14 @@ def cross_plot(actual, pred):
     ))
     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",
+        margin=dict(l=64, r=18, t=8, b=48), hovermode="closest",
         font=dict(size=FONT_SZ)
     )
-    fig.update_xaxes(title_text="<b>Actual UCS</b>", range=[x0, x1],
+    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</b>", range=[x0, x1],
+    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)
@@ -197,30 +213,30 @@ def track_plot(df, include_actual=True):
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
-        x=df["UCS_Pred"], y=y, mode="lines",
+        x=df["UCS_Pred, psi"], 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>"
+        name="UCS_Pred, psi",
+        hovertemplate="UCS_Pred, psi: %{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>"
+            name="UCS (actual), psi",
+            hovertemplate="UCS (actual), psi: %{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",
+        margin=dict(l=72, r=18, t=30, b=48), hovermode="closest",
         font=dict(size=FONT_SZ),
         legend=dict(
             x=0.98, y=0.05, xanchor="right", yanchor="bottom",
-            bgcolor="rgba(255,255,255,0.75)", bordercolor="#ccc", borderwidth=1
+            bgcolor="rgba(255,255,255,0.78)", bordercolor="#ccc", borderwidth=1
         ),
         legend_title_text=""
     )
-    fig.update_xaxes(title_text="<b>UCS</b>", side="top",
+    fig.update_xaxes(title_text="<b>UCS, psi</b>", side="top",
                      ticks="outside", tickformat=",.0f",
                      showline=True, linewidth=1.2, linecolor="#444", mirror=True, showgrid=True, gridcolor="rgba(0,0,0,0.12)",
                      automargin=True)
@@ -315,6 +331,13 @@ for k, v in {
 }.items():
     st.session_state.setdefault(k, v)
 
+# helper notice anchor (sticky)
+def make_notice():
+    anchor = st.empty()
+    def info(msg_html):    anchor.markdown(f"<div class='helper-sticky'><div class='box info'>{msg_html}</div></div>", unsafe_allow_html=True)
+    def success(msg_html): anchor.markdown(f"<div class='helper-sticky'><div class='box success'>{msg_html}</div></div>", unsafe_allow_html=True)
+    return info, success
+
 # =========================
 # Hero
 # =========================
@@ -331,6 +354,9 @@ st.markdown(
     unsafe_allow_html=True,
 )
 
+# reuse plot config
+PLOT_CFG = {"displayModeBar": False, "scrollZoom": True}
+
 # =========================
 # INTRO
 # =========================
@@ -368,17 +394,19 @@ 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
     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()
 
+    info, success = make_notice()
     st.subheader("Case Building (Development)")
-    if st.session_state.dev_file_loaded and st.session_state.dev_preview:
-        st.info("Previewed ✓ — now click **Run Model**.")
+    if "Train" in st.session_state.results or "Test" in st.session_state.results:
+        success("Case has been built and results are displayed below.")
+    elif st.session_state.dev_file_loaded and st.session_state.dev_preview:
+        info("Previewed ✓ — now click <b>Run Model</b>.")
     elif st.session_state.dev_file_loaded:
-        st.info("📄 **Preview uploaded data** using the sidebar button, then click **Run Model**.")
+        info("📄 <b>Preview uploaded data</b> using the sidebar button, then click <b>Run Model</b>.")
     else:
-        st.write("**Upload your data to build a case, then run the model to review development performance.**")
+        info("<b>Upload your data</b> 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)
@@ -387,18 +415,17 @@ if st.session_state.app_step == "dev":
         if sh_train is None or sh_test is None:
             st.error("Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets."); st.stop()
         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])
+        if not (ensure_cols(tr, FEATURES+[TARGET]) and ensure_cols(te, FEATURES+[TARGET])): st.stop()
+        tr["UCS_Pred, psi"] = model.predict(tr[FEATURES])
+        te["UCS_Pred, psi"] = 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"]={"R2":r2_score(tr[TARGET],tr["UCS_Pred, psi"]), "RMSE":rmse(tr[TARGET],tr["UCS_Pred, psi"]), "MAE":mean_absolute_error(tr[TARGET],tr["UCS_Pred"])}
+        st.session_state.results["m_test"] ={"R2":r2_score(te[TARGET],te["UCS_Pred, psi"]), "RMSE":rmse(te[TARGET],te["UCS_Pred, psi"]), "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}
-        st.success("Case has been built and results are displayed below.")
+        st.rerun()
 
     if "Train" in st.session_state.results or "Test" in st.session_state.results:
         tab1, tab2 = st.tabs(["Training", "Testing"])
@@ -406,13 +433,15 @@ 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}")
-            col_left, col_right = st.columns(2)
-            with col_left:
-                st.plotly_chart(cross_plot(df[TARGET], df["UCS_Pred"]),
-                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
-            with col_right:
+            left, mid, right = st.columns(PLOT_COLS, gap="small")
+            with left:
+                st.plotly_chart(cross_plot(df[TARGET], df["UCS_Pred, psi"]),
+                                use_container_width=False, config=PLOT_CFG)
+            with mid:
+                st.write("")  # spacer
+            with right:
                 st.plotly_chart(track_plot(df, include_actual=True),
-                                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+                                use_container_width=False, config=PLOT_CFG)
 
         if "Train" in st.session_state.results:
             with tab1: dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
@@ -436,15 +465,16 @@ if st.session_state.app_step == "validate":
     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()
 
+    info, success = make_notice()
     st.subheader("Validate the Model")
-    st.write("Upload a dataset with the same **features** and **UCS** to evaluate performance.")
+    info("Upload a dataset with the same <b>features</b> and <b>UCS, psi</b> 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]
         df = book[name].copy()
-        if not ensure_cols(df, FEATURES+[TARGET]): st.error("Missing required columns."); st.stop()
-        df["UCS_Pred"] = model.predict(df[FEATURES])
+        if not ensure_cols(df, FEATURES+[TARGET]): st.stop()
+        df["UCS_Pred, psi"] = model.predict(df[FEATURES])
         st.session_state.results["Validate"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
@@ -454,25 +484,28 @@ 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"]={"R2":r2_score(df[TARGET],df["UCS_Pred, psi"]), "RMSE":rmse(df[TARGET],df["UCS_Pred, psi"]), "MAE":mean_absolute_error(df[TARGET],df["UCS_Pred"])}
+        st.session_state.results["sv_val"]={"n":len(df),"pred_min":float(df["UCS_Pred, psi"].min()),"pred_max":float(df["UCS_Pred, psi"].max()),"oor":oor_pct}
         st.session_state.results["oor_tbl"]=tbl
+        st.rerun()
 
     if "Validate" in st.session_state.results:
         m = st.session_state.results["m_val"]; sv = st.session_state.results["sv_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}")
 
-        col_left, col_right = st.columns(2)
-        with col_left:
+        left, mid, right = st.columns(PLOT_COLS, gap="small")
+        with left:
             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})
-        with col_right:
+                                       st.session_state.results["Validate"]["UCS_Pred, psi"]),
+                            use_container_width=False, config=PLOT_CFG)
+        with mid:
+            st.write("")
+        with right:
             st.plotly_chart(track_plot(st.session_state.results["Validate"], include_actual=True),
-                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+                            use_container_width=False, config=PLOT_CFG)
 
-        if sv["oor"] > 0: st.warning("Some inputs fall outside **training min–max** ranges.")
+        if sv["oor"] > 0: st.warning("Some inputs fall outside <b>training min–max</b> ranges.", icon="⚠️")
         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)
@@ -493,13 +526,14 @@ if st.session_state.app_step == "predict":
     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()
 
+    info, _success = make_notice()
     st.subheader("Prediction")
-    st.write("Upload a dataset with the feature columns (no **UCS**).")
+    info("Upload a dataset with the feature columns (no <b>UCS, psi</b>).")
 
     if go_btn and up is not None:
         book = read_book_bytes(up.getvalue()); name = list(book.keys())[0]
         df = book[name].copy()
-        if not ensure_cols(df, FEATURES): st.error("Missing required columns."); st.stop()
+        if not ensure_cols(df, FEATURES): st.stop()
         df["UCS_Pred"] = model.predict(df[FEATURES])
         st.session_state.results["PredictOnly"]=df
 
@@ -509,18 +543,19 @@ if st.session_state.app_step == "predict":
             oor_pct = float(any_viol.mean()*100.0)
         st.session_state.results["sv_pred"]={
             "n":len(df),
-            "pred_min":float(df["UCS_Pred"].min()),
-            "pred_max":float(df["UCS_Pred"].max()),
-            "pred_mean":float(df["UCS_Pred"].mean()),
-            "pred_std":float(df["UCS_Pred"].std(ddof=0)),
+            "pred_min":float(df["UCS_Pred, psi"].min()),
+            "pred_max":float(df["UCS_Pred, psi"].max()),
+            "pred_mean":float(df["UCS_Pred, psi"].mean()),
+            "pred_std":float(df["UCS_Pred, psi"].std(ddof=0)),
             "oor":oor_pct
         }
+        st.rerun()
 
     if "PredictOnly" in st.session_state.results:
         df = st.session_state.results["PredictOnly"]; sv = st.session_state.results["sv_pred"]
 
-        col_left, col_right = st.columns(2)
-        with col_left:
+        left, mid, right = st.columns(PLOT_COLS, gap="small")
+        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}%']
@@ -528,9 +563,11 @@ if st.session_state.app_step == "predict":
             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 col_right:
+        with mid:
+            st.write("")
+        with right:
             st.plotly_chart(track_plot(df, include_actual=False),
-                            use_container_width=False, config={"displayModeBar": False, "scrollZoom": True})
+                            use_container_width=False, config=PLOT_CFG)
 
 # =========================
 # Footer