Upload 2 files

app.py

@@ -7,7 +7,7 @@ from sklearn import datasets
 from sklearn.preprocessing import StandardScaler
 from sklearn.decomposition import PCA
 import plotly.graph_objects as go
-import time
+import plotly.express as px
 
 FEATURE_LABELS = {
     "age": "Leeftijd",
@@ -24,31 +24,6 @@ FEATURE_LABELS = {
 }
 LABEL_TO_KEY = {v: k for k, v in FEATURE_LABELS.items()}
 
-MEDICAL_MD = """
-### Medisch nut  
-
-**Wat zien we hier?**  
-Ik heb een bestaande, anonieme gezondheidsdataset gebruikt die speciaal beschikbaar is gemaakt voor onderzoek en studie. In deze gegevens staan metingen van een grote groep patiënten, zoals **bloedwaarden, BMI, cholesterol en bloedsuiker**.  
-
-Zo'n enorme berg cijfers is voor artsen en ziekenhuizen bijna niet in één keer te overzien. Het is gewoon te veel om met het blote oog patronen uit te halen.  
-
-**Daar komt kunstmatige intelligentie om de hoek kijken.**  
-Met deze techniek (PCA) kan de computer de data slim samenvatten en patronen zichtbaar maken. Dit programma dat ik heb ontworpen laat live zien hoe die samenvatting werkt.  
-
-- Elke punt is één patiënt.  
-- De kleur laat zien hoe hoog of laag een bepaalde meting is (standaard: BMI).  
-- De pijlen laten zien welke metingen het meeste invloed hebben.  
-- Links bovenin kun je kiezen welke meting je als uitgangspunt wilt nemen.  
-
-**En wat heb je hieraan?**  
-In de praktijk gebruiken artsen en onderzoekers zo'n plot om patronen en verbanden te ontdekken. 👉 Het is dus niet alleen een mooi plaatje, maar echt een manier om grote hoeveelheden data sneller en slimmer te begrijpen.  
-
-Met AI kunnen we patronen vinden die je met het blote oog nooit zou zien. Dat maakt dit niet alleen een mooie visualisatie, maar ook een knap stukje technologie met échte waarde voor onderzoek en zorg.  
-
-**Speel zelf de onderzoeker!**  
-Doe alsof je een arts bent en kies links bovenin een waarde, bijvoorbeeld **cholesterol**, **leeftijd** of **geslacht**. Klik daarna op *Update visualisaties* en ontdek je eigen patronen in de data.  
-"""
-
 def load_diabetes_df():
     d = datasets.load_diabetes()
     X = pd.DataFrame(d.data, columns=d.feature_names)
@@ -57,293 +32,101 @@ def load_diabetes_df():
     df["target"] = y
     return df
 
-def compute_overview_table(df: pd.DataFrame):
-    keys = ["bmi","bp","s1","s2","s3","s4","s5","s6"]
-    rows = []
-    for k in keys:
-        vals = df[k].dropna().values
-        if vals.size == 0:
-            continue
-        mean = float(vals.mean())
-        pct_above = float((vals > 0).mean() * 100.0)  # standardized: 0 ~ mean
-        pct_below = float((vals < 0).mean() * 100.0)
-        rows.append({
-            "Meting": FEATURE_LABELS.get(k, k),
-            "Gemiddelde (gestandaardiseerd)": round(mean, 3),
-            "% boven gemiddelde": round(pct_above, 1),
-            "% onder gemiddelde": round(pct_below, 1),
-        })
-    table = pd.DataFrame(rows)
-    note = ("Let op: waarden in deze dataset zijn **gestandaardiseerd**. "
-            "`0` betekent ongeveer het **algemene gemiddelde**. "
-            "Positief = hoger dan gemiddeld, negatief = lager dan gemiddeld.")
-    return table, note
-
-def compute_top_correlations(df: pd.DataFrame, top_n: int = 6):
-    feats = [c for c in df.columns if c != "target"]
-    corr = pd.DataFrame(df[feats]).corr()
-    pairs = []
-    for i, a in enumerate(feats):
-        for j, b in enumerate(feats):
-            if j <= i:
-                continue
-            pairs.append({
-                "Combinatie": f"{FEATURE_LABELS.get(a,a)} ↔ {FEATURE_LABELS.get(b,b)}",
-                "Correlatie": corr.loc[a, b]
-            })
-    out = pd.DataFrame(pairs)
-    out["Sterkte (|r|)"] = out["Correlatie"].abs()
-    out = out.sort_values("Sterkte (|r|)", ascending=False).head(top_n).reset_index(drop=True)
-    out["Correlatie"] = out["Correlatie"].round(3)
-    out["Sterkte (|r|)"] = out["Sterkte (|r|)"].round(3)
-    return out[["Combinatie", "Correlatie", "Sterkte (|r|)"]]
-
-def compute_pca(df: pd.DataFrame, n_components: int, standardize: bool):
+def compute_pca(df, n_components=10, standardize=True):
     feats = [c for c in df.columns if c != "target"]
     X = df[feats].values
     if standardize:
-        scaler = StandardScaler(with_mean=True, with_std=True)
+        scaler = StandardScaler()
         Xs = scaler.fit_transform(X)
     else:
         Xs = X
-    pca = PCA(n_components=min(int(n_components), Xs.shape[1]))
+    pca = PCA(n_components=min(n_components, Xs.shape[1]))
     Z = pca.fit_transform(Xs)
     loadings = pca.components_.T
     expl = pca.explained_variance_ratio_
     return feats, Xs, Z, loadings, expl
 
-def build_biplot(Z, loadings, feats, color_vals, arrow_scale, point_size, alpha, color_label_nl):
-    fig = plt.figure(figsize=(7.8, 5.6))
-    ax = fig.add_subplot(111)
-    sc = ax.scatter(Z[:, 0], Z[:, 1], c=color_vals, s=point_size, alpha=alpha)
-    cbar = plt.colorbar(sc, ax=ax, pad=0.02)
-    cbar.set_label(f"Kleur: {color_label_nl}")
-    ax.set_xlabel("PC1"); ax.set_ylabel("PC2")
-    ax.set_title("PCA-biplot — punten (patiënten) + pijlen (belangrijkste metingen)")
-    for i, key in enumerate(feats):
-        x_arrow = loadings[i, 0] * arrow_scale
-        y_arrow = loadings[i, 1] * arrow_scale
-        ax.arrow(0, 0, x_arrow, y_arrow, head_width=0.05, head_length=0.08, fc="k", ec="k", length_includes_head=True)
-        ax.text(x_arrow * 1.08, y_arrow * 1.08, FEATURE_LABELS.get(key, key), fontsize=9, ha="center", va="center")
-    ax.axhline(0, color="grey", linewidth=0.6, linestyle=":")
-    ax.axvline(0, color="grey", linewidth=0.6, linestyle=":")
-    ax.grid(True, linestyle=":", linewidth=0.6)
-    plt.tight_layout()
+def build_biplot(df, Z, loadings, feats, color_key):
+    hover_text = []
+    for idx in range(len(df)):
+        parts = [f"{FEATURE_LABELS.get(k,k)}: {df.iloc[idx][k]:.3f}" for k in df.columns]
+        hover_text.append("<br>".join(parts))
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=Z[:,0], y=Z[:,1], mode="markers",
+                             marker=dict(size=7, color=df[color_key].values),
+                             text=hover_text,
+                             hovertemplate="%{text}<extra></extra>"))
+    # arrows
+    scale=2.0
+    for i,key in enumerate(feats):
+        x = loadings[i,0]*scale; y = loadings[i,1]*scale
+        fig.add_annotation(x=x, y=y, ax=0, ay=0, showarrow=True, arrowhead=3)
+        fig.add_annotation(x=x*1.05, y=y*1.05, text=FEATURE_LABELS.get(key,key), showarrow=False, font=dict(size=10))
+    fig.update_layout(title="PCA-biplot (2D, hover)", xaxis_title="PC1", yaxis_title="PC2", height=500)
+    return fig
+
+def build_pca3d(Z3, color_vals):
+    fig = go.Figure(data=[go.Scatter3d(x=Z3[:,0], y=Z3[:,1], z=Z3[:,2], mode="markers",
+                                       marker=dict(size=4,color=color_vals,opacity=0.85))])
+    fig.update_layout(title="PCA 3D", scene=dict(xaxis_title="PC1", yaxis_title="PC2", zaxis_title="PC3"), height=500)
     return fig
 
 def build_variance_plot(expl):
-    fig = plt.figure(figsize=(7.8, 3.8))
+    fig = plt.figure()
     ax = fig.add_subplot(111)
-    xs = np.arange(1, len(expl) + 1)
-    ax.bar(xs, expl, width=0.8, align="center")
-    ax.plot(xs, np.cumsum(expl), marker="o")
-    ax.set_xticks(xs)
-    ax.set_xlabel("Principal Component")
-    ax.set_ylabel("Explained variance ratio")
-    ax.set_title("Uitlegvariantie per component (balken) + cumulatief (lijn)")
-    ax.grid(True, linestyle=":", linewidth=0.6)
-    plt.tight_layout()
+    xs = np.arange(1,len(expl)+1)
+    ax.bar(xs, expl); ax.plot(xs, np.cumsum(expl), marker="o")
+    ax.set_xlabel("PC"); ax.set_ylabel("Explained variance ratio")
+    fig.tight_layout()
     return fig
 
-def build_pca3d(Z3, color_vals, color_label_nl, point_size, alpha):
-    # Plotly 3D scatter for real rotation/drag
-    fig = go.Figure(data=[go.Scatter3d(
-        x=Z3[:, 0], y=Z3[:, 1], z=Z3[:, 2],
-        mode="markers",
-        marker=dict(size=max(2, int(point_size/2)), color=color_vals, opacity=alpha)
-    )])
-    fig.update_layout(
-        title="PCA 3D — PC1 · PC2 · PC3",
-        scene=dict(xaxis_title="PC1", yaxis_title="PC2", zaxis_title="PC3"),
-        margin=dict(l=0, r=0, t=40, b=0),
-        height=520
-    )
+def build_corr_heatmap(df):
+    feats = [c for c in df.columns if c != "target"]
+    corr = pd.DataFrame(df[feats]).corr()
+    order = corr.abs().sum().sort_values(ascending=False).index.tolist()
+    corr_sorted = corr.loc[order, order]
+    fig = px.imshow(corr_sorted, color_continuous_scale="RdBu", origin="lower", zmin=-1, zmax=1)
+    fig.update_layout(title="Correlatie-heatmap")
     return fig
 
-def pca_biplot(color_label="BMI (Body Mass Index)", arrow_scale=2.0, point_size=32, alpha=0.85, n_components=10, standardize=True, show_3d=False):
-    df = load_diabetes_df()
-    overview_df, overview_note = compute_overview_table(df)
-    corr_tbl = compute_top_correlations(df)
-
-    feats, Xs, Z, loadings, expl = compute_pca(df, n_components, standardize)
-    color_key = LABEL_TO_KEY.get(color_label, "bmi")
-    color_label_nl = FEATURE_LABELS.get(color_key, color_key)
-    color_vals = df[color_key].values
-
-    fig1 = build_biplot(Z, loadings, feats, color_vals, arrow_scale, point_size, alpha, color_label_nl)
-    fig2 = build_variance_plot(expl)
-
-    load_df = pd.DataFrame({
-        "feature_key": feats,
-        "PC1_loading": loadings[:, 0],
-        "PC2_loading": loadings[:, 1],
-        "PC1_abs": np.abs(loadings[:, 0]),
-        "PC2_abs": np.abs(loadings[:, 1]),
-    })
-    load_df["Feature (PC1)"] = load_df["feature_key"].map(lambda k: FEATURE_LABELS.get(k, k))
-    load_df["Feature (PC2)"] = load_df["feature_key"].map(lambda k: FEATURE_LABELS.get(k, k))
-    top_pc1 = load_df.sort_values("PC1_abs", ascending=False)[["Feature (PC1)", "PC1_loading"]].head(6).reset_index(drop=True)
-    top_pc2 = load_df.sort_values("PC2_abs", ascending=False)[["Feature (PC2)", "PC2_loading"]].head(6).reset_index(drop=True)
-    max_len = max(len(top_pc1), len(top_pc2))
-    top_pc1 = top_pc1.reindex(range(max_len)); top_pc2 = top_pc2.reindex(range(max_len))
-    table = pd.concat([top_pc1, top_pc2], axis=1)
+def build_hist_box(df, color_key):
+    series = df[color_key]
+    fig_hist = px.histogram(series, nbins=30, title=f"Histogram — {FEATURE_LABELS.get(color_key,color_key)}")
+    fig_box = px.box(series, points="outliers", title=f"Boxplot — {FEATURE_LABELS.get(color_key,color_key)}")
+    return fig_hist, fig_box
 
-    summary_md = f"""
-### Wat zie je hier?
-- **Punten (patiënten)** geprojecteerd in 2D met **PCA**. Dicht bij elkaar = **lijken op elkaar** over meerdere metingen.
-- **Kleur** = **{color_label_nl}**. Zo zie je meteen of deze eigenschap een **gradiënt** vormt.
-- **Pijlen** = bijdrage van **metingen** aan de richting van **PC1/PC2**. **Langere pijlen** wegen zwaarder.
-- **Balkgrafiek** = per component hoeveel variatie hij uitlegt; **lijn** = cumulatief.
-"""
-
-    # 3D
-    if show_3d:
-        # Zorg dat we minstens 3 componenten hebben
-        if Z.shape[1] < 3:
-            pca3 = PCA(n_components=3)
-            Z3 = pca3.fit_transform(Xs)
-        else:
-            Z3 = Z[:, :3]
-        fig3 = build_pca3d(Z3, color_vals, color_label_nl, point_size, alpha)
-        pca3d_out = gr.update(value=fig3, visible=True)
-    else:
-        pca3d_out = gr.update(value=None, visible=False)
-
-    return fig1, fig2, table, summary_md, overview_df, overview_note, corr_tbl, pca3d_out
-
-def animate_pca(color_label="BMI (Body Mass Index)", point_size=32, alpha=0.85, n_components=10, standardize=True, frames=40, pause=0.0):
+def controller(color_label="BMI (Body Mass Index)", n_components=10, standardize=True):
     df = load_diabetes_df()
     feats, Xs, Z, loadings, expl = compute_pca(df, n_components, standardize)
-    color_key = LABEL_TO_KEY.get(color_label, "bmi")
-    color_vals = df[color_key].values
-    for i in range(frames):
-        t = i / max(1, frames-1)
-        w1 = min(1.0, t * 2.0)
-        w2 = max(0.0, (t - 0.5) * 2.0)
-        coords = np.column_stack([Z[:, 0] * w1, Z[:, 1] * w2])
-        fig = plt.figure(figsize=(7.8, 5.6))
-        ax = fig.add_subplot(111)
-        ax.scatter(coords[:, 0], coords[:, 1], c=color_vals, s=point_size, alpha=alpha)
-        ax.set_xlabel("PC1 (opbouw)"); ax.set_ylabel("PC2 (opbouw)")
-        title = "PCA-projectie (animatie) — " + ("PC1 →" if w2 == 0 else "PC1 + PC2")
-        ax.set_title(f"{title} — frame {i+1}/{frames}")
-        ax.axhline(0, color="grey", linewidth=0.6, linestyle=":")
-        ax.axvline(0, color="grey", linewidth=0.6, linestyle=":")
-        ax.grid(True, linestyle=":", linewidth=0.6)
-        plt.tight_layout()
-        yield fig
-        if pause > 0:
-            time.sleep(pause)
-
-def export_biplot_png(color_label="BMI (Body Mass Index)", arrow_scale=2.0, point_size=32, alpha=0.85, n_components=10, standardize=True):
-    df = load_diabetes_df()
-    feats, Xs, Z, loadings, expl = compute_pca(df, n_components, standardize)
-    color_key = LABEL_TO_KEY.get(color_label, "bmi")
-    color_label_nl = FEATURE_LABELS.get(color_key, color_key)
-    color_vals = df[color_key].values
-    fig = build_biplot(Z, loadings, feats, color_vals, arrow_scale, point_size, alpha, color_label_nl)
-    path = f"/mnt/data/biplot_{int(time.time())}.png"
-    fig.savefig(path, dpi=150, bbox_inches="tight")
-    plt.close(fig)
-    return path
-
-def export_variance_png(n_components=10, standardize=True):
-    df = load_diabetes_df()
-    feats, Xs, Z, loadings, expl = compute_pca(df, n_components, standardize)
-    fig = build_variance_plot(expl)
-    path = f"/mnt/data/variance_{int(time.time())}.png"
-    fig.savefig(path, dpi=150, bbox_inches="tight")
-    plt.close(fig)
-    return path
-
-with gr.Blocks(title="PCA Biplot — Diabetes (Dashboard)") as demo:
-    gr.HTML("""
-    <style>
-      .card {background:#fff; border:1px solid #e5e7eb; border-radius:12px; padding:14px; box-shadow: 0 1px 4px rgba(0,0,0,0.06);}
-      .callout {padding:12px 14px; border-left:4px solid #2563eb; background:#f1f5f9; border-radius:8px; margin: 8px 0 18px;}
-      .smallnote {font-size: 0.92em; opacity: 0.85;}
-    </style>
-    """)
-
-    gr.Markdown("# PCA Biplot — Diabetes (Dashboard)")
-    gr.Markdown(MEDICAL_MD)
-
+    color_key = LABEL_TO_KEY[color_label]
+    fig2d = build_biplot(df, Z, loadings, feats, color_key)
+    if Z.shape[1] < 3:
+        pca3 = PCA(n_components=3); Z3 = pca3.fit_transform(Xs)
+    else:
+        Z3 = Z[:,:3]
+    fig3d = build_pca3d(Z3, df[color_key].values)
+    fig_var = build_variance_plot(expl)
+    fig_heat = build_corr_heatmap(df)
+    fig_hist, fig_box = build_hist_box(df, color_key)
+    return fig2d, fig3d, fig_var, fig_heat, fig_hist, fig_box
+
+with gr.Blocks() as demo:
+    gr.Markdown("# PCA Dashboard — Diabetes")
     with gr.Row():
-        with gr.Column(scale=1):
-            with gr.Group():
-                gr.Markdown("### Instellingen")
-                color_choices = [FEATURE_LABELS[k] for k in ["bmi","bp","s1","s2","s3","s4","s5","s6","age","sex","target"]]
-                color_feat = gr.Dropdown(choices=color_choices, value=FEATURE_LABELS["bmi"], label="Kleur op meting")
-                arrow_scale = gr.Slider(0.5, 5.0, value=2.0, step=0.1, label="Pijl-schaal (loadings)")
-                point_size = gr.Slider(8, 80, value=32, step=2, label="Puntgrootte")
-                alpha = gr.Slider(0.2, 1.0, value=0.85, step=0.05, label="Transparantie (punten)")
-                n_components = gr.Slider(2, 10, value=10, step=1, label="Aantal PCA-componenten")
-                standardize = gr.Checkbox(value=True, label="Standaardiseer metingen (aanbevolen)")
-                show_3d = gr.Checkbox(value=True, label="Toon 3D PCA (PC1–PC3)")
-                run_btn = gr.Button("Update visualisaties")
-                gr.HTML('<div class="callout smallnote">💡 <b>Tip:</b> Kies links een meting (bijv. BMI of cholesterol) en klik daarna op <b>Update visualisaties</b>.</div>')
-            with gr.Group():
-                gr.Markdown("### Animatie")
-                animate_btn = gr.Button("▶ Animate PCA (PC1 → PC2)")
-                anim_plot = gr.Plot(label="Animatie van projectie")
-
-            with gr.Group():
-                gr.Markdown("### Downloads")
-                dl_biplot = gr.DownloadButton("Download biplot (PNG)")
-                dl_var = gr.DownloadButton("Download variatieplot (PNG)")
-                file_biplot = gr.File(label="Biplot PNG", visible=False)
-                file_var = gr.File(label="Variatieplot PNG", visible=False)
-
-        with gr.Column(scale=2):
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Biplot (2D)")
-                    plot_biplot = gr.Plot()
-                with gr.Column():
-                    gr.Markdown("### Uitlegvariantie")
-                    plot_expl = gr.Plot()
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Top-features (PC1 / PC2)")
-                    table = gr.Dataframe(headers=["Feature (PC1)", "Loading PC1", "Feature (PC2)", "Loading PC2"], row_count=6)
-                with gr.Column():
-                    gr.Markdown("### Overzicht (gemiddelden & verdeling)")
-                    overview_tbl = gr.Dataframe(interactive=False)
-                    overview_note_md = gr.Markdown()
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Samenvatting")
-                    summary = gr.Markdown()
-                with gr.Column():
-                    gr.Markdown("### Top correlaties (features)")
-                    topcorr_tbl = gr.Dataframe(interactive=False)
-            with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### 3D PCA (PC1–PC3 — sleep om te draaien)")
-                    plot3d = gr.Plot(visible=True)
-
-    inputs = [color_feat, arrow_scale, point_size, alpha, n_components, standardize, show_3d]
-    run_btn.click(fn=pca_biplot, inputs=inputs,
-                  outputs=[plot_biplot, plot_expl, table, summary, overview_tbl, overview_note_md, topcorr_tbl, plot3d])
-    demo.load(fn=pca_biplot, inputs=inputs,
-              outputs=[plot_biplot, plot_expl, table, summary, overview_tbl, overview_note_md, topcorr_tbl, plot3d])
-
-    animate_btn.click(fn=animate_pca,
-                      inputs=[color_feat, point_size, alpha, n_components, standardize],
-                      outputs=anim_plot)
+        color_feat = gr.Dropdown(choices=list(LABEL_TO_KEY.keys()), value="BMI (Body Mass Index)", label="Kleur op meting")
+        n_components = gr.Slider(3,10,10,step=1,label="Aantal PCA-componenten")
+        standardize = gr.Checkbox(value=True,label="Standaardiseer")
+        run_btn = gr.Button("Update")
+    with gr.Row():
+        plot2d = gr.Plot(); plot3d = gr.Plot()
+    with gr.Row():
+        plot_var = gr.Plot(); plot_heat = gr.Plot()
+    with gr.Row():
+        plot_hist = gr.Plot(); plot_box = gr.Plot()
 
-    dl_biplot.click(fn=export_biplot_png,
-                    inputs=[color_feat, arrow_scale, point_size, alpha, n_components, standardize],
-                    outputs=[dl_biplot])
-    dl_biplot.click(fn=export_biplot_png,
-                    inputs=[color_feat, arrow_scale, point_size, alpha, n_components, standardize],
-                    outputs=[file_biplot])
-    dl_var.click(fn=export_variance_png,
-                 inputs=[n_components, standardize],
-                 outputs=[dl_var])
-    dl_var.click(fn=export_variance_png,
-                 inputs=[n_components, standardize],
-                 outputs=[file_var])
+    inputs=[color_feat,n_components,standardize]
+    run_btn.click(fn=controller, inputs=inputs, outputs=[plot2d,plot3d,plot_var,plot_heat,plot_hist,plot_box])
+    demo.load(fn=controller, inputs=inputs, outputs=[plot2d,plot3d,plot_var,plot_heat,plot_hist,plot_box])
 
-if __name__ == "__main__":
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False, show_api=False)
+if __name__=="__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)