Update app.py

app.py

@@ -1,3 +1,4 @@
+# app.py — ST_GR (Gamma Ray) app adapted from your UCS app, same flow & design
 import io, json, os, base64, math
 from pathlib import Path
 import streamlit as st
@@ -15,90 +16,72 @@ import plotly.graph_objects as go
 from sklearn.metrics import mean_squared_error, mean_absolute_error
 
 # =========================
-# Constants
+# Constants (GR)
 # =========================
-FEATURES = ["Q, gpm", "SPP(psi)", "T (kft.lbf)", "WOB (klbf)", "ROP (ft/h)"]
-TARGET = "UCS"
+APP_NAME = "ST_GR"
+TAGLINE  = "Gamma Ray Prediction"
+# If meta.json is present, these will be overridden
+FEATURES = ["Feat1","Feat2","Feat3","Feat4","Feat5","Feat6"]   # 6 inputs (placeholder; meta.json wins)
+TARGET   = "log_GR"   # typical training target; meta.json wins
+TARGET_TRANSFORM = "log10"  # "log10" | "ln" | "none" (meta.json wins)
+ACTUAL_COL = "GR"     # if present in sheets; if not, we'll derive from TARGET + transform
+
 MODELS_DIR = Path("models")
-DEFAULT_MODEL = MODELS_DIR / "ucs_rf.joblib"
+DEFAULT_MODEL = MODELS_DIR / "gr_rf.joblib"
 MODEL_FALLBACKS = [MODELS_DIR / "model.joblib", MODELS_DIR / "model.pkl"]
+
 COLORS = {"pred": "#1f77b4", "actual": "#f2b702", "ref": "#5a5a5a"}
 
 # ---- Plot sizing controls ----
-CROSS_W = 350 # px (matplotlib figure size; Streamlit will still scale)
+CROSS_W = 350    # px (matplotlib figure size; Streamlit will still scale)
 CROSS_H = 350
-TRACK_H = 1000 # px (plotly height; width auto-fits column)
-# NEW: Add a TRACK_W variable to control the width
-TRACK_W = 500 # px (plotly width)
-FONT_SZ = 13
-BOLD_FONT = "Arial Black, Arial, sans-serif" # used for bold axis titles & ticks
+TRACK_H = 1000   # px (plotly height)
+TRACK_W = 500    # px (plotly width)
+FONT_SZ  = 13
+BOLD_FONT = "Arial Black, Arial, sans-serif"
 
 # =========================
 # Page / CSS
 # =========================
-st.set_page_config(page_title="ST_GeoMech_UCS", page_icon="logo.png", layout="wide")
+st.set_page_config(page_title=APP_NAME, page_icon="logo.png", layout="wide")
 
-# General CSS (logo helpers etc.)
+# General CSS
 st.markdown("""
 <style>
  .brand-logo { width: 200px; height: auto; object-fit: contain; }
  .sidebar-header { display:flex; align-items:center; gap:12px; }
  .sidebar-header .text h1 { font-size: 1.05rem; margin:0; line-height:1.1; }
  .sidebar-header .text .tag { font-size: .85rem; color:#6b7280; margin:2px 0 0; }
- .centered-container {
-   display: flex;
-   flex-direction: column;
-   align-items: center;
-   text-align: center;
- }
+ .centered-container { display:flex; flex-direction:column; align-items:center; text-align:center; }
 </style>
 """, unsafe_allow_html=True)
 
-# CSS to make sticky headers work correctly by overriding Streamlit's overflow property
+# Allow sticky bits (preview expander header & tabs)
 st.markdown("""
 <style>
-/* This targets the main content area */
-.main .block-container {
-    overflow: unset !important;
-}
-
-/* This targets the vertical block that holds all your elements */
-div[data-testid="stVerticalBlock"] {
-    overflow: unset !important;
-}
+.main .block-container { overflow: unset !important; }
+div[data-testid="stVerticalBlock"] { overflow: unset !important; }
 </style>
 """, unsafe_allow_html=True)
 
 # Hide uploader helper text ("Drag and drop file here", limits, etc.)
 st.markdown("""
 <style>
-/* Older builds (helper wrapped in a Markdown container) */
 section[data-testid="stFileUploader"] div[data-testid="stMarkdownContainer"]{display:none !important;}
-/* 1.31–1.34: helper is the first child in the dropzone */
 section[data-testid="stFileUploader"] [data-testid="stFileUploaderDropzone"] > div:first-child{display:none !important;}
-/* 1.35+: explicit helper container */
 section[data-testid="stFileUploader"] [data-testid="stFileUploaderInstructions"]{display:none !important;}
-/* Fallback: any paragraph/small text inside the uploader */
 section[data-testid="stFileUploader"] p, section[data-testid="stFileUploader"] small{display:none !important;}
 </style>
 """, unsafe_allow_html=True)
 
-# Make the Preview expander title & tabs sticky (pinned to the top)
+# Sticky Preview expander & its tabs
 st.markdown("""
 <style>
 div[data-testid="stExpander"] > details > summary {
- position: sticky;
- top: 0;
- z-index: 10;
- background: #fff;
- border-bottom: 1px solid #eee;
+ position: sticky; top: 0; z-index: 10; background: #fff; border-bottom: 1px solid #eee;
 }
 div[data-testid="stExpander"] div[data-baseweb="tab-list"] {
- position: sticky;
- top: 42px;    /* adjust if your expander header height differs */
- z-index: 9;
- background: #fff;
- padding-top: 6px;
+ position: sticky; top: 42px; z-index: 9; background: #fff; padding-top: 6px;
 }
 </style>
 """, unsafe_allow_html=True)
@@ -109,31 +92,13 @@ TABLE_CENTER_CSS = [
     dict(selector="td", props=[("text-align", "center")]),
 ]
 
-# NEW: CSS for the message box
+# Message box styles
 st.markdown("""
 <style>
-.st-message-box {
-    background-color: #f0f2f6;
-    color: #333333;
-    padding: 10px;
-    border-radius: 10px;
-    border: 1px solid #e6e9ef;
-}
-.st-message-box.st-success {
-    background-color: #d4edda;
-    color: #155724;
-    border-color: #c3e6cb;
-}
-.st-message-box.st-warning {
-    background-color: #fff3cd;
-    color: #856404;
-    border-color: #ffeeba;
-}
-.st-message-box.st-error {
-    background-color: #f8d7da;
-    color: #721c24;
-    border-color: #f5c6cb;
-}
+.st-message-box { background:#f0f2f6; color:#333; padding:10px; border-radius:10px; border:1px solid #e6e9ef; }
+.st-message-box.st-success { background:#d4edda; color:#155724; border-color:#c3e6cb; }
+.st-message-box.st-warning { background:#fff3cd; color:#856404; border-color:#ffeeba; }
+.st-message-box.st-error { background:#f8d7da; color:#721c24; border-color:#f5c6cb; }
 </style>
 """, unsafe_allow_html=True)
 
@@ -164,7 +129,7 @@ def add_password_gate() -> None:
     st.sidebar.markdown(f"""
         <div class="centered-container">
             <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-            <div style='font-weight:800;font-size:1.2rem; margin-top: 10px;'>ST_GeoMech_UCS</div>
+            <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
             <div style='color:#667085;'>Smart Thinking • Secure Access</div>
         </div>
         """, unsafe_allow_html=True
@@ -217,11 +182,10 @@ 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:
+def _nice_tick0(xmin: float, step: int = 5) -> float:
     return step * math.floor(xmin / step) if np.isfinite(xmin) else xmin
 
 def df_centered_rounded(df: pd.DataFrame, hide_index=True):
-    """Center headers & cells; format numeric columns to 2 decimals."""
     out = df.copy()
     numcols = out.select_dtypes(include=[np.number]).columns
     styler = (
@@ -232,15 +196,57 @@ def df_centered_rounded(df: pd.DataFrame, hide_index=True):
     )
     st.dataframe(styler, use_container_width=True, hide_index=hide_index)
 
-# =========================
-# Cross plot (Matplotlib, fixed limits & ticks)
-# =========================
+# --- target transform helpers (to support models trained on log(GR)) ---
+def inverse_target(x: np.ndarray, transform: str) -> np.ndarray:
+    t = (transform or "none").lower()
+    if t in ["log10", "log_10", "log10()"]:
+        return np.power(10.0, x)
+    if t in ["ln", "log", "log_e", "natural"]:
+        return np.exp(x)
+    return x  # "none"
+
+def to_actual_series(df: pd.DataFrame, target_col: str, actual_col_hint: str, transform: str) -> pd.Series:
+    """
+    Return the 'actual GR' series (API).
+    If an explicit actual column exists, use it; else invert the target.
+    """
+    if actual_col_hint and actual_col_hint in df.columns:
+        return pd.Series(df[actual_col_hint], dtype=float)
+    # else, if target exists, invert:
+    if target_col in df.columns:
+        return pd.Series(inverse_target(np.asarray(df[target_col], dtype=float), transform), dtype=float)
+    # fallback: if a column named "GR" exists, use it
+    if "GR" in df.columns:
+        return pd.Series(df["GR"], dtype=float)
+    raise ValueError("Cannot find actual GR column or target to invert.")
+
+# =========================
+# Cross plot (Matplotlib) — auto limits for GR
+# =========================
+def _nice_bounds(arr_min, arr_max, n_ticks=5):
+    # pick a "nice" range and step for GR (typically 0–200+ API)
+    if not np.isfinite(arr_min) or not np.isfinite(arr_max):
+        return 0.0, 100.0, 20.0
+    span = arr_max - arr_min
+    if span <= 0:
+        return max(arr_min-5, 0), arr_max+5, 5.0
+    raw_step = span / max(n_ticks, 1)
+    mag = 10 ** math.floor(math.log10(raw_step))
+    steps = np.array([1, 2, 2.5, 5, 10]) * mag
+    step = steps[np.argmin(np.abs(steps - raw_step))]
+    lo = step * math.floor(arr_min / step)
+    hi = step * math.ceil(arr_max / step)
+    return float(lo), float(hi), float(step)
+
 def cross_plot_static(actual, pred):
     a = pd.Series(actual, dtype=float)
-    p = pd.Series(pred, dtype=float)
+    p = pd.Series(pred,   dtype=float)
 
-    fixed_min, fixed_max = 6000, 10000
-    ticks = np.arange(fixed_min, fixed_max + 1, 1000)
+    # auto bounds & ticks for GR
+    lo = min(a.min(), p.min())
+    hi = max(a.max(), p.max())
+    fixed_min, fixed_max, step = _nice_bounds(lo, hi, n_ticks=6)
+    ticks = np.arange(fixed_min, fixed_max + step, step)
 
     dpi = 110
     fig, ax = plt.subplots(
@@ -257,15 +263,15 @@ def cross_plot_static(actual, pred):
     ax.set_ylim(fixed_min, fixed_max)
     ax.set_xticks(ticks)
     ax.set_yticks(ticks)
-    ax.set_aspect("equal", adjustable="box") # true 45°
+    ax.set_aspect("equal", adjustable="box")  # true 1:1
 
     fmt = FuncFormatter(lambda x, _: f"{int(x):,}")
     ax.xaxis.set_major_formatter(fmt)
     ax.yaxis.set_major_formatter(fmt)
 
-    ax.set_xlabel("Actual UCS (psi)", fontweight="bold", fontsize=10, color="black")
-    ax.set_ylabel("Predicted UCS (psi)", fontweight="bold", fontsize=10, color="black")
-    ax.tick_params(labelsize=6, colors="black")
+    ax.set_xlabel("Actual GR (API)",     fontweight="bold", fontsize=10, color="black")
+    ax.set_ylabel("Predicted GR (API)",  fontweight="bold", fontsize=10, color="black")
+    ax.tick_params(labelsize=8, colors="black")
 
     ax.grid(True, linestyle=":", alpha=0.3)
     for spine in ax.spines.values():
@@ -278,45 +284,43 @@ def cross_plot_static(actual, pred):
 # =========================
 # Track plot (Plotly)
 # =========================
-def track_plot(df, include_actual=True):
+def track_plot(df, include_actual=True, pred_col="GR_Pred", actual_col="GR"):
     depth_col = next((c for c in df.columns if 'depth' in str(c).lower()), None)
     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
+        y_range = [float(y.max()), float(y.min())]  # reverse for logs
     else:
         y = pd.Series(np.arange(1, len(df) + 1))
         ylab = "Point Index"
         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 (GR) range & ticks
+    x_series = pd.Series(df.get(pred_col, pd.Series(dtype=float))).astype(float)
+    if include_actual and actual_col in df.columns:
+        x_series = pd.concat([x_series, pd.Series(df[actual_col]).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)
+    tick0 = _nice_tick0(xmin, step=5)
 
     fig = go.Figure()
     fig.add_trace(go.Scatter(
-        x=df["UCS_Pred"], y=y, mode="lines",
+        x=df[pred_col], 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="GR_Pred",
+        hovertemplate="GR_Pred: %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
     ))
-    if include_actual and TARGET in df.columns:
+    if include_actual and actual_col in df.columns:
         fig.add_trace(go.Scatter(
-            x=df[TARGET], y=y, mode="lines",
+            x=df[actual_col], 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="GR (actual)",
+            hovertemplate="GR (actual): %{x:.0f}<br>"+ylab+": %{y}<extra></extra>"
         ))
 
     fig.update_layout(
-        height=TRACK_H,
-        width=TRACK_W, # Set the width here
-        autosize=False, # Disable autosizing to respect the width
+        height=TRACK_H, width=TRACK_W, autosize=False,
         paper_bgcolor="#fff", plot_bgcolor="#fff",
         margin=dict(l=64, r=16, t=36, b=48), hovermode="closest",
         font=dict(size=FONT_SZ, color="#000"),
@@ -326,31 +330,23 @@ def track_plot(df, include_actual=True):
         ),
         legend_title_text=""
     )
-
-    # Bold, black axis titles & ticks
     fig.update_xaxes(
-        title_text="UCS (psi)",
+        title_text="GR (API)",
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
-        side="top",
-        range=[xmin, xmax],
-        ticks="outside",
-        tickformat=",.0f",
-        tickmode="auto",
-        tick0=tick0,
+        side="top", range=[xmin, xmax],
+        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=ylab,
+        title_text=f"{ylab}",
         title_font=dict(size=20, family=BOLD_FONT, color="#000"),
         tickfont=dict(size=15, family=BOLD_FONT, color="#000"),
-        range=y_range,
-        ticks="outside",
+        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) ----------
@@ -384,25 +380,8 @@ except AttributeError:
             return wrapper
         return deco
 
-def preview_modal(book: dict[str, pd.DataFrame]):
-    if not book:
-        st.info("No data loaded yet."); return
-    names = list(book.keys())
-    tabs = st.tabs(names)
-    for t, name in zip(tabs, names):
-        with t:
-            df = book[name]
-            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"}))
-                df_centered_rounded(tbl.reset_index(names="Feature"))
-
 # =========================
-# Load model
+# Load model + meta
 # =========================
 def ensure_model() -> Path|None:
     for p in [DEFAULT_MODEL, *MODEL_FALLBACKS]:
@@ -423,7 +402,7 @@ def ensure_model() -> Path|None:
 
 mpath = ensure_model()
 if not mpath:
-    st.error("Model not found. Upload models/ucs_rf.joblib (or set MODEL_URL).")
+    st.error("Model not found. Upload models/gr_rf.joblib (or set MODEL_URL).")
     st.stop()
 try:
     model = load_model(str(mpath))
@@ -435,7 +414,10 @@ 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)
+        FEATURES         = meta.get("features", FEATURES)
+        TARGET           = meta.get("target", TARGET)
+        TARGET_TRANSFORM = meta.get("target_transform", TARGET_TRANSFORM)
+        ACTUAL_COL       = meta.get("actual_col", ACTUAL_COL)
     except Exception:
         pass
 
@@ -449,7 +431,7 @@ st.session_state.setdefault("dev_file_name","")
 st.session_state.setdefault("dev_file_bytes",b"")
 st.session_state.setdefault("dev_file_loaded",False)
 st.session_state.setdefault("dev_preview",False)
-st.session_state.setdefault("show_preview_modal", False) # New state variable
+st.session_state.setdefault("show_preview_modal", False)
 
 # =========================
 # Branding in Sidebar
@@ -457,27 +439,20 @@ st.session_state.setdefault("show_preview_modal", False) # New state variable
 st.sidebar.markdown(f"""
     <div class="centered-container">
         <img src="{inline_logo('logo.png')}" style="width: 200px; height: auto; object-fit: contain;">
-        <div style='font-weight:800;font-size:1.2rem;'>ST_GeoMech_UCS</div>
-        <div style='color:#667085;'>Real-Time UCS Tracking While Drilling</div>
+        <div style='font-weight:800;font-size:1.2rem;'>{APP_NAME}</div>
+        <div style='color:#667085;'>{TAGLINE}</div>
     </div>
     """, unsafe_allow_html=True
 )
 
-# =========================
-# Reusable Sticky Header Function
-# =========================
+# Reusable sticky header
 def sticky_header(title, message):
     st.markdown(
         f"""
         <style>
         .sticky-container {{
-            position: sticky;
-            top: 0;
-            background-color: white;
-            z-index: 100;
-            padding-top: 10px;
-            padding-bottom: 10px;
-            border-bottom: 1px solid #eee;
+            position: sticky; top: 0; background-color: white; z-index: 100;
+            padding-top: 10px; padding-bottom: 10px; border-bottom: 1px solid #eee;
         }}
         </style>
         <div class="sticky-container">
@@ -493,12 +468,12 @@ def sticky_header(title, message):
 # =========================
 if st.session_state.app_step == "intro":
     st.header("Welcome!")
-    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate UCS from drilling data.")
+    st.markdown("This software is developed by *Smart Thinking AI-Solutions Team* to estimate Gamma Ray (GR) from input features.")
     st.subheader("How It Works")
     st.markdown(
-        "1) **Upload your data to build the case and preview the performance of our model.** \n"
-        "2) Click **Run Model** to compute metrics and plots. \n"
-        "3) **Proceed to Validation** (with actual UCS) or **Proceed to Prediction** (no UCS)."
+        "1) **Upload your data to build the case and preview the performance of our model.**  \n"
+        "2) Click **Run Model** to compute metrics and plots.  \n"
+        "3) **Proceed to Validation** (with actual GR) or **Proceed to Prediction** (no GR)."
     )
     if st.button("Start Showcase", type="primary"):
         st.session_state.app_step = "dev"; st.rerun()
@@ -521,14 +496,14 @@ if st.session_state.app_step == "dev":
             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):
-        st.session_state.show_preview_modal = True # Set state to show modal
+        st.session_state.show_preview_modal = True
         st.session_state.dev_preview = True
 
     run = st.sidebar.button("Run Model", type="primary", use_container_width=True)
     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()
 
-    # Apply sticky header
+    # Sticky helper
     if st.session_state.dev_file_loaded and st.session_state.dev_preview:
         sticky_header("Case Building", "Previewed ✓ — now click **Run Model**.")
     elif st.session_state.dev_file_loaded:
@@ -539,27 +514,34 @@ if st.session_state.app_step == "dev":
     if run and st.session_state.dev_file_bytes:
         book = read_book_bytes(st.session_state.dev_file_bytes)
         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:
-            st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training/training2 and Test/Testing/testing2 sheets.</div>', unsafe_allow_html=True)
+            st.markdown('<div class="st-message-box st-error">Workbook must include Train/Training and Test/Testing sheets.</div>', unsafe_allow_html=True)
             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.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True)
-            st.stop()
-        tr["UCS_Pred"] = model.predict(tr[FEATURES])
-        te["UCS_Pred"] = model.predict(te[FEATURES])
+        if not (ensure_cols(tr, FEATURES) and ensure_cols(te, FEATURES)):
+            st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True); st.stop()
+
+        # predictions (handle log targets)
+        tr_pred_raw = model.predict(tr[FEATURES])
+        te_pred_raw = model.predict(te[FEATURES])
+        tr["GR_Pred"] = inverse_target(np.asarray(tr_pred_raw, dtype=float), TARGET_TRANSFORM)
+        te["GR_Pred"] = inverse_target(np.asarray(te_pred_raw, dtype=float), TARGET_TRANSFORM)
+
+        # actual GR (for metrics/plots)
+        tr["GR_Actual"] = to_actual_series(tr, TARGET, ACTUAL_COL, TARGET_TRANSFORM)
+        te["GR_Actual"] = to_actual_series(te, TARGET, ACTUAL_COL, TARGET_TRANSFORM)
 
         st.session_state.results["Train"]=tr; st.session_state.results["Test"]=te
         st.session_state.results["m_train"]={
-            "R": pearson_r(tr[TARGET], tr["UCS_Pred"]),
-            "RMSE": rmse(tr[TARGET], tr["UCS_Pred"]),
-            "MAE": mean_absolute_error(tr[TARGET], tr["UCS_Pred"])
+            "R": pearson_r(tr["GR_Actual"], tr["GR_Pred"]),
+            "RMSE": rmse(tr["GR_Actual"], tr["GR_Pred"]),
+            "MAE": mean_absolute_error(tr["GR_Actual"], tr["GR_Pred"])
         }
         st.session_state.results["m_test"]={
-            "R": pearson_r(te[TARGET], te["UCS_Pred"]),
-            "RMSE": rmse(te[TARGET], te["UCS_Pred"]),
-            "MAE": mean_absolute_error(te[TARGET], te["UCS_Pred"])
+            "R": pearson_r(te["GR_Actual"], te["GR_Pred"]),
+            "RMSE": rmse(te["GR_Actual"], te["GR_Pred"]),
+            "MAE": mean_absolute_error(te["GR_Actual"], te["GR_Pred"])
         }
 
         tr_min = tr[FEATURES].min().to_dict(); tr_max = tr[FEATURES].max().to_dict()
@@ -571,37 +553,34 @@ if st.session_state.app_step == "dev":
         c1.metric("R", f"{m['R']:.2f}")
         c2.metric("RMSE", f"{m['RMSE']:.2f}")
         c3.metric("MAE", f"{m['MAE']:.2f}")
-
-        # NEW: Footer for metric abbreviations
         st.markdown("""
-            <div style='text-align: left; font-size: 0.8em; color: #6b7280; margin-top: -16px; margin-bottom: 8px;'>
+            <div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>
                 <strong>R:</strong> Pearson Correlation Coefficient<br>
                 <strong>RMSE:</strong> Root Mean Square Error<br>
                 <strong>MAE:</strong> Mean Absolute Error
             </div>
         """, unsafe_allow_html=True)
 
-        # 2-column layout, big gap (prevents overlap)
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
             st.plotly_chart(
-                track_plot(df, include_actual=True),
-                use_container_width=False, # Set to False to honor the width in track_plot()
+                track_plot(df.rename(columns={"GR_Actual":"GR"}), include_actual=True,
+                           pred_col="GR_Pred", actual_col="GR"),
+                use_container_width=False,
                 config={"displayModeBar": False, "scrollZoom": True}
             )
         with col_cross:
-            st.pyplot(cross_plot_static(df[TARGET], df["UCS_Pred"]), use_container_width=False)
-
+            st.pyplot(cross_plot_static(df["GR_Actual"], df["GR_Pred"]), use_container_width=False)
 
     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: _dev_block(st.session_state.results["Train"], st.session_state.results["m_train"])
         if "Test" in st.session_state.results:
-            with tab2: _dev_block(st.session_state.results["Test"], st.session_state.results["m_test"])
+            with tab2: _dev_block(st.session_state.results["Test"],  st.session_state.results["m_test"])
 
 # =========================
-# VALIDATION (with actual UCS)
+# VALIDATION (with actual GR)
 # =========================
 if st.session_state.app_step == "validate":
     st.sidebar.header("Validate the Model")
@@ -612,19 +591,27 @@ if st.session_state.app_step == "validate":
             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)):
-        st.session_state.show_preview_modal = True # Set state to show modal
+        st.session_state.show_preview_modal = True
     go_btn = st.sidebar.button("Predict & Validate", 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()
 
-    sticky_header("Validate the Model", "Upload a dataset with the same **features** and **UCS** to evaluate performance.")
+    sticky_header("Validate the Model", "Upload a dataset with the same **features** and **GR** 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.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
-        df["UCS_Pred"] = model.predict(df[FEATURES])
+        if not ensure_cols(df, FEATURES): st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True); st.stop()
+
+        pred_raw = model.predict(df[FEATURES])
+        df["GR_Pred"] = inverse_target(np.asarray(pred_raw, dtype=float), TARGET_TRANSFORM)
+        # actual GR
+        try:
+            df["GR_Actual"] = to_actual_series(df, TARGET, ACTUAL_COL, TARGET_TRANSFORM)
+        except Exception:
+            st.markdown('<div class="st-message-box st-error">Validation sheet must include actual GR (or a target column that can be inverse-transformed).</div>', unsafe_allow_html=True); st.stop()
+
         st.session_state.results["Validate"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0; tbl=None
@@ -636,12 +623,13 @@ if st.session_state.app_step == "validate":
                 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": pearson_r(df[TARGET], df["UCS_Pred"]),
-            "RMSE": rmse(df[TARGET], df["UCS_Pred"]),
-            "MAE": mean_absolute_error(df[TARGET], df["UCS_Pred"])
+            "R": pearson_r(df["GR_Actual"], df["GR_Pred"]),
+            "RMSE": rmse(df["GR_Actual"], df["GR_Pred"]),
+            "MAE": mean_absolute_error(df["GR_Actual"], df["GR_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["GR_Pred"].min()),"pred_max":float(df["GR_Pred"].max()),"oor":oor_pct}
         st.session_state.results["oor_tbl"]=tbl
 
     if "Validate" in st.session_state.results:
@@ -650,27 +638,25 @@ if st.session_state.app_step == "validate":
         c1.metric("R", f"{m['R']:.2f}")
         c2.metric("RMSE", f"{m['RMSE']:.2f}")
         c3.metric("MAE", f"{m['MAE']:.2f}")
-
-        # NEW: Footer for metric abbreviations
         st.markdown("""
-            <div style='text-align: left; font-size: 0.8em; color: #6b7280; margin-top: -16px; margin-bottom: 8px;'>
+            <div style='text-align:left;font-size:0.8em;color:#6b7280;margin-top:-16px;margin-bottom:8px;'>
                 <strong>R:</strong> Pearson Correlation Coefficient<br>
                 <strong>RMSE:</strong> Root Mean Square Error<br>
                 <strong>MAE:</strong> Mean Absolute Error
             </div>
         """, unsafe_allow_html=True)
-        
+
         col_track, col_cross = st.columns([2, 3], gap="large")
         with col_track:
             st.plotly_chart(
-                track_plot(st.session_state.results["Validate"], include_actual=True),
-                use_container_width=False, # Set to False to honor the width in track_plot()
-                config={"displayModeBar": False, "scrollZoom": True}
+                track_plot(st.session_state.results["Validate"].rename(columns={"GR_Actual":"GR"}),
+                           include_actual=True, pred_col="GR_Pred", actual_col="GR"),
+                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
             )
         with col_cross:
             st.pyplot(
-                cross_plot_static(st.session_state.results["Validate"][TARGET],
-                                  st.session_state.results["Validate"]["UCS_Pred"]),
+                cross_plot_static(st.session_state.results["Validate"]["GR_Actual"],
+                                  st.session_state.results["Validate"]["GR_Pred"]),
                 use_container_width=False
             )
 
@@ -681,10 +667,10 @@ if st.session_state.app_step == "validate":
             df_centered_rounded(st.session_state.results["oor_tbl"])
 
 # =========================
-# PREDICTION (no actual UCS)
+# PREDICTION (no actual GR)
 # =========================
 if st.session_state.app_step == "predict":
-    st.sidebar.header("Prediction (No Actual UCS)")
+    st.sidebar.header("Prediction (No Actual GR)")
     up = st.sidebar.file_uploader("Upload Prediction Excel", type=["xlsx","xls"])
     if up is not None:
         book = read_book_bytes(up.getvalue())
@@ -692,17 +678,19 @@ if st.session_state.app_step == "predict":
             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)):
-        st.session_state.show_preview_modal = True # Set state to show modal
+        st.session_state.show_preview_modal = True
     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()
 
-    sticky_header("Prediction", "Upload a dataset with the feature columns (no **UCS**).")
+    sticky_header("Prediction", "Upload a dataset with the feature columns (no **GR**).")
 
     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.markdown('<div class="st-message-box st-error">Missing required columns.</div>', unsafe_allow_html=True); st.stop()
-        df["UCS_Pred"] = model.predict(df[FEATURES])
+        if not ensure_cols(df, FEATURES): st.markdown('<div class="st-message-box st-error">Missing required feature columns.</div>', unsafe_allow_html=True); st.stop()
+
+        pred_raw = model.predict(df[FEATURES])
+        df["GR_Pred"] = inverse_target(np.asarray(pred_raw, dtype=float), TARGET_TRANSFORM)
         st.session_state.results["PredictOnly"]=df
 
         ranges = st.session_state.train_ranges; oor_pct = 0.0
@@ -711,10 +699,10 @@ 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["GR_Pred"].min()),
+            "pred_max":float(df["GR_Pred"].max()),
+            "pred_mean":float(df["GR_Pred"].mean()),
+            "pred_std":float(df["GR_Pred"].std(ddof=0)),
             "oor":oor_pct
         }
 
@@ -725,28 +713,27 @@ if st.session_state.app_step == "predict":
         with col_left:
             table = pd.DataFrame({
                 "Metric": ["# points","Pred min","Pred max","Pred mean","Pred std","OOR %"],
-                "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}%']
+                "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.markdown('<div class="st-message-box st-success">Predictions ready ✓</div>', unsafe_allow_html=True)
             df_centered_rounded(table, hide_index=True)
             st.caption("**★ OOR** = % of rows whose input features fall outside the training min–max range.")
         with col_right:
             st.plotly_chart(
-                track_plot(df, include_actual=False),
-                use_container_width=False, # Set to False to honor the width in track_plot()
-                config={"displayModeBar": False, "scrollZoom": True}
+                track_plot(df.rename(columns={"GR_Pred":"GR_Pred"}), include_actual=False,
+                           pred_col="GR_Pred", actual_col="GR"),
+                use_container_width=False, config={"displayModeBar": False, "scrollZoom": True}
             )
 
 # =========================
-# Run preview modal after all other elements
+# Preview modal (re-usable)
 # =========================
 if st.session_state.show_preview_modal:
-    # Get the correct book based on the current app step
     book_to_preview = {}
     if st.session_state.app_step == "dev":
         book_to_preview = read_book_bytes(st.session_state.dev_file_bytes)
@@ -770,9 +757,7 @@ if st.session_state.show_preview_modal:
                                  .agg(['min','max','mean','std'])
                                  .T.rename(columns={"min":"Min","max":"Max","mean":"Mean","std":"Std"}))
                         df_centered_rounded(tbl.reset_index(names="Feature"))
-    # Reset the state variable after the modal is displayed
     st.session_state.show_preview_modal = False
-
 # =========================
 # Footer
 # =========================
@@ -780,6 +765,7 @@ st.markdown("""
 <br><br><br>
 <hr>
 <div style='text-align:center;color:#6b7280;font-size:0.8em;'>
-    © 2024 Smart Thinking AI-Solutions Team. All rights reserved.
+    © 2024 Smart Thinking AI-Solutions Team. All rights reserved.<br>
+    Contact: smartthinking@smartthinking.com.sa
 </div>
 """, unsafe_allow_html=True)