Update app.py

app.py

@@ -1,9 +1,9 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-import pickle
 import plotly.express as px
 import plotly.graph_objects as go
+import statsmodels.api as sm
 
 # =======================
 # LOAD DATA
@@ -14,146 +14,218 @@ df_long = pd.concat([
     pd.DataFrame({
         "year": df["Year"],
         "acpl": df["White.ACPL"],
-        "player": df["White.Player"]
+        "player": df["White.Player"],
+        "color": "White"
     }),
     pd.DataFrame({
         "year": df["Year"],
         "acpl": df["Black.ACPL"],
-        "player": df["Black.Player"]
+        "player": df["Black.Player"],
+        "color": "Black"
     })
 ]).dropna()
 
 df_long["engine"] = np.where(df_long["year"] >= 1996, "Post-1996", "Pre-1996")
 
-players = sorted(df_long["player"].unique().tolist())
+players = sorted(df_long["player"].dropna().unique().tolist())
 
 # =======================
-# LOAD MODEL
+# GLOBAL CACHE
 # =======================
-with open("acpl_trend_model.pkl", "rb") as f:
-    model = pickle.load(f)
+PLOTS = {}
+player_cache = {}
 
 # =======================
-# PRECOMPUTE EVERYTHING
+# PRECOMPUTE PLOTS
 # =======================
+def build_all_plots():
+    global PLOTS
+
+    # ---- OVERVIEW ----
+    fig_overview = px.scatter(
+        df_long,
+        x="year",
+        y="acpl",
+        opacity=0.3,
+        title="📈 Performance Over Time"
+    )
+    fig_overview.update_layout(template="plotly_white")
+
+    # ---- ENGINE ----
+    fig_engine = px.scatter(
+        df_long,
+        x="year",
+        y="acpl",
+        color="engine",
+        opacity=0.3,
+        title="🤖 Engine Effect (Pre vs Post 1996)"
+    )
+    fig_engine.update_layout(template="plotly_white")
 
-# 🔹 Sample for fast plots
-df_sample = df_long.sample(min(len(df_long), 800))
-
-# 🔹 Overview plot (ONCE)
-overview_fig = px.scatter(
-    df_sample, x="year", y="acpl",
-    opacity=0.3, render_mode="webgl"
-)
-
-# 🔹 Engine plot (ONCE)
-engine_fig = px.scatter(
-    df_sample, x="year", y="acpl",
-    color="engine", opacity=0.3,
-    render_mode="webgl"
-)
-
-# 🔹 Prediction plot (ONCE)
-df_sorted = df_long.sort_values("year")
-df_sorted["pred"] = model.predict(
-    pd.DataFrame({"const": 1, "year": df_sorted["year"]})
-)
-
-future = pd.DataFrame({
-    "year": np.arange(df_long["year"].max(), df_long["year"].max()+10)
-})
-future["pred"] = model.predict(
-    pd.DataFrame({"const": 1, "year": future["year"]})
-)
-
-prediction_fig = go.Figure()
-prediction_fig.add_trace(go.Scatter(
-    x=df_sample["year"], y=df_sample["acpl"],
-    mode="markers", opacity=0.2
-))
-prediction_fig.add_trace(go.Scatter(
-    x=df_sorted["year"], y=df_sorted["pred"],
-    mode="lines"
-))
-prediction_fig.add_trace(go.Scatter(
-    x=future["year"], y=future["pred"],
-    mode="lines", line=dict(dash="dash")
-))
-
-# 🔹 PLAYER PLOTS (PRECOMPUTE ALL)
-player_cache = {}
+    # ---- PREDICTION ----
+    X = sm.add_constant(df_long["year"])
+    model = sm.OLS(df_long["acpl"], X).fit()
 
-for p in players:
-    data = df_long[df_long["player"] == p]
-    data = data.sample(min(len(data), 150))
+    df_sorted = df_long.sort_values("year")
+    df_sorted["pred"] = model.predict(sm.add_constant(df_sorted["year"]))
 
-    fig = px.scatter(
-        data, x="year", y="acpl",
-        render_mode="webgl"
+    future_years = pd.DataFrame({
+        "year": np.arange(df_long["year"].max(), df_long["year"].max() + 10)
+    })
+    future_years["pred"] = model.predict(sm.add_constant(future_years["year"]))
+
+    fig_pred = go.Figure()
+
+    # Actual data
+    fig_pred.add_trace(go.Scatter(
+        x=df_sorted["year"],
+        y=df_sorted["acpl"],
+        mode="markers",
+        opacity=0.2,
+        name="Observed"
+    ))
+
+    # Trend line
+    fig_pred.add_trace(go.Scatter(
+        x=df_sorted["year"],
+        y=df_sorted["pred"],
+        mode="lines",
+        name="Trend"
+    ))
+
+    # Future prediction
+    fig_pred.add_trace(go.Scatter(
+        x=future_years["year"],
+        y=future_years["pred"],
+        mode="lines",
+        line=dict(dash="dash"),
+        name="Future"
+    ))
+
+    fig_pred.update_layout(
+        title="🔮 Future Performance Trend",
+        xaxis_title="Year",
+        yaxis_title="ACPL",
+        template="plotly_white"
     )
 
-    avg = data["acpl"].mean()
-    player_cache[p] = (f"Avg ACPL: {avg:.2f}", fig)
+    # Save in cache
+    PLOTS["overview"] = fig_overview
+    PLOTS["engine"] = fig_engine
+    PLOTS["prediction"] = fig_pred
+
+
+# Run once at startup
+build_all_plots()
 
 # =======================
-# FUNCTIONS (FAST SWITCH)
+# FUNCTIONS (FAST)
 # =======================
 
-def get_player(p):
-    return player_cache[p]
+def overview_plot():
+    return PLOTS["overview"]
+
+def engine_plot():
+    return PLOTS["engine"]
+
+def prediction_plot():
+    return PLOTS["prediction"]
 
-def get_overview():
-    return overview_fig
+def player_analysis(player):
+    if player in player_cache:
+        return player_cache[player]
 
-def get_engine():
-    return engine_fig
+    data = df_long[df_long["player"] == player]
 
-def get_prediction():
-    return prediction_fig
+    avg = data["acpl"].mean()
+    games = len(data)
+
+    fig = px.scatter(
+        data,
+        x="year",
+        y="acpl",
+        title=f"{player} Performance",
+    )
+    fig.update_layout(template="plotly_white")
+
+    result = (f"Avg ACPL: {avg:.2f} | Games: {games}", fig)
+    player_cache[player] = result
+
+    return result
+
+
+def summary_stats():
+    avg_acpl = df_long["acpl"].mean()
+    player_stats = df_long.groupby("player")["acpl"].mean()
+    best_player = player_stats.idxmin()
+
+    return f"📊 Avg ACPL: {avg_acpl:.2f}", f"🏆 Best Player: {best_player}"
 
-def stats():
-    avg = df_long["acpl"].mean()
-    best = df_long.groupby("player")["acpl"].mean().idxmin()
-    return f"{avg:.2f}", best
 
 # =======================
 # UI
 # =======================
 
-with gr.Blocks() as app:
+with gr.Blocks(theme=gr.themes.Soft()) as app:
 
-    gr.Markdown("# ♟️ Chess Dashboard")
+    # Header
+    gr.Markdown(
+        """
+        # ♟️ Chess Performance Dashboard  
+        Explore how player performance has improved over time.
+        """
+    )
 
+    # KPI row
     with gr.Row():
-        k1 = gr.Textbox(label="Avg ACPL")
-        k2 = gr.Textbox(label="Best Player")
+        kpi1 = gr.Textbox(label="Average Performance", interactive=False)
+        kpi2 = gr.Textbox(label="Top Player", interactive=False)
 
-    app.load(stats, outputs=[k1, k2])
+    app.load(summary_stats, outputs=[kpi1, kpi2])
 
+    # Layout
     with gr.Row():
 
+        # Sidebar
         with gr.Column(scale=1):
-            player_dd = gr.Dropdown(players, value=players[0])
-
+            gr.Markdown("## ⚙️ Controls")
+
+            player_dropdown = gr.Dropdown(
+                players,
+                label="Select Player",
+                value=players[0]
+            )
+
+            gr.Markdown("### 💡 Tips")
+            gr.Markdown("""
+            - Lower ACPL = better  
+            - Compare players  
+            - Observe trends  
+            """)
+
+        # Main content
         with gr.Column(scale=3):
 
             with gr.Tabs():
 
-                with gr.Tab("Overview"):
-                    gr.Plot(get_overview)
+                with gr.Tab("📈 Overview"):
+                    gr.Plot(overview_plot)
 
-                with gr.Tab("Player"):
-                    txt = gr.Textbox()
-                    plot = gr.Plot()
+                with gr.Tab("🏆 Player Analysis"):
+                    output_text = gr.Textbox()
+                    player_plot = gr.Plot()
 
-                    player_dd.change(get_player, player_dd, [txt, plot])
+                    player_dropdown.change(
+                        player_analysis,
+                        inputs=player_dropdown,
+                        outputs=[output_text, player_plot]
+                    )
 
-                with gr.Tab("Engine"):
-                    gr.Plot(get_engine)
+                with gr.Tab("🤖 Engine Impact"):
+                    gr.Plot(engine_plot)
 
-                with gr.Tab("Prediction"):
-                    gr.Plot(get_prediction)
+                with gr.Tab("🔮 Prediction"):
+                    gr.Plot(prediction_plot)
 
-# 🔥 IMPORTANT FOR HUGGINGFACE
-app.queue()   # <-- THIS FIXES FREEZE
-app.launch()
+# Run with queue (important for HF)
+app.queue().launch()