Update app.py

app.py

@@ -1,10 +1,12 @@
+
 import streamlit as st
 import numpy as np
 import pandas as pd
 import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import shap
 import matplotlib.pyplot as plt
-
 from datetime import datetime, timedelta
 from sklearn.model_selection import train_test_split
 from sklearn.compose import ColumnTransformer
@@ -14,38 +16,108 @@ from sklearn.ensemble import RandomForestRegressor
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import r2_score, mean_absolute_error
 
-st.set_page_config(page_title="AI-Driven Daily Gross Margin", layout="wide")
+# Enhanced page config
+st.set_page_config(
+    page_title="Profitability Intelligence Suite",
+    page_icon="📊",
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+# Custom CSS for premium look
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.8rem;
+        font-weight: 700;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 0.5rem;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
+    }
+    .sub-header {
+        font-size: 1.2rem;
+        color: #666;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .metric-container {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 1.5rem;
+        border-radius: 15px;
+        box-shadow: 0 8px 16px rgba(0,0,0,0.1);
+        color: white;
+        text-align: center;
+    }
+    .insight-box {
+        background: #f8f9fa;
+        border-left: 5px solid #1f77b4;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        border-radius: 8px;
+        box-shadow: 0 4px 8px rgba(0,0,0,0.05);
+    }
+    .recommendation-card {
+        background: white;
+        border: 2px solid #e9ecef;
+        border-radius: 12px;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+        transition: transform 0.2s;
+    }
+    .recommendation-card:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 8px 20px rgba(0,0,0,0.12);
+    }
+    .positive-impact {
+        color: #28a745;
+        font-weight: 700;
+        font-size: 1.5rem;
+    }
+    .negative-impact {
+        color: #dc3545;
+        font-weight: 700;
+        font-size: 1.5rem;
+    }
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2rem;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 3rem;
+        font-size: 1.1rem;
+        font-weight: 600;
+    }
+</style>
+""", unsafe_allow_html=True)
 
 # -----------------------------
-# 1) Synthetic data generation
+# Data Generation (Same as original)
 # -----------------------------
 @st.cache_data(show_spinner=False)
 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")
+    products = ["Premium Widget", "Standard Widget", "Economy Widget", "Deluxe Widget"]
+    regions = ["Americas", "EMEA", "Asia Pacific"]
+    channels = ["Direct Sales", "Distribution Partners", "E-Commerce"]
 
-    products = ["A", "B", "C", "D"]
-    regions = ["AMER", "EMEA", "APAC"]
-    channels = ["Direct", "Distributor", "Online"]
-
-    base_price = {"A": 120, "B": 135, "C": 110, "D": 150}
-    base_cost  = {"A": 70,  "B": 88,  "C": 60,  "D": 95}
-
-    region_price_bump = {"AMER": 1.00, "EMEA": 1.03, "APAC": 0.97}
-    region_cost_bump  = {"AMER": 1.00, "EMEA": 1.02, "APAC": 1.01}
-
-    channel_discount_mean = {"Direct": 0.06, "Distributor": 0.12, "Online": 0.04}
-    channel_discount_std  = {"Direct": 0.02, "Distributor": 0.03, "Online": 0.02}
+    base_price = {"Premium Widget": 120, "Standard Widget": 135, "Economy Widget": 110, "Deluxe Widget": 150}
+    base_cost = {"Premium Widget": 70, "Standard Widget": 88, "Economy Widget": 60, "Deluxe Widget": 95}
+    region_price_bump = {"Americas": 1.00, "EMEA": 1.03, "Asia Pacific": 0.97}
+    region_cost_bump = {"Americas": 1.00, "EMEA": 1.02, "Asia Pacific": 1.01}
+    channel_discount_mean = {"Direct Sales": 0.06, "Distribution Partners": 0.12, "E-Commerce": 0.04}
+    channel_discount_std = {"Direct Sales": 0.02, "Distribution Partners": 0.03, "E-Commerce": 0.02}
 
     seg_epsilon = {}
     for p in products:
         for r in regions:
             for c in channels:
                 base_eps = rng.uniform(-0.9, -0.25)
-                if c == "Distributor":
+                if c == "Distribution Partners":
                     base_eps -= rng.uniform(0.1, 0.3)
-                if c == "Online":
+                if c == "E-Commerce":
                     base_eps += rng.uniform(0.05, 0.15)
                 seg_epsilon[(p, r, c)] = base_eps
 
@@ -57,16 +129,17 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
 
         n = rows_per_day
         prod = rng.choice(products, size=n, p=[0.35, 0.3, 0.2, 0.15])
-        reg  = rng.choice(regions,  size=n, p=[0.4, 0.35, 0.25])
-        ch   = rng.choice(channels, size=n, p=[0.45, 0.35, 0.20])
+        reg = rng.choice(regions, size=n, p=[0.4, 0.35, 0.25])
+        ch = rng.choice(channels, size=n, p=[0.45, 0.35, 0.20])
 
         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])
+        base_c = np.array([base_cost[x] for x in prod]) * np.array([region_cost_bump[x] for x in reg])
 
         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)
@@ -77,9 +150,9 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
         qty = np.maximum(1, rng.poisson(8 * dow_mult * macro * qty_mu))
 
         revenue = net_price * qty
-        cogs    = unit_cost * qty
-        gm_val  = revenue - cogs
-        gm_pct  = np.where(revenue > 0, gm_val / revenue, 0.0)
+        cogs = unit_cost * qty
+        gm_val = revenue - cogs
+        gm_pct = np.where(revenue > 0, gm_val / revenue, 0.0)
 
         for i in range(n):
             records.append({
@@ -98,135 +171,628 @@ def generate_synthetic_data(days=60, seed=42, rows_per_day=600):
                 "gm_pct": float(gm_pct[i]),
                 "dow": dow
             })
-    return pd.DataFrame(records)
 
-# -----------------------------
-# 2) Modeling utilities
-# -----------------------------
-def build_features(df):
+    df = pd.DataFrame(records)
+    return df
+
+def build_features(df: pd.DataFrame):
     feats_num = ["net_price", "unit_cost", "qty", "discount_pct", "list_price", "dow"]
     feats_cat = ["product", "region", "channel"]
-
     df = df.sort_values("date").copy()
     seg = ["product", "region", "channel"]
     df["price_per_unit"] = df["net_price"]
-    df["cost_per_unit"]  = df["unit_cost"]
-
+    df["cost_per_unit"] = df["unit_cost"]
     df["roll7_qty"] = df.groupby(seg)["qty"].transform(lambda s: s.rolling(7, min_periods=1).median())
     df["roll7_price"] = df.groupby(seg)["price_per_unit"].transform(lambda s: s.rolling(7, min_periods=1).median())
-    df["roll7_cost"]  = df.groupby(seg)["cost_per_unit"].transform(lambda s: s.rolling(7, min_periods=1).median())
-
+    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"]
-    return df, feats_num, feats_cat, "gm_pct"
+    target = "gm_pct"
+    return df, feats_num, feats_cat, target
 
 @st.cache_resource(show_spinner=False)
-def train_model(df, feats_num, feats_cat, target, n_estimators=250):
+def train_model(df: pd.DataFrame, feats_num, feats_cat, target):
     X = df[feats_num + feats_cat]
     y = df[target]
-    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)
+    pre = ColumnTransformer(
+        transformers=[
+            ("cat", OneHotEncoder(handle_unknown="ignore"), feats_cat),
+            ("num", "passthrough", feats_num),
+        ]
+    )
+    model = RandomForestRegressor(n_estimators=250, 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)
     pipe.fit(X_train, y_train)
     pred = pipe.predict(X_test)
-    return pipe, {"r2": r2_score(y_test, pred), "mae": mean_absolute_error(y_test, pred)}, X_test
+    r2 = r2_score(y_test, pred)
+    mae = mean_absolute_error(y_test, pred)
+    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
+def compute_shap(pipe, X_sample, feats_num, feats_cat, shap_sample=800):
+    np.random.seed(42)
+    preprocessor = pipe.named_steps["pre"]
+    rf = pipe.named_steps["rf"]
+    feature_names = list(preprocessor.named_transformers_["cat"].get_feature_names_out(feats_cat)) + feats_num
 
     if len(X_sample) > shap_sample:
-        X_sample = X_sample.sample(shap_sample, random_state=seed)
-    X_t = preproc.transform(X_sample)
+        sample_idx = np.random.choice(len(X_sample), size=shap_sample, replace=False)
+        X_sample = X_sample.iloc[sample_idx]
+
+    X_t = preprocessor.transform(X_sample)
     try:
         X_t = X_t.toarray()
     except Exception:
         pass
+
     explainer = shap.TreeExplainer(rf)
     shap_values = explainer.shap_values(X_t)
-    return pd.DataFrame(shap_values, columns=feature_names), explainer.expected_value, X_sample.reset_index(drop=True), feature_names
+    shap_df = pd.DataFrame(shap_values, columns=feature_names)
+
+    return shap_df, X_sample.reset_index(drop=True), feature_names
 
-def estimate_segment_elasticity(df, product, region, channel):
+def estimate_segment_elasticity(df: pd.DataFrame, 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:
+    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)
     return float(lin.coef_[0]), True
 
-def simulate_action(segment_df, elasticity, delta_discount=0.0, delta_unit_cost=0.0):
+def simulate_pricing_action(segment_df: pd.DataFrame, elasticity, discount_reduction_pct):
     if segment_df.empty:
         return None
     base = segment_df.iloc[-1]
-    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)
+    p0 = base["net_price"]
+    c0 = base["unit_cost"]
+    q0 = base["qty"]
+    d0 = base["discount_pct"]
+
+    new_discount = np.clip(d0 - (discount_reduction_pct/100), 0.0, 0.45)
     p1 = max(0.01, base["list_price"] * (1 - new_discount))
-    c1 = max(0.01, c0 + delta_unit_cost)
-    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)
+    c1 = c0
+
+    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
+
     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,
+        "baseline_discount": d0*100, "new_discount": new_discount*100,
+        "gm_delta_value": gm_delta_value,
+        "gm0_pct": gm0_pct, "gm1_pct": gm1_pct,
+        "revenue_delta": rev1 - rev0
     }
 
 # -----------------------------
-# 3) UI
+# Main App
 # -----------------------------
-st.title("📈 AI-Driven Daily Gross Margin — Analysis & What-if Simulator")
-with st.sidebar:
-    st.header("⚙️ Controls")
-    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"] = daily["gm_value"]/daily["revenue"]
+
+# Header
+st.markdown('<h1 class="main-header">🎯 Profitability Intelligence Suite</h1>', unsafe_allow_html=True)
+st.markdown('<p class="sub-header">AI-Powered Margin Analysis & Strategic Recommendations</p>', unsafe_allow_html=True)
+
+# Generate data
+with st.spinner("🔄 Loading business data..."):
+    df = generate_synthetic_data(days=60, seed=42, rows_per_day=600)
+    df_feat, feats_num, feats_cat, target = build_features(df)
+
+# Calculate KPIs
+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)
+
 today_row = daily.iloc[-1]
-st.metric("GM% (today)", f"{today_row['gm_pct']*100:.2f}%")
+yesterday_row = daily.iloc[-2] if len(daily) > 1 else today_row
+week_ago_row = daily.iloc[-8] if len(daily) > 7 else today_row
+roll7 = daily["gm_pct"].tail(7).mean()
+
+# Executive Dashboard Section
+st.markdown("### 📊 Executive Performance Dashboard")
+
+col1, col2, col3, col4 = st.columns(4)
+
+with col1:
+    delta_gm = (today_row["gm_pct"] - yesterday_row["gm_pct"]) * 100
+    st.metric(
+        label="Gross Margin %",
+        value=f"{today_row['gm_pct']*100:.1f}%",
+        delta=f"{delta_gm:+.2f}pp vs yesterday",
+        delta_color="normal"
+    )
+
+with col2:
+    delta_rev = ((today_row["revenue"] - yesterday_row["revenue"]) / yesterday_row["revenue"] * 100) if yesterday_row["revenue"] > 0 else 0
+    st.metric(
+        label="Revenue (Today)",
+        value=f"${today_row['revenue']/1e6:.2f}M",
+        delta=f"{delta_rev:+.1f}% DoD",
+        delta_color="normal"
+    )
+
+with col3:
+    st.metric(
+        label="Gross Margin $ (Today)",
+        value=f"${today_row['gm_value']/1e6:.2f}M",
+        delta=f"${(today_row['gm_value'] - yesterday_row['gm_value'])/1e6:+.2f}M",
+        delta_color="normal"
+    )
+
+with col4:
+    avg_gm_vs_week = (today_row["gm_pct"] - week_ago_row["gm_pct"]) * 100
+    st.metric(
+        label="7-Day Avg GM%",
+        value=f"{roll7*100:.1f}%",
+        delta=f"{avg_gm_vs_week:+.2f}pp WoW",
+        delta_color="normal"
+    )
+
+# Trend visualization
+st.markdown("#### 📈 Performance Trend Analysis")
+
+fig_trends = make_subplots(
+    rows=1, cols=2,
+    subplot_titles=("Gross Margin % Trend", "Revenue & Margin $ Trend"),
+    specs=[[{"secondary_y": False}, {"secondary_y": True}]]
+)
+
+# GM% trend
+fig_trends.add_trace(
+    go.Scatter(
+        x=daily["date"],
+        y=daily["gm_pct"]*100,
+        name="GM%",
+        line=dict(color="#1f77b4", width=3),
+        fill='tozeroy',
+        fillcolor="rgba(31, 119, 180, 0.1)"
+    ),
+    row=1, col=1
+)
+
+# Revenue and GM$ trend
+fig_trends.add_trace(
+    go.Scatter(
+        x=daily["date"],
+        y=daily["revenue"]/1e6,
+        name="Revenue",
+        line=dict(color="#2ca02c", width=2)
+    ),
+    row=1, col=2
+)
+
+fig_trends.add_trace(
+    go.Scatter(
+        x=daily["date"],
+        y=daily["gm_value"]/1e6,
+        name="GM Value",
+        line=dict(color="#ff7f0e", width=2, dash="dash")
+    ),
+    row=1, col=2, secondary_y=True
+)
+
+fig_trends.update_xaxes(title_text="Date", row=1, col=1)
+fig_trends.update_xaxes(title_text="Date", row=1, col=2)
+fig_trends.update_yaxes(title_text="Gross Margin %", row=1, col=1)
+fig_trends.update_yaxes(title_text="Revenue ($M)", row=1, col=2)
+fig_trends.update_yaxes(title_text="GM Value ($M)", row=1, col=2, secondary_y=True)
+
+fig_trends.update_layout(height=400, showlegend=True, hovermode="x unified")
+st.plotly_chart(fig_trends, use_container_width=True)
+
+st.markdown("---")
 
 # 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}")
-
-# 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
-
-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 = 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})")
+with st.spinner("🤖 Training AI model..."):
+    pipe, metrics, X_test = train_model(df_feat, feats_num, feats_cat, target)
+
+# Tabs for different sections
+tab1, tab2, tab3 = st.tabs(["🔍 Key Drivers Analysis", "🎯 Strategic Recommendations", "🧪 What-If Simulator"])
+
+with tab1:
+    st.markdown("### Understanding What Drives Your Profitability")
+    st.markdown("""
+    <div class="insight-box">
+    <b>🎓 Business Insight:</b> This analysis reveals which business factors have the strongest impact on gross margin.
+    Understanding these drivers helps prioritize strategic initiatives and operational improvements.
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Compute SHAP
+    with st.spinner("🔬 Analyzing profitability drivers..."):
+        shap_df, X_test_sample, feature_names = compute_shap(pipe, X_test, feats_num, feats_cat, shap_sample=800)
+
+        # Calculate mean absolute SHAP
+        mean_abs = shap_df.abs().mean().sort_values(ascending=False)
+
+        # Map technical names to business names
+        business_name_map = {
+            "discount_pct": "Discount Level",
+            "unit_cost": "Unit Cost",
+            "net_price": "Net Selling Price",
+            "list_price": "List Price",
+            "qty": "Order Quantity",
+            "price_per_unit": "Price per Unit",
+            "cost_per_unit": "Cost per Unit",
+            "roll7_qty": "7-Day Avg Quantity",
+            "roll7_price": "7-Day Avg Price",
+            "roll7_cost": "7-Day Avg Cost",
+            "dow": "Day of Week"
+        }
+
+        # Get top drivers with business names
+        top_drivers = []
+        for feat, val in mean_abs.head(10).items():
+            bus_name = feat
+            for key, name in business_name_map.items():
+                if key in feat.lower():
+                    bus_name = name
+                    break
+            # Check for product/region/channel encoding
+            if feat.startswith("cat__"):
+                parts = feat.replace("cat__", "").split("_")
+                if "product" in feat.lower():
+                    bus_name = f"Product: {parts[-1] if parts else feat}"
+                elif "region" in feat.lower():
+                    bus_name = f"Region: {parts[-1] if parts else feat}"
+                elif "channel" in feat.lower():
+                    bus_name = f"Channel: {parts[-1] if parts else feat}"
+            top_drivers.append({"Driver": bus_name, "Impact Score": val})
+
+        drivers_df = pd.DataFrame(top_drivers)
+
+    col_a, col_b = st.columns([1, 1])
+
+    with col_a:
+        st.markdown("#### Top 10 Profitability Drivers")
+
+        # Create horizontal bar chart
+        fig_drivers = go.Figure()
+        fig_drivers.add_trace(go.Bar(
+            y=drivers_df["Driver"][::-1],
+            x=drivers_df["Impact Score"][::-1],
+            orientation='h',
+            marker=dict(
+                color=drivers_df["Impact Score"][::-1],
+                colorscale='Blues',
+                line=dict(color='rgb(8,48,107)', width=1.5)
+            ),
+            text=drivers_df["Impact Score"][::-1].round(4),
+            textposition='outside',
+        ))
+
+        fig_drivers.update_layout(
+            title="Ranked by Average Impact on Gross Margin",
+            xaxis_title="Impact Score (higher = stronger influence)",
+            yaxis_title="",
+            height=500,
+            showlegend=False
+        )
+        st.plotly_chart(fig_drivers, use_container_width=True)
+
+    with col_b:
+        st.markdown("#### Key Insights")
+
+        # Generate business insights
+        top_3 = drivers_df.head(3)
+
+        st.markdown(f"""
+        <div class="insight-box">
+        <b>🥇 Primary Driver:</b> {top_3.iloc[0]['Driver']}<br>
+        <small>This factor has the strongest influence on margin performance</small>
+        </div>
+        """, unsafe_allow_html=True)
+
+        st.markdown(f"""
+        <div class="insight-box">
+        <b>🥈 Secondary Driver:</b> {top_3.iloc[1]['Driver']}<br>
+        <small>Second most important factor affecting profitability</small>
+        </div>
+        """, unsafe_allow_html=True)
+
+        st.markdown(f"""
+        <div class="insight-box">
+        <b>🥉 Tertiary Driver:</b> {top_3.iloc[2]['Driver']}<br>
+        <small>Third key factor with significant margin impact</small>
+        </div>
+        """, unsafe_allow_html=True)
+
+        # Segment-level insights
+        st.markdown("#### Segment Performance")
+
+        # Join SHAP with original data
+        cat_cols = ["product", "region", "channel"]
+        joined = pd.concat([X_test_sample.reset_index(drop=True), shap_df.reset_index(drop=True)], axis=1)
+
+        # Find segments with biggest impact
+        grp = joined.groupby(cat_cols).mean(numeric_only=True)
+        key_shap_cols = [c for c in grp.columns if c in shap_df.columns]
+        grp["net_impact"] = grp[key_shap_cols].sum(axis=1)
+
+        top_negative = grp.nsmallest(5, "net_impact")
+        top_positive = grp.nlargest(5, "net_impact")
+
+        st.markdown("**⚠️ Segments Reducing Margin:**")
+        for idx, row in top_negative.head(3).iterrows():
+            st.markdown(f"• **{idx[0]}** • {idx[1]} • {idx[2]} *(Impact: {row['net_impact']:.4f})*")
+
+        st.markdown("**✅ Segments Boosting Margin:**")
+        for idx, row in top_positive.head(3).iterrows():
+            st.markdown(f"• **{idx[0]}** • {idx[1]} • {idx[2]} *(Impact: {row['net_impact']:.4f})*")
+
+with tab2:
+    st.markdown("### AI-Generated Strategic Recommendations")
+    st.markdown("""
+    <div class="insight-box">
+    <b>💡 How This Works:</b> The AI identifies segments with margin pressure and suggests specific pricing actions
+    to improve profitability. Recommendations are ranked by expected financial impact.
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Generate recommendations
+    with st.spinner("🧠 Generating strategic recommendations..."):
+        joined = pd.concat([X_test_sample.reset_index(drop=True), shap_df.reset_index(drop=True)], axis=1)
+        joined["key"] = joined["product"] + "|" + joined["region"] + "|" + joined["channel"]
+
+        cand_cols = [c for c in joined.columns if ("discount" in c.lower() or "cost" in c.lower() or "price" in c.lower()) and c in shap_df.columns]
+        seg_scores = joined.groupby("key")[cand_cols].mean().sum(axis=1)
+        worst_keys = seg_scores.sort_values().head(15).index.tolist()
+
+        recs = []
+        for key in worst_keys:
+            p, r, c = key.split("|")
+            hist = df[(df["product"]==p)&(df["region"]==r)&(df["channel"]==c)].sort_values("date")
+            if hist.empty or len(hist) < 50:
+                continue
+
+            eps, _ = estimate_segment_elasticity(hist, p, r, c)
+
+            # Suggest discount reduction between 1-3 percentage points
+            prop_disc_pts = np.clip(abs(seg_scores[key])*10, 1.0, 3.0)
+            sim = simulate_pricing_action(hist, eps, prop_disc_pts)
+
+            if sim is None or sim["gm_delta_value"] <= 0:
+                continue
+
+            # Calculate annualized impact (rough estimate)
+            daily_transactions = len(hist) / ((hist["date"].max() - hist["date"].min()).days + 1)
+            annual_impact = sim["gm_delta_value"] * daily_transactions * 365
+
+            recs.append({
+                "Segment": f"{p}",
+                "Region": r,
+                "Channel": c,
+                "Current Discount": f"{sim['baseline_discount']:.1f}%",
+                "Recommended Discount": f"{sim['new_discount']:.1f}%",
+                "Expected GM Uplift": sim["gm_delta_value"],
+                "Annual Impact Estimate": annual_impact,
+                "Current GM%": sim["gm0_pct"]*100,
+                "Projected GM%": sim["gm1_pct"]*100,
+                "Price Elasticity": eps
+            })
+
+        recs_df = pd.DataFrame(recs).sort_values("Expected GM Uplift", ascending=False)
+
+    if len(recs_df) > 0:
+        # Show top 3 recommendations in cards
+        st.markdown("#### 🏆 Top 3 Priority Actions")
+
+        for i, (idx, rec) in enumerate(recs_df.head(3).iterrows()):
+            with st.container():
+                st.markdown(f"""
+                <div class="recommendation-card">
+                    <h4>#{i+1}: {rec['Segment']} • {rec['Region']} • {rec['Channel']}</h4>
+                    <p style="font-size: 1.1rem; margin: 0.5rem 0;">
+                        <b>Recommended Action:</b> Reduce discount from <b>{rec['Current Discount']}</b> to <b>{rec['Recommended Discount']}</b>
+                    </p>
+                    <p style="font-size: 1rem; color: #666; margin: 0.5rem 0;">
+                        Current GM: <b>{rec['Current GM%']:.1f}%</b> → Projected GM: <b style="color: #28a745;">{rec['Projected GM%']:.1f}%</b>
+                    </p>
+                    <p class="positive-impact">
+                        💰 Expected Daily Impact: ${rec['Expected GM Uplift']:.2f}
+                    </p>
+                    <p style="font-size: 0.95rem; color: #666;">
+                        📊 Estimated Annual Impact: <b>${rec['Annual Impact Estimate']/1e3:.1f}K</b>
+                    </p>
+                </div>
+                """, unsafe_allow_html=True)
+
+        st.markdown("---")
+        st.markdown("#### 📋 Complete Recommendations List")
+
+        # Format for display
+        display_df = recs_df.copy()
+        display_df["Expected GM Uplift"] = display_df["Expected GM Uplift"].apply(lambda x: f"${x:.2f}")
+        display_df["Annual Impact Estimate"] = display_df["Annual Impact Estimate"].apply(lambda x: f"${x/1e3:.1f}K")
+        display_df["Current GM%"] = display_df["Current GM%"].apply(lambda x: f"{x:.1f}%")
+        display_df["Projected GM%"] = display_df["Projected GM%"].apply(lambda x: f"{x:.1f}%")
+        display_df["Price Elasticity"] = display_df["Price Elasticity"].apply(lambda x: f"{x:.2f}")
+
+        st.dataframe(display_df, use_container_width=True, height=400)
+
+        # Download button
+        st.download_button(
+            label="📥 Download Full Recommendations (CSV)",
+            data=recs_df.to_csv(index=False).encode("utf-8"),
+            file_name=f"profitability_recommendations_{datetime.today().strftime('%Y%m%d')}.csv",
+            mime="text/csv"
+        )
+
+        # Aggregate impact
+        total_daily_impact = recs_df["Expected GM Uplift"].sum()
+        total_annual_impact = recs_df["Annual Impact Estimate"].sum()
+
+        st.markdown(f"""
+        <div class="insight-box" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none;">
+            <h3 style="color: white; margin-top: 0;">💎 Total Opportunity</h3>
+            <p style="font-size: 1.3rem; margin: 0.5rem 0;">
+                <b>Daily GM Impact:</b> ${total_daily_impact:.2f}
+            </p>
+            <p style="font-size: 1.6rem; margin: 0.5rem 0;">
+                <b>Estimated Annual Impact:</b> ${total_annual_impact/1e6:.2f}M
+            </p>
+            <small>Based on current transaction volumes and assuming consistent implementation</small>
+        </div>
+        """, unsafe_allow_html=True)
+    else:
+        st.info("No significant optimization opportunities detected in current data.")
+
+with tab3:
+    st.markdown("### Custom What-If Analysis")
+    st.markdown("""
+    <div class="insight-box">
+    <b>🧪 Interactive Simulation:</b> Test different pricing strategies for specific segments to understand
+    the potential impact on revenue, volume, and profitability.
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Segment selector
+    last_day = df["date"].max()
+    seg_today = df[df["date"]==last_day][["product","region","channel"]].drop_duplicates()
+
+    col_sim1, col_sim2, col_sim3 = st.columns(3)
+
+    with col_sim1:
+        selected_product = st.selectbox("📦 Select Product", sorted(seg_today["product"].unique()))
+    with col_sim2:
+        selected_region = st.selectbox("🌍 Select Region", sorted(seg_today["region"].unique()))
+    with col_sim3:
+        selected_channel = st.selectbox("🛒 Select Channel", sorted(seg_today["channel"].unique()))
+
+    # Get segment history
+    seg_hist = df[
+        (df["product"]==selected_product) &
+        (df["region"]==selected_region) &
+        (df["channel"]==selected_channel)
+    ].sort_values("date")
+
+    if not seg_hist.empty and len(seg_hist) >= 50:
+        elasticity, _ = estimate_segment_elasticity(seg_hist, selected_product, selected_region, selected_channel)
+
+        # Current state
+        current = seg_hist.iloc[-1]
+
+        st.markdown(f"""
+        <div class="insight-box">
+        <b>📊 Current State:</b><br>
+        • Current Discount: <b>{current['discount_pct']*100:.1f}%</b><br>
+        • Net Price: <b>${current['net_price']:.2f}</b><br>
+        • Unit Cost: <b>${current['unit_cost']:.2f}</b><br>
+        • Avg Daily Volume: <b>{seg_hist.tail(7)['qty'].mean():.0f} units</b><br>
+        • Current GM%: <b>{current['gm_pct']*100:.1f}%</b><br>
+        • Price Elasticity: <b>{elasticity:.2f}</b> <small>(% change in volume per 1% price change)</small>
+        </div>
+        """, unsafe_allow_html=True)
+
+        st.markdown("#### 🎯 Test Pricing Strategy")
+
+        # Pricing strategy slider
+        discount_change = st.slider(
+            "Adjust Discount Level (percentage points)",
+            min_value=-10.0,
+            max_value=5.0,
+            value=0.0,
+            step=0.5,
+            help="Negative values reduce discount (increase price), positive values increase discount"
+        )
+
+        if discount_change != 0:
+            sim = simulate_pricing_action(seg_hist, elasticity, -discount_change)
+
+            if sim:
+                # Visualization
+                col_res1, col_res2 = st.columns(2)
+
+                with col_res1:
+                    # Create comparison chart
+                    comparison_data = pd.DataFrame({
+                        'Metric': ['Price', 'Volume', 'GM%'],
+                        'Current': [sim['baseline_price'], sim['baseline_qty'], sim['gm0_pct']*100],
+                        'Projected': [sim['new_price'], sim['new_qty'], sim['gm1_pct']*100]
+                    })
+
+                    fig_comp = go.Figure()
+                    fig_comp.add_trace(go.Bar(
+                        name='Current',
+                        x=comparison_data['Metric'],
+                        y=comparison_data['Current'],
+                        marker_color='#94a3b8'
+                    ))
+                    fig_comp.add_trace(go.Bar(
+                        name='Projected',
+                        x=comparison_data['Metric'],
+                        y=comparison_data['Projected'],
+                        marker_color='#3b82f6'
+                    ))
+
+                    fig_comp.update_layout(
+                        title="Current vs. Projected Performance",
+                        barmode='group',
+                        height=350
+                    )
+                    st.plotly_chart(fig_comp, use_container_width=True)
+
+                with col_res2:
+                    st.markdown("#### 📈 Simulation Results")
+
+                    gm_change = sim['gm1_pct'] - sim['gm0_pct']
+                    rev_change_pct = (sim['revenue_delta'] / (sim['baseline_price'] * sim['baseline_qty'])) * 100 if sim['baseline_price'] * sim['baseline_qty'] > 0 else 0
+                    vol_change_pct = ((sim['new_qty'] - sim['baseline_qty']) / sim['baseline_qty']) * 100 if sim['baseline_qty'] > 0 else 0
+
+                    st.metric(
+                        "Gross Margin Impact",
+                        f"{sim['gm1_pct']*100:.1f}%",
+                        f"{gm_change*100:+.1f}pp"
+                    )
+
+                    st.metric(
+                        "Revenue Impact",
+                        f"${sim['new_price'] * sim['new_qty']:.2f}",
+                        f"{rev_change_pct:+.1f}%"
+                    )
+
+                    st.metric(
+                        "Volume Impact",
+                        f"{sim['new_qty']:.0f} units",
+                        f"{vol_change_pct:+.1f}%"
+                    )
+
+                    # Daily P&L impact
+                    st.markdown(f"""
+                    <div class="insight-box" style="margin-top: 1rem;">
+                    <b>💰 Daily P&L Impact:</b><br>
+                    <span style="font-size: 1.5rem; {'color: #28a745' if sim['gm_delta_value'] > 0 else 'color: #dc3545'}">
+                    ${sim['gm_delta_value']:+.2f}
+                    </span>
+                    </div>
+                    """, unsafe_allow_html=True)
+        else:
+            st.info("👆 Adjust the discount slider above to simulate different pricing strategies")
+
+    else:
+        st.warning("⚠️ Insufficient data for selected segment. Please choose a different combination.")
+
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #666; padding: 2rem 0;">
+    <small>
+    🔒 Demo Mode: Using synthetic SAP-style data for illustration purposes<br>
+    For production deployment, connect to live SAP S/4HANA CDS views or data warehouse
+    </small>
+</div>
+""", unsafe_allow_html=True)