Update app.py

app.py

@@ -1,4 +1,3 @@
-
 import streamlit as st
 import numpy as np
 import pandas as pd
@@ -30,7 +29,6 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
     regions = ["AMER", "EMEA", "APAC"]
     channels = ["Direct", "Distributor", "Online"]
 
-    # Base economics
     base_price = {"A": 120, "B": 135, "C": 110, "D": 150}
     base_cost  = {"A": 70,  "B": 88,  "C": 60,  "D": 95}
 
@@ -40,12 +38,10 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
     channel_discount_mean = {"Direct": 0.06, "Distributor": 0.12, "Online": 0.04}
     channel_discount_std  = {"Direct": 0.02, "Distributor": 0.03, "Online": 0.02}
 
-    # True (hidden) elasticities per segment product×region×channel
     seg_epsilon = {}
     for p in products:
         for r in regions:
             for c in channels:
-                # Inelastic online, more elastic distributor
                 base_eps = rng.uniform(-0.9, -0.25)
                 if c == "Distributor":
                     base_eps -= rng.uniform(0.1, 0.3)
@@ -55,11 +51,8 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
 
     records = []
     for d in dates:
-        # Seasonality/day-of-week effect
         dow = d.weekday()
-        dow_mult = 1.0 + (0.06 if dow in (5, 6) else 0)  # weekend lift
-
-        # Random macro shock (slow drift)
+        dow_mult = 1.0 + (0.06 if dow in (5, 6) else 0)
         macro = 1.0 + 0.03*np.sin((d.toordinal()%365)/365*2*np.pi)
 
         n = rows_per_day
@@ -70,17 +63,14 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
         base_p = np.array([base_price[x] for x in prod]) * np.array([region_price_bump[x] for x in reg])
         base_c = np.array([base_cost[x]  for x in prod]) * np.array([region_cost_bump[x]  for x in reg])
 
-        # Realized price & cost
         discount = np.clip(
             np.array([channel_discount_mean[x] for x in ch]) +
             rng.normal(0, [channel_discount_std[x] for x in ch]), 0, 0.45
         )
         list_price = rng.normal(base_p, 5)
         net_price = np.clip(list_price * (1 - discount), 20, None)
-
         unit_cost = np.clip(rng.normal(base_c, 4), 10, None)
 
-        # 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])
         qty_mu = np.exp(eps * (net_price - ref_price) / np.maximum(ref_price, 1e-6))
@@ -108,13 +98,12 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
                 "gm_pct": float(gm_pct[i]),
                 "dow": dow
             })
-    df = pd.DataFrame(records)
-    return df
+    return pd.DataFrame(records)
 
 # -----------------------------
 # 2) Modeling utilities
 # -----------------------------
-def build_features(df: pd.DataFrame):
+def build_features(df):
     feats_num = ["net_price", "unit_cost", "qty", "discount_pct", "list_price", "dow"]
     feats_cat = ["product", "region", "channel"]
 
@@ -128,288 +117,116 @@ def build_features(df: pd.DataFrame):
     df["roll7_cost"]  = df.groupby(seg)["cost_per_unit"].transform(lambda s: s.rolling(7, min_periods=1).median())
 
     feats_num += ["price_per_unit", "cost_per_unit", "roll7_qty", "roll7_price", "roll7_cost"]
-    target = "gm_pct"
-    return df, feats_num, feats_cat, target
+    return df, feats_num, feats_cat, "gm_pct"
 
 @st.cache_resource(show_spinner=False)
-def train_model(df: pd.DataFrame, feats_num, feats_cat, target, n_estimators=250):
+def train_model(df, feats_num, feats_cat, target, n_estimators=250):
     X = df[feats_num + feats_cat]
     y = df[target]
-
-    pre = ColumnTransformer(
-        transformers=[
-            ("cat", OneHotEncoder(handle_unknown="ignore"), feats_cat),
-            ("num", "passthrough", feats_num),
-        ]
-    )
-    model = RandomForestRegressor(n_estimators=n_estimators, max_depth=None, random_state=42, n_jobs=-1, min_samples_leaf=3)
+    pre = ColumnTransformer([
+        ("cat", OneHotEncoder(handle_unknown="ignore"), feats_cat),
+        ("num", "passthrough", feats_num),
+    ])
+    model = RandomForestRegressor(n_estimators=n_estimators, 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)
     pipe.fit(X_train, y_train)
     pred = pipe.predict(X_test)
-
-    r2 = r2_score(y_test, pred)
-    mae = mean_absolute_error(y_test, pred)
-
-    # Store components for SHAP later (on-demand)
-    return pipe, {"r2": r2, "mae": mae}, X_test
+    return pipe, {"r2": r2_score(y_test, pred), "mae": mean_absolute_error(y_test, pred)}, X_test
 
 @st.cache_resource(show_spinner=False)
-def compute_shap(pipe, X_sample, feats_num, feats_cat, shap_sample=800, seed=42):
+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"]
+    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
 
     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_sample = X_sample.sample(shap_sample, random_state=seed)
     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_t)
-    expected_value = explainer.expected_value
-
-    shap_df = pd.DataFrame(shap_values, columns=feature_names)
-    return shap_df, expected_value, X_sample.reset_index(drop=True), feature_names
+    return pd.DataFrame(shap_values, columns=feature_names), explainer.expected_value, X_sample.reset_index(drop=True), feature_names
 
-def estimate_segment_elasticity(df: pd.DataFrame, product, region, channel):
+def estimate_segment_elasticity(df, product, region, channel):
     seg_df = df[(df["product"]==product)&(df["region"]==region)&(df["channel"]==channel)]
-    if len(seg_df) < 100 or seg_df["net_price"].std() < 1e-6 or seg_df["qty"].std() < 1e-6:
+    if len(seg_df) < 100 or seg_df["net_price"].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)
     return float(lin.coef_[0]), True
 
-def simulate_action(segment_df: pd.DataFrame, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
+def simulate_action(segment_df, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
     if segment_df.empty:
         return None
     base = segment_df.iloc[-1]
-    p0 = base["net_price"]
-    c0 = base["unit_cost"]
-    q0 = base["qty"]
-    d0 = base["discount_pct"]
-
+    p0, c0, q0, d0 = base["net_price"], base["unit_cost"], base["qty"], base["discount_pct"]
     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)
-
-    if p0 <= 0:
-        q1 = q0
-    else:
-        q1 = max(0.0, q0 * (p1 / p0) ** elasticity)
-
-    rev0 = p0 * q0
-    cogs0 = c0 * q0
-    rev1 = p1 * q1
-    cogs1 = c1 * q1
-
-    gm_delta_value = (rev1 - cogs1) - (rev0 - cogs0)
-    gm0_pct = (rev0 - cogs0)/rev0 if rev0>0 else 0.0
-    gm1_pct = (rev1 - cogs1)/rev1 if rev1>0 else 0.0
+    q1 = q0 if p0 <= 0 else max(0.0, q0 * (p1 / p0) ** elasticity)
+    rev0, rev1 = p0*q0, p1*q1
+    cogs0, cogs1 = c0*q0, c1*q1
+    gm_delta = (rev1 - cogs1) - (rev0 - cogs0)
     return {
+        "gm_delta_value": gm_delta,
+        "gm0_pct": (rev0 - cogs0)/rev0 if rev0>0 else 0,
+        "gm1_pct": (rev1 - cogs1)/rev1 if rev1>0 else 0,
+        "new_discount": new_discount,
         "baseline_price": p0, "new_price": p1,
         "baseline_cost": c0, "new_cost": c1,
         "baseline_qty": q0, "new_qty": q1,
-        "gm_delta_value": gm_delta_value,
-        "gm0_pct": gm0_pct, "gm1_pct": gm1_pct,
-        "new_discount": new_discount
     }
 
 # -----------------------------
 # 3) UI
 # -----------------------------
 st.title("📈 AI-Driven Daily Gross Margin — Analysis & What-if Simulator")
-st.caption("Synthetic demo: Revenue − COGS focus • Driver analysis with SHAP • What-if recommendations")
-
 with st.sidebar:
     st.header("⚙️ Controls")
-    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)
-
-# Data
-with st.spinner("Generating realistic synthetic data..."):
-    df = generate_synthetic_data(days=days, seed=int(seed), rows_per_day=int(rows_per_day))
-
+    fast_mode = st.toggle("Fast mode", value=True)
+    days = 60 if fast_mode else 90
+    rows_per_day = 600 if fast_mode else 1200
+    seed = 42
+    n_trees = 250 if fast_mode else 400
+    shap_sample = 800 if fast_mode else 1800
+
+df = generate_synthetic_data(days, seed, rows_per_day)
 df_feat, feats_num, feats_cat, target = build_features(df)
 
 # KPI panel
 daily = df.groupby("date").agg(revenue=("revenue","sum"), cogs=("cogs","sum"), gm_value=("gm_value","sum")).reset_index()
-daily["gm_pct"] = np.where(daily["revenue"]>0, daily["gm_value"]/daily["revenue"], 0.0)
+daily["gm_pct"] = daily["gm_value"]/daily["revenue"]
 today_row = daily.iloc[-1]
-roll7 = daily["gm_pct"].tail(7).mean() if len(daily)>=7 else daily["gm_pct"].mean()
-delta_pts = (today_row["gm_pct"] - roll7)*100
-
-kpi_cols = st.columns(4)
-kpi_cols[0].metric("GM% (today)", f"{today_row['gm_pct']*100:.2f}%",
-                   f"{delta_pts:+.2f} pts vs 7D avg")
-kpi_cols[1].metric("Revenue (today)", f"{today_row['revenue']/1e6:.2f} M")
-kpi_cols[2].metric("COGS (today)", f"{today_row['cogs']/1e6:.2f} M")
-kpi_cols[3].metric("GM Value (today)", f"{today_row['gm_value']/1e6:.2f} M")
+st.metric("GM% (today)", f"{today_row['gm_pct']*100:.2f}%")
 
-fig = px.line(daily, x="date", y="gm_pct", title="Daily GM% (history)")
-fig.update_yaxes(tickformat=".1%")
-st.plotly_chart(fig, use_container_width=True)
+# Train model
+pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target, n_estimators=n_trees)
+st.success(f"Model trained R²={metrics['r2']:.3f} • MAE={metrics['mae']:.4f}")
 
-# Train
-with st.spinner("Training model…"):
-    pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target, n_estimators=int(n_trees))
+# SHAP compute
+if st.button("Compute / Refresh SHAP drivers"):
+    shap_df, expected_value, X_test_sample, feature_names = compute_shap(pipe, X_test, feats_num, feats_cat, shap_sample)
+    st.session_state["shap_df"] = shap_df
+    st.session_state["X_test_sample"] = X_test_sample
+    st.session_state["feature_names"] = feature_names
 
-st.success(f"Model trained • R²={metrics['r2']:.3f} • MAE={metrics['mae']:.4f} (GM% points)")
-
-# SHAP: compute on demand
-st.subheader("🔍 Driver Analysis (Global)")
-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)")
-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")
+if "shap_df" in st.session_state:
+    shap_df = st.session_state["shap_df"]
+    mean_abs = shap_df.abs().mean().sort_values(ascending=False)
+    st.dataframe(pd.DataFrame({"feature": mean_abs.index, "mean_abs_shap": mean_abs.values}).head(15))
 
+# What-if simulation
 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):",
-                          seg_today.apply(lambda r: f"{r['product']} • {r['region']} • {r['channel']}", axis=1))
-
-prod_sel, reg_sel, ch_sel = [s.strip() for s in seg_choice.split("•")]
-seg_hist = df[(df["product"]==prod_sel)&(df["region"]==reg_sel)&(df["channel"]==ch_sel)].sort_values("date")
-
-elasticity, ok = estimate_segment_elasticity(seg_hist, prod_sel, reg_sel, ch_sel)
-st.caption(f"Estimated price elasticity for segment: **{elasticity:.2f}** ({'ok' if ok else 'fallback'})")
-
-c3, c4 = st.columns(2)
-with c3:
-    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, 0.0, 0.1)
-
-sim_res = simulate_action(seg_hist, elasticity, delta_discount=delta_disc/100.0, delta_unit_cost=delta_cost)
-
-if sim_res is not None:
-    st.markdown(f"""
-**Simulated outcome (today’s baseline for {seg_choice}):**  
-- New discount: **{sim_res['new_discount']*100:.2f}%**  
-- Price: {sim_res['baseline_price']:.2f} → **{sim_res['new_price']:.2f}**  
-- Cost:  {sim_res['baseline_cost']:.2f} → **{sim_res['new_cost']:.2f}**  
-- Qty:   {sim_res['baseline_qty']:.1f} → **{sim_res['new_qty']:.1f}**  
-- GM%:   {sim_res['gm0_pct']*100:.2f}% → **{sim_res['gm1_pct']*100:.2f}%**  
-- **GM uplift (value)**: **{sim_res['gm_delta_value']:.2f}**
-""")
-
-# -----------------------------
-# Auto Recommendations
-# -----------------------------
-st.subheader("💡 Top Recommendations (ranked by expected uplift)")
-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.")
+seg = df[df["date"]==last_day][["product","region","channel"]].drop_duplicates().iloc[0]
+prod_sel, reg_sel, ch_sel = seg
+seg_hist = df[(df["product"]==prod_sel)&(df["region"]==reg_sel)&(df["channel"]==ch_sel)]
+elasticity, _ = estimate_segment_elasticity(seg_hist, prod_sel, reg_sel, ch_sel)
+res = simulate_action(seg_hist, elasticity, delta_discount=-0.015, delta_unit_cost=0.0)
+if res:
+    st.write(f"Simulated GM%: {res['gm0_pct']*100:.2f}% → {res['gm1_pct']*100:.2f}% (ΔGM: {res['gm_delta_value']:.2f})")