Upload 3 files

README.md

@@ -27,10 +27,10 @@ streamlit run app.py
 
 ## Deploy to Hugging Face Spaces
 1. Create a new Space → **SDK: Streamlit**.
-2. Upload `app.py` and `requirements.txt` (and this README if you like).
+2. Upload `app.py`, `requirements.txt`, and this `README.md`.
 3. The Space will build automatically and launch the app.
 
 ## Notes
 - Data is **synthetic** but embeds realistic pricing, discounting, cost, and elasticity signals.
-- SHAP is computed on a sample for responsiveness.
-- Recommendations are illustrative; in production, add policy bounds, portfolio constraints, and cost/promo feasibility tables.
+- SHAP is computed **on demand** with a sample size control for performance.
+- Recommendations are illustrative; in production, add policy bounds, portfolio constraints, and cost/promo feasibility tables.

app.py

@@ -1,3 +1,4 @@
+
 import streamlit as st
 import numpy as np
 import pandas as pd
@@ -20,7 +21,7 @@ st.set_page_config(page_title="AI-Driven Daily Gross Margin", layout="wide")
 # 1) Synthetic data generation
 # -----------------------------
 @st.cache_data(show_spinner=False)
-def generate_synthetic_data(days=90, seed=42, rows_per_day=1200):
+def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
     rng = np.random.default_rng(seed)
     start_date = datetime.today().date() - timedelta(days=days)
     dates = pd.date_range(start_date, periods=days, freq="D")
@@ -82,7 +83,6 @@ def generate_synthetic_data(days=90, seed=42, rows_per_day=1200):
         # Quantity via elasticity around a reference price
         eps = np.array([seg_epsilon[(pp, rr, cc)] for pp, rr, cc in zip(prod, reg, ch)])
         ref_price = np.array([base_price[x] for x in prod])
-        # expected qty relative to ref price
         qty_mu = np.exp(eps * (net_price - ref_price) / np.maximum(ref_price, 1e-6))
         qty = np.maximum(1, rng.poisson(8 * dow_mult * macro * qty_mu))
 
@@ -115,11 +115,9 @@ def generate_synthetic_data(days=90, seed=42, rows_per_day=1200):
 # 2) Modeling utilities
 # -----------------------------
 def build_features(df: pd.DataFrame):
-    # Basic feature set
     feats_num = ["net_price", "unit_cost", "qty", "discount_pct", "list_price", "dow"]
     feats_cat = ["product", "region", "channel"]
 
-    # Rolling features for elasticity/momentum (7D trailing by segment)
     df = df.sort_values("date").copy()
     seg = ["product", "region", "channel"]
     df["price_per_unit"] = df["net_price"]
@@ -134,7 +132,7 @@ def build_features(df: pd.DataFrame):
     return df, feats_num, feats_cat, target
 
 @st.cache_resource(show_spinner=False)
-def train_model(df: pd.DataFrame, feats_num, feats_cat, target):
+def train_model(df: pd.DataFrame, feats_num, feats_cat, target, n_estimators=250):
     X = df[feats_num + feats_cat]
     y = df[target]
 
@@ -144,7 +142,7 @@ def train_model(df: pd.DataFrame, feats_num, feats_cat, target):
             ("num", "passthrough", feats_num),
         ]
     )
-    model = RandomForestRegressor(n_estimators=400, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=2)
+    model = RandomForestRegressor(n_estimators=n_estimators, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=3)
     pipe = Pipeline([("pre", pre), ("rf", model)])
 
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, shuffle=False)
@@ -154,38 +152,43 @@ def train_model(df: pd.DataFrame, feats_num, feats_cat, target):
     r2 = r2_score(y_test, pred)
     mae = mean_absolute_error(y_test, pred)
 
-    # SHAP on a sample for speed
+    # Store components for SHAP later (on-demand)
+    return pipe, {"r2": r2, "mae": mae}, X_test
+
+@st.cache_resource(show_spinner=False)
+def compute_shap(pipe, X_sample, feats_num, feats_cat, shap_sample=800, seed=42):
+    np.random.seed(seed)
     preproc = pipe.named_steps["pre"]
     rf = pipe.named_steps["rf"]
     feature_names = list(preproc.named_transformers_["cat"].get_feature_names_out(feats_cat)) + feats_num
 
-    # transform a reasonable sample size
-    sample_idx = np.random.choice(len(X_test), size=min(2500, len(X_test)), replace=False)
-    X_test_t = preproc.transform(X_test.iloc[sample_idx])
+    if len(X_sample) > shap_sample:
+        sample_idx = np.random.choice(len(X_sample), size=shap_sample, replace=False)
+        X_sample = X_sample.iloc[sample_idx]
+
+    X_t = preproc.transform(X_sample)
+    try:
+        X_t = X_t.toarray()
+    except Exception:
+        pass
+
     explainer = shap.TreeExplainer(rf)
-    shap_values = explainer.shap_values(X_test_t)
+    shap_values = explainer.shap_values(X_t)
     expected_value = explainer.expected_value
 
     shap_df = pd.DataFrame(shap_values, columns=feature_names)
-    # also keep the corresponding original rows for joins
-    X_test_sample = X_test.iloc[sample_idx].reset_index(drop=True)
-
-    return pipe, {"r2": r2, "mae": mae}, feature_names, shap_df, expected_value, X_test_sample
+    return shap_df, expected_value, X_sample.reset_index(drop=True), feature_names
 
 def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
     seg_df = df[(df["product"]==product)&(df["region"]==region)&(df["channel"]==channel)]
-    # Require minimal spread
     if len(seg_df) < 100 or seg_df["net_price"].std() < 1e-6 or seg_df["qty"].std() < 1e-6:
         return -0.5, False
     x = np.log(np.clip(seg_df["net_price"].values, 1e-6, None)).reshape(-1,1)
     y = np.log(np.clip(seg_df["qty"].values, 1e-6, None))
     lin = LinearRegression().fit(x, y)
-    # slope is elasticity (d ln Q / d ln P)
     return float(lin.coef_[0]), True
 
 def simulate_action(segment_df: pd.DataFrame, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
-    # Simulate changing discount (affects price) and unit cost
-    # Use last-day averages as baseline
     if segment_df.empty:
         return None
     base = segment_df.iloc[-1]
@@ -193,12 +196,11 @@ def simulate_action(segment_df: pd.DataFrame, elasticity, delta_discount=0.0, de
     c0 = base["unit_cost"]
     q0 = base["qty"]
     d0 = base["discount_pct"]
-    # Apply action
+
     new_discount = np.clip(d0 + delta_discount, 0.0, 0.45)
     p1 = max(0.01, base["list_price"] * (1 - new_discount))
     c1 = max(0.01, c0 + delta_unit_cost)
 
-    # Volume change via elasticity around p0
     if p0 <= 0:
         q1 = q0
     else:
@@ -229,13 +231,23 @@ st.caption("Synthetic demo: Revenue − COGS focus • Driver analysis with SHAP
 
 with st.sidebar:
     st.header("⚙️ Controls")
-    days = st.slider("History (days)", 45, 180, 90, 1)
-    rows_per_day = st.slider("Rows per day", 300, 3000, 1200, 100)
+    fast_mode = st.toggle("Fast mode (recommended on Spaces)", value=True)
+    if fast_mode:
+        days = st.slider("History (days)", 30, 120, 60, 1)
+        rows_per_day = st.slider("Rows per day", 300, 2000, 600, 100)
+    else:
+        days = st.slider("History (days)", 45, 180, 90, 1)
+        rows_per_day = st.slider("Rows per day", 300, 3000, 1200, 100)
+
     seed = st.number_input("Random seed", value=42, step=1)
     st.markdown("---")
     st.markdown("**Training**")
+    n_trees = st.slider("RandomForest trees", 100, 600, 250 if fast_mode else 400, 50)
     st.caption("Model: RandomForestRegressor (SHAP via TreeExplainer)")
     st.markdown("---")
+    st.markdown("**SHAP computation**")
+    shap_sample = st.slider("SHAP sample size", 200, 3000, 800 if fast_mode else 1800, 100)
+    st.markdown("---")
     st.markdown("**What-if Defaults**")
     default_disc_step = st.slider("Default discount step (points)", -5.0, 5.0, -1.5, 0.1)
     default_cost_step = st.slider("Default unit cost change", -5.0, 5.0, 0.0, 0.1)
@@ -265,50 +277,66 @@ fig.update_yaxes(tickformat=".1%")
 st.plotly_chart(fig, use_container_width=True)
 
 # Train
-with st.spinner("Training model & computing SHAP…"):
-    pipe, metrics, feature_names, shap_df, expected_value, X_test_sample = train_model(df_feat, feats_num, feats_cat, target)
+with st.spinner("Training model…"):
+    pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target, n_estimators=int(n_trees))
 
 st.success(f"Model trained • R²={metrics['r2']:.3f} • MAE={metrics['mae']:.4f} (GM% points)")
 
-# Global driver importance
+# SHAP: compute on demand
 st.subheader("🔍 Driver Analysis (Global)")
-mean_abs = shap_df.abs().mean().sort_values(ascending=False)
-imp_df = pd.DataFrame({"feature": mean_abs.index, "mean_abs_shap": mean_abs.values})
-st.dataframe(imp_df.head(15), use_container_width=True)
-
-# Optional: SHAP bar plot
-fig2, ax = plt.subplots(figsize=(8,5))
-imp_df.head(20).iloc[::-1].plot(kind="barh", x="feature", y="mean_abs_shap", ax=ax)
-ax.set_title("Top Drivers — Mean |SHAP| (GM%)")
-ax.set_xlabel("Mean |SHAP| contribution")
-st.pyplot(fig2, clear_figure=True)
-
-# Segment analysis using net SHAP sign for key features
+if "shap_imp_df" not in st.session_state:
+    st.session_state["shap_imp_df"] = None
+if "shap_joined" not in st.session_state:
+    st.session_state["shap_joined"] = None
+
+compute_now = st.button("Compute / Refresh SHAP drivers")
+if compute_now or st.session_state["shap_imp_df"] is None:
+    with st.spinner("Computing SHAP (sampled)…"):
+        shap_df, expected_value, X_test_sample, feature_names = compute_shap(pipe, X_test, feats_num, feats_cat, shap_sample=int(shap_sample))
+        mean_abs = shap_df.abs().mean().sort_values(ascending=False)
+        imp_df = pd.DataFrame({"feature": mean_abs.index, "mean_abs_shap": mean_abs.values})
+        st.session_state["shap_imp_df"] = imp_df
+        # Keep a joined frame for segment view
+        cat_cols = ["product","region","channel"]
+        joined = pd.concat([X_test_sample.reset_index(drop=True), shap_df.reset_index(drop=True)], axis=1)
+        st.session_state["shap_joined"] = joined
+
+imp_df = st.session_state["shap_imp_df"]
+if imp_df is not None:
+    st.dataframe(imp_df.head(15), use_container_width=True)
+    fig2, ax = plt.subplots(figsize=(8,5))
+    imp_df.head(20).iloc[::-1].plot(kind="barh", x="feature", y="mean_abs_shap", ax=ax)
+    ax.set_title("Top Drivers — Mean |SHAP| (GM%)")
+    ax.set_xlabel("Mean |SHAP| contribution")
+    st.pyplot(fig2, clear_figure=True)
+else:
+    st.info("Click **Compute / Refresh SHAP drivers** to see driver importance.")
+
+# Segment analysis
 st.subheader("🧭 Where did it happen? (Segment view)")
-# We'll focus on key interpretable features
-key_feats = [f for f in feature_names if any(k in f for k in ["discount", "price_per_unit", "cost_per_unit","unit_cost","net_price"])]
-joined = pd.concat([X_test_sample.reset_index(drop=True), shap_df[key_feats].reset_index(drop=True)], axis=1)
-# net directional impact
-grp = joined.groupby(["product","region","channel"]).mean(numeric_only=True)
-# Summaries
-rank_cols = [c for c in grp.columns if c not in ["product","region","channel"]]
-top_bad = grp[rank_cols].sum(axis=1).sort_values().head(10)
-top_good = grp[rank_cols].sum(axis=1).sort_values(ascending=False).head(10)
-
-c1, c2 = st.columns(2)
-with c1:
-    st.caption("Segments dragging GM% (more negative net SHAP)")
-    st.write(top_bad.to_frame("net_shap_sum").round(4))
-with c2:
-    st.caption("Segments lifting GM% (more positive net SHAP)")
-    st.write(top_good.to_frame("net_shap_sum").round(4))
+joined = st.session_state["shap_joined"]
+if joined is not None:
+    key_feats = [c for c in joined.columns if any(k in c for k in ["discount", "price_per_unit", "cost_per_unit","unit_cost","net_price"])]
+    grp = joined.groupby(["product","region","channel"]).mean(numeric_only=True)
+    rank_cols = [c for c in grp.columns if c in key_feats]
+    top_bad = grp[rank_cols].sum(axis=1).sort_values().head(10)
+    top_good = grp[rank_cols].sum(axis=1).sort_values(ascending=False).head(10)
+
+    c1, c2 = st.columns(2)
+    with c1:
+        st.caption("Segments dragging GM% (more negative net SHAP)")
+        st.write(top_bad.to_frame("net_shap_sum").round(4))
+    with c2:
+        st.caption("Segments lifting GM% (more positive net SHAP)")
+        st.write(top_good.to_frame("net_shap_sum").round(4))
+else:
+    st.info("Compute SHAP first to populate the segment view.")
 
 # -----------------------------
 # What-if Simulator
 # -----------------------------
-st.header("🧪 What‑if Simulator & Recommendations")
+st.header("🧪 What-if Simulator & Recommendations")
 
-# Segment picker based on last-day data
 last_day = df["date"].max()
 seg_today = df[df["date"]==last_day][["product","region","channel"]].drop_duplicates().sort_values(["product","region","channel"])
 seg_choice = st.selectbox("Choose a segment (product × region × channel):",
@@ -322,9 +350,9 @@ st.caption(f"Estimated price elasticity for segment: **{elasticity:.2f}** ({'ok'
 
 c3, c4 = st.columns(2)
 with c3:
-    delta_disc = st.slider("Change discount (percentage points)", -10.0, 10.0, default_disc_step, 0.1)
+    delta_disc = st.slider("Change discount (percentage points)", -10.0, 10.0, -1.5, 0.1)
 with c4:
-    delta_cost = st.slider("Change unit cost (absolute)", -5.0, 5.0, default_cost_step, 0.1)
+    delta_cost = st.slider("Change unit cost (absolute)", -5.0, 5.0, 0.0, 0.1)
 
 sim_res = simulate_action(seg_hist, elasticity, delta_discount=delta_disc/100.0, delta_unit_cost=delta_cost)
 
@@ -343,48 +371,45 @@ if sim_res is not None:
 # Auto Recommendations
 # -----------------------------
 st.subheader("💡 Top Recommendations (ranked by expected uplift)")
-
-# Identify candidate segments from last day (using negative discount/cost SHAP in recent window)
-recent_join = joined.copy()
-recent_join["key"] = recent_join["product"] + "|" + recent_join["region"] + "|" + recent_join["channel"]
-
-# score segments: more negative (discount/cost) net shap → candidate for improvement
-cand_cols = [c for c in key_feats if ("discount" in c or "cost" in c or "price" in c)]
-seg_scores = recent_join.groupby("key")[cand_cols].mean().sum(axis=1)
-worst_keys = seg_scores.sort_values().head(20).index.tolist()
-
-recs = []
-seen = set()
-for key in worst_keys:
-    p, r, c = key.split("|")
-    if key in seen: 
-        continue
-    seen.add(key)
-    hist = df[(df["product"]==p)&(df["region"]==r)&(df["channel"]==c)].sort_values("date")
-    if hist.empty: 
-        continue
-    eps, _ = estimate_segment_elasticity(hist, p, r, c)
-    # propose tightening discount a bit; sample 1.0–2.0 pts
-    prop_disc_pts = -np.clip(abs(seg_scores[key])*10, 0.5, 2.0)
-    sim = simulate_action(hist, eps, delta_discount=prop_disc_pts/100.0, delta_unit_cost=0.0)
-    if sim is None: 
-        continue
-    recs.append({
-        "segment": f"{p} • {r} • {c}",
-        "action": f"Reduce discount by {abs(prop_disc_pts):.1f} pts",
-        "expected_gm_uplift": sim["gm_delta_value"],
-        "new_discount_pct": sim["new_discount"]*100,
-        "elasticity": eps,
-        "notes": "Driven by negative discount/price SHAP"
-    })
-
-rec_df = pd.DataFrame(recs).sort_values("expected_gm_uplift", ascending=False)
-st.dataframe(rec_df.head(15), use_container_width=True)
-
-st.download_button("⬇️ Download recommendations (CSV)",
-                   data=rec_df.to_csv(index=False).encode("utf-8"),
-                   file_name="gm_recommendations.csv",
-                   mime="text/csv")
+if joined is not None:
+    recent_join = joined.copy()
+    recent_join["key"] = recent_join["product"] + "|" + recent_join["region"] + "|" + recent_join["channel"]
+    cand_cols = [c for c in recent_join.columns if ("discount" in c or "cost" in c or "price" in c)]
+    seg_scores = recent_join.groupby("key")[cand_cols].mean().sum(axis=1)
+    worst_keys = seg_scores.sort_values().head(20).index.tolist()
+
+    recs = []
+    seen = set()
+    for key in worst_keys:
+        p, r, c = key.split("|")
+        if key in seen:
+            continue
+        seen.add(key)
+        hist = df[(df["product"]==p)&(df["region"]==r)&(df["channel"]==c)].sort_values("date")
+        if hist.empty:
+            continue
+        eps, _ = estimate_segment_elasticity(hist, p, r, c)
+        prop_disc_pts = -np.clip(abs(seg_scores[key])*10, 0.5, 2.0)  # propose 0.5–2.0 pts tightening
+        sim = simulate_action(hist, eps, delta_discount=prop_disc_pts/100.0, delta_unit_cost=0.0)
+        if sim is None:
+            continue
+        recs.append({
+            "segment": f"{p} • {r} • {c}",
+            "action": f"Reduce discount by {abs(prop_disc_pts):.1f} pts",
+            "expected_gm_uplift": sim["gm_delta_value"],
+            "new_discount_pct": sim["new_discount"]*100,
+            "elasticity": eps,
+            "notes": "Driven by negative discount/price SHAP"
+        })
+
+    rec_df = pd.DataFrame(recs).sort_values("expected_gm_uplift", ascending=False)
+    st.dataframe(rec_df.head(15), use_container_width=True)
+    st.download_button("⬇️ Download recommendations (CSV)",
+                       data=rec_df.to_csv(index=False).encode("utf-8"),
+                       file_name="gm_recommendations.csv",
+                       mime="text/csv")
+else:
+    st.info("Compute SHAP first to generate recommendation candidates.")
 
 st.markdown("---")
-st.caption("Demo only — synthetic data & simplified economics. For production, plug in your CDS feed and business constraints.")
+st.caption("Demo only — synthetic data & simplified economics. For production, plug in your CDS feed and business constraints.")

requirements.txt

@@ -1,7 +1,8 @@
+
 streamlit==1.37.1
 pandas==2.2.2
 numpy==1.26.4
 scikit-learn==1.4.2
 shap==0.45.1
 matplotlib==3.9.0
-plotly==5.22.0
+plotly==5.22.0