Upload 4 files

app.py

@@ -1,4 +1,5 @@
 import os
+import json
 import time
 import traceback
 import subprocess
@@ -8,6 +9,8 @@ import gradio as gr
 import pandas as pd
 import joblib
 import papermill as pm
+import plotly.express as px
+from huggingface_hub import InferenceClient
 from jupyter_client.kernelspec import KernelSpecManager
 
 BASE_DIR = Path(__file__).resolve().parent
@@ -22,11 +25,20 @@ PIPELINE_CANDIDATES = [
 ]
 
 RUNS_DIR = BASE_DIR / "runs"
+ART_DIR = BASE_DIR / "artifacts"
+PY_FIG_DIR = ART_DIR / "py" / "figures"
+PY_TAB_DIR = ART_DIR / "py" / "tables"
+R_FIG_DIR = ART_DIR / "r" / "figures"
+R_TAB_DIR = ART_DIR / "r" / "tables"
+
 PAPERMILL_TIMEOUT = int(os.environ.get("PAPERMILL_TIMEOUT", "1800"))
+HF_API_KEY = os.environ.get("HF_API_KEY", "").strip()
+MODEL_NAME = os.environ.get("MODEL_NAME", "Qwen/Qwen2.5-7B-Instruct").strip()
 
 
 def ensure_dirs():
-    RUNS_DIR.mkdir(parents=True, exist_ok=True)
+    for p in [RUNS_DIR, PY_FIG_DIR, PY_TAB_DIR, R_FIG_DIR, R_TAB_DIR]:
+        p.mkdir(parents=True, exist_ok=True)
 
 
 def stamp():
@@ -61,7 +73,9 @@ def run_notebook(nb_path: Path, label: str, kernel_name: str | None) -> str:
     if not nb_path.exists():
         return f"❌ {label} not found: {nb_path.name}"
     if not kernel_name:
-        return f"❌ {label} kernel is not available."
+        kernels = ", ".join(sorted(available_kernels().keys())) or "none"
+        return f"❌ {label} kernel is not available.\nAvailable kernels: {kernels}"
+
     try:
         out_path = RUNS_DIR / f"run_{stamp()}_{nb_path.name}"
         pm.execute_notebook(
@@ -76,7 +90,7 @@ def run_notebook(nb_path: Path, label: str, kernel_name: str | None) -> str:
         )
         return f"✅ {label} finished successfully.\nSaved run: {out_path.name}"
     except Exception as e:
-        return f"❌ {label} failed.\n{str(e)}\n\n{traceback.format_exc()[-2500:]}"
+        return f"❌ {label} failed.\n{str(e)}\n\n{traceback.format_exc()[-3000:]}"
 
 
 def run_python():
@@ -151,92 +165,250 @@ def load_data():
     })
 
 
-def dashboard_data():
-    df = load_data()
+def _read_json(path: Path):
+    with open(path, "r", encoding="utf-8") as f:
+        obj = json.load(f)
+    if isinstance(obj, dict):
+        return pd.DataFrame([obj])
+    return pd.DataFrame(obj)
 
-    lines = [f"### Dataset Summary", f"- Total Customers: **{len(df)}**"]
-    if "Exited" in df.columns:
-        churn_rate = round(df["Exited"].mean() * 100, 2)
-        lines.append(f"- Churn Rate: **{churn_rate}%**")
-        lines.append(f"- Churned Customers: **{int(df['Exited'].sum())}**")
-    if "Balance" in df.columns:
-        lines.append(f"- Average Balance: **{round(df['Balance'].mean(), 2)}**")
-    summary = "\n".join(lines)
 
-    geo_df = pd.DataFrame({"Geography": [], "Exited": []})
+def load_latest_table(table_dir: Path):
+    if not table_dir.exists():
+        return None, None
+    files = sorted(
+        [p for p in table_dir.iterdir() if p.suffix.lower() in [".csv", ".json"]],
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+    if not files:
+        return None, None
+
+    path = files[0]
+    try:
+        if path.suffix.lower() == ".csv":
+            df = pd.read_csv(path)
+        else:
+            df = _read_json(path)
+        return path.name, df
+    except Exception as e:
+        return path.name, pd.DataFrame([{"error": str(e)}])
+
+
+def build_interactive_plot(df: pd.DataFrame, title: str):
+    if df is None or df.empty:
+        return px.scatter(title=f"{title}: no data")
+
+    numeric_cols = [c for c in df.columns if pd.api.types.is_numeric_dtype(df[c])]
+    cat_cols = [c for c in df.columns if c not in numeric_cols]
+
+    if cat_cols and numeric_cols:
+        x = cat_cols[0]
+        y = numeric_cols[0]
+        chart_df = df[[x, y]].dropna().copy().head(100)
+        if chart_df.empty:
+            return px.scatter(title=f"{title}: no usable rows")
+        if chart_df[x].nunique() <= 20:
+            fig = px.bar(chart_df, x=x, y=y, title=title)
+        else:
+            fig = px.line(chart_df, x=x, y=y, title=title, markers=True)
+        fig.update_layout(height=380)
+        return fig
+
+    if len(numeric_cols) >= 2:
+        chart_df = df[numeric_cols[:2]].dropna().copy().head(300)
+        fig = px.scatter(
+            chart_df,
+            x=numeric_cols[0],
+            y=numeric_cols[1],
+            title=title
+        )
+        fig.update_layout(height=380)
+        return fig
+
+    if len(numeric_cols) == 1:
+        fig = px.histogram(df, x=numeric_cols[0], title=title)
+        fig.update_layout(height=380)
+        return fig
+
+    return px.scatter(title=f"{title}: unsupported table structure")
+
+
+def build_overview_charts(df: pd.DataFrame):
+    geo_fig = px.scatter(title="Churn by Geography (%)")
+    age_fig = px.scatter(title="Churn by Age Band (%)")
+
     if {"Geography", "Exited"}.issubset(df.columns):
         geo_df = df.groupby("Geography", as_index=False)["Exited"].mean()
         geo_df["Exited"] = (geo_df["Exited"] * 100).round(2)
+        geo_fig = px.bar(geo_df, x="Geography", y="Exited", title="Churn by Geography (%)")
+        geo_fig.update_layout(height=380)
 
-    age_df = pd.DataFrame({"AgeBand": [], "churn_rate": []})
     if {"Age", "Exited"}.issubset(df.columns):
-        tmp = df.copy()
-        tmp["AgeBand"] = pd.cut(
-            tmp["Age"],
+        temp = df.copy()
+        temp["AgeBand"] = pd.cut(
+            temp["Age"],
             bins=[18, 30, 40, 50, 60, 70],
             include_lowest=True
         )
-        age_df = tmp.groupby("AgeBand").agg(churn_rate=("Exited", "mean")).reset_index()
+        age_df = temp.groupby("AgeBand").agg(churn_rate=("Exited", "mean")).reset_index()
         age_df["AgeBand"] = age_df["AgeBand"].astype(str)
         age_df["churn_rate"] = (age_df["churn_rate"] * 100).round(2)
+        age_fig = px.line(age_df, x="AgeBand", y="churn_rate", title="Churn by Age Band (%)", markers=True)
+        age_fig.update_layout(height=380)
+
+    return geo_fig, age_fig
+
+
+def build_dashboard():
+    df = load_data()
+
+    summary_lines = [
+        "### Executive Summary",
+        f"- Total Customers: **{len(df)}**",
+    ]
+    if "Exited" in df.columns:
+        summary_lines.append(f"- Churn Rate: **{round(df['Exited'].mean() * 100, 2)}%**")
+        summary_lines.append(f"- Churned Customers: **{int(df['Exited'].sum())}**")
+    if "Balance" in df.columns:
+        summary_lines.append(f"- Average Balance: **{round(df['Balance'].mean(), 2)}**")
+
+    kernels = ", ".join(sorted(available_kernels().keys())) or "none"
+    summary_lines.append(f"- Available Kernels: **{kernels}**")
+    summary_md = "\n".join(summary_lines)
+
+    geo_fig, age_fig = build_overview_charts(df)
 
-    kernel_info = ", ".join(sorted(available_kernels().keys())) or "none"
-    summary += f"\n- Available Kernels: **{kernel_info}**"
+    py_name, py_df = load_latest_table(PY_TAB_DIR)
+    r_name, r_df = load_latest_table(R_TAB_DIR)
 
-    return summary, geo_df, age_df, df
+    py_status = f"### Python Analysis Output\nLatest table: **{py_name or 'none found'}**"
+    r_status = f"### R Analysis Output\nLatest table: **{r_name or 'none found'}**"
+
+    py_plot = build_interactive_plot(py_df, "Python Analysis Chart")
+    r_plot = build_interactive_plot(r_df, "R Analysis Chart")
+
+    if py_df is None:
+        py_df = pd.DataFrame([{"info": "No Python table found in artifacts/py/tables"}])
+    if r_df is None:
+        r_df = pd.DataFrame([{"info": "No R table found in artifacts/r/tables"}])
+
+    return summary_md, geo_fig, age_fig, py_status, py_plot, py_df, r_status, r_plot, r_df
+
+
+def generate_ai_insight(question: str):
+    if not HF_API_KEY:
+        return "HF_API_KEY is not configured in Space Secrets."
+
+    df = load_data()
+    summary = {
+        "rows": int(len(df)),
+        "churn_rate": round(float(df["Exited"].mean() * 100), 2) if "Exited" in df.columns else None,
+        "avg_balance": round(float(df["Balance"].mean()), 2) if "Balance" in df.columns else None,
+    }
+    py_name, py_df = load_latest_table(PY_TAB_DIR)
+    r_name, r_df = load_latest_table(R_TAB_DIR)
+
+    prompt = f"""
+You are a bank churn strategy assistant.
+Use the dataset summary and analysis outputs to answer in concise business language.
+
+Question: {question}
+
+Dataset summary:
+{json.dumps(summary, ensure_ascii=False)}
+
+Python latest table:
+{py_name}
+{py_df.head(8).to_csv(index=False) if py_df is not None else 'No Python analysis table available.'}
+
+R latest table:
+{r_name}
+{r_df.head(8).to_csv(index=False) if r_df is not None else 'No R analysis table available.'}
+
+Return:
+1. Key finding
+2. Customer retention action
+3. One risk or caveat
+"""
+    try:
+        client = InferenceClient(api_key=HF_API_KEY)
+        try:
+            response = client.chat.completions.create(
+                model=MODEL_NAME,
+                messages=[
+                    {"role": "system", "content": "You are a precise analytics assistant."},
+                    {"role": "user", "content": prompt},
+                ],
+                max_tokens=350,
+            )
+            return response.choices[0].message.content.strip()
+        except Exception:
+            return client.text_generation(
+                prompt,
+                model=MODEL_NAME,
+                max_new_tokens=350,
+            )
+    except Exception as e:
+        return f"AI request failed: {str(e)}"
 
 
 def build_ui():
     css_path = BASE_DIR / "style.css"
     css = css_path.read_text(encoding="utf-8") if css_path.exists() else ""
 
-    with gr.Blocks(title="Bank Churn Dashboard") as demo:
+    with gr.Blocks(title="Bank Churn Intelligence Hub") as demo:
         gr.HTML(f"<style>{css}</style>")
 
         gr.Markdown(
-            "# 🏦 Bank Churn Dashboard\n"
-            "*Run the Python and R analyses first, then review the dashboard and predictions.*",
+            "# 🏦 Bank Churn Intelligence Hub\n"
+            "*Run Python and R analyses, refresh the dashboard, and ask AI for retention ideas.*",
             elem_id="escp_title",
         )
 
-        with gr.Tab("Run Analyses"):
+        with gr.Tab("Analysis Runner"):
+            gr.Markdown("### Execute the analysis workflow")
             with gr.Row():
                 btn_py = gr.Button("Run Python", variant="secondary")
                 btn_r = gr.Button("Run R", variant="secondary")
                 btn_all = gr.Button("Run All", variant="primary")
+            exec_log = gr.Textbox(
+                label="Execution Log",
+                lines=18,
+                max_lines=28,
+                interactive=False,
+            )
+            btn_py.click(run_python, outputs=[exec_log])
+            btn_r.click(run_r, outputs=[exec_log])
+            btn_all.click(run_all, outputs=[exec_log])
 
-            py_log = gr.Textbox(label="Python Log", lines=12, max_lines=18, interactive=False)
-            r_log = gr.Textbox(label="R Log", lines=12, max_lines=18, interactive=False)
-            all_log = gr.Textbox(label="Run All Log", lines=18, max_lines=28, interactive=False)
-
-            btn_py.click(run_python, outputs=[py_log])
-            btn_r.click(run_r, outputs=[r_log])
-            btn_all.click(run_all, outputs=[all_log])
-
-        with gr.Tab("Dashboard"):
+        with gr.Tab("Interactive Dashboard"):
             refresh_btn = gr.Button("Refresh Dashboard", variant="primary")
             summary_md = gr.Markdown()
+
+            with gr.Row():
+                geo_plot = gr.Plot(label="Churn by Geography")
+                age_plot = gr.Plot(label="Churn by Age Band")
+
+            with gr.Row():
+                py_status = gr.Markdown()
+                r_status = gr.Markdown()
+
+            with gr.Row():
+                py_plot = gr.Plot(label="Python Analysis Plot")
+                r_plot = gr.Plot(label="R Analysis Plot")
+
             with gr.Row():
-                geo_plot = gr.BarPlot(
-                    x="Geography",
-                    y="Exited",
-                    title="Churn by Geography (%)",
-                    vertical=False
-                )
-                age_plot = gr.LinePlot(
-                    x="AgeBand",
-                    y="churn_rate",
-                    title="Churn by Age Band (%)"
-                )
-            data_table = gr.Dataframe(label="Customer Data", interactive=True)
+                py_table = gr.Dataframe(label="Python Analysis Table", interactive=True)
+                r_table = gr.Dataframe(label="R Analysis Table", interactive=True)
 
             refresh_btn.click(
-                dashboard_data,
-                outputs=[summary_md, geo_plot, age_plot, data_table]
+                build_dashboard,
+                outputs=[summary_md, geo_plot, age_plot, py_status, py_plot, py_table, r_status, r_plot, r_table],
             )
             demo.load(
-                dashboard_data,
-                outputs=[summary_md, geo_plot, age_plot, data_table]
+                build_dashboard,
+                outputs=[summary_md, geo_plot, age_plot, py_status, py_plot, py_table, r_status, r_plot, r_table],
             )
 
         with gr.Tab("Prediction"):
@@ -247,10 +419,21 @@ def build_ui():
             pred_out = gr.Textbox(label="Prediction Result")
             pred_btn.click(predict, inputs=[age, balance], outputs=[pred_out])
 
+        with gr.Tab("AI Insight"):
+            gr.Markdown("### Ask AI to interpret the Python and R analysis outputs")
+            ai_q = gr.Textbox(
+                label="Question",
+                placeholder="What does the latest Python and R analysis suggest about churn risk?"
+            )
+            ai_btn = gr.Button("Generate AI Insight", variant="primary")
+            ai_out = gr.Textbox(label="AI Response", lines=12)
+            ai_btn.click(generate_ai_insight, inputs=[ai_q], outputs=[ai_out])
+
     return demo
 
 
 if __name__ == "__main__":
+    ensure_dirs()
     demo = build_ui()
     demo.queue()
     port = int(os.environ.get("PORT", 7860))

requirements.txt

@@ -11,6 +11,7 @@ papermill>=2.5.0
 nbformat>=5.9.0
 ipykernel>=6.29.0
 jupyter_client>=8.6.0
+plotly>=5.24.0
 pillow>=10.0.0
 requests>=2.31.0
 beautifulsoup4>=4.12.0

style.css

@@ -1,4 +1,4 @@
-/* Background restored to first-app style logic */
+/* Background restored close to the first app */
 gradio-app,
 .gradio-app,
 .main,
@@ -7,12 +7,9 @@ gradio-app,
   background-color: rgb(15, 23, 42) !important;
   background-image:
     url("https://huggingface.co/spaces/XRachel/bc4/resolve/main/assets/BankChurn.png") !important;
-  background-position:
-    top center !important;
-  background-repeat:
-    no-repeat !important;
-  background-size:
-    100% auto !important;
+  background-position: top center !important;
+  background-repeat: no-repeat !important;
+  background-size: 100% auto !important;
   min-height: 100vh !important;
 }
 
@@ -23,17 +20,15 @@ html, body {
   min-height: 100vh !important;
 }
 
-/* Top spacing like the first app */
 .gradio-container {
   max-width: 1400px !important;
   width: 94vw !important;
   margin: 0 auto !important;
   padding-top: 220px !important;
-  padding-bottom: 150px !important;
+  padding-bottom: 140px !important;
   background: transparent !important;
 }
 
-/* Title */
 #escp_title h1 {
   color: rgb(242, 198, 55) !important;
   font-size: 3rem !important;
@@ -44,15 +39,13 @@ html, body {
 
 #escp_title p,
 #escp_title em {
-  color: rgba(255, 255, 255, 0.90) !important;
+  color: rgba(255, 255, 255, 0.9) !important;
   text-align: center !important;
 }
 
-/* Tabs */
 .tabs > .tab-nav,
 .tab-nav,
-div[role="tablist"],
-.svelte-tabs > .tab-nav {
+div[role="tablist"] {
   background: rgba(15, 23, 42, 0.60) !important;
   border-radius: 10px 10px 0 0 !important;
   padding: 4px !important;
@@ -61,10 +54,7 @@ div[role="tablist"],
 .tabs > .tab-nav button,
 .tab-nav button,
 div[role="tablist"] button,
-button[role="tab"],
-.svelte-tabs button,
-.tab-nav > button,
-.tabs button {
+button[role="tab"] {
   color: #ffffff !important;
   font-weight: 600 !important;
   border: none !important;
@@ -77,45 +67,30 @@ button[role="tab"],
 .tabs > .tab-nav button.selected,
 .tab-nav button.selected,
 button[role="tab"][aria-selected="true"],
-button[role="tab"].selected,
-div[role="tablist"] button[aria-selected="true"],
-.svelte-tabs button.selected {
+div[role="tablist"] button[aria-selected="true"] {
   color: rgb(242, 198, 55) !important;
   background: rgba(255, 255, 255, 0.12) !important;
 }
 
-.tabs > .tab-nav button:not(.selected),
-.tab-nav button:not(.selected),
-button[role="tab"][aria-selected="false"],
-button[role="tab"]:not(.selected),
-div[role="tablist"] button:not([aria-selected="true"]) {
-  color: #ffffff !important;
-  opacity: 1 !important;
-}
-
-/* White cards */
 .gradio-container .gr-block,
 .gradio-container .gr-box,
 .gradio-container .gr-panel,
-.gradio-container .gr-group {
-  background: #ffffff !important;
-  border-radius: 10px !important;
+.gradio-container .gr-group,
+.tabitem {
+  background: rgba(255, 255, 255, 0.97) !important;
+  border-radius: 12px !important;
 }
 
 .tabitem {
-  background: rgba(255, 255, 255, 0.96) !important;
-  border-radius: 0 0 10px 10px !important;
   padding: 16px !important;
 }
 
-/* Inputs */
 .gradio-container input,
 .gradio-container textarea,
 .gradio-container select {
   border-radius: 10px !important;
 }
 
-/* Buttons */
 button:not([role="tab"]) {
   border-radius: 10px !important;
   font-weight: 700 !important;