Upload 2 files

app.py

@@ -1,142 +1,155 @@
 
 import gradio as gr
 import numpy as np
+import pandas as pd
 import matplotlib.pyplot as plt
 from sklearn import datasets
 from sklearn.preprocessing import StandardScaler
 from sklearn.decomposition import PCA
-from sklearn.cluster import MiniBatchKMeans
-from sklearn.metrics import silhouette_score
-
-INTRO_MD = r"""
-### Wat gebeurt hier?
-We laten **unsupervised learning** zien: het algoritme zoekt **vanzelf groepjes** in de data — zónder dat we van tevoren labels geven.
-We gebruiken een bekende dataset (sklearn *diabetes*) met meerdere metingen per persoon (features).
-
-- We **schalen** de data (zodat alle metingen vergelijkbaar meewegen).
-- We projecteren alles naar **2D met PCA** om het zichtbaar te maken.
-- We voeren **k-means clustering** uit en **updaten** de centers stap voor stap (mini-batches).
-- Je ziet live:
-  - de **punten** (elk een persoon) ingekleurd per **cluster**,
-  - de **clustercentra** (kruisjes) die **opschuiven**,
-  - en de **inertia-curve** die meestal **daalt** (lager = strakkere clusters).
-
-> Educatief voorbeeld. Dit is géén medisch advies en geen diagnose.
-"""
 
-def load_diabetes_features():
+# ------------------------------
+# Data loading
+# ------------------------------
+def load_diabetes_df():
     d = datasets.load_diabetes()
-    X = d.data  # 10 features
-    return X
-
-def kmeans_live_generator(k, iters, batch_size, seed):
-    # Data voorbereiden
-    X = load_diabetes_features()
-    scaler = StandardScaler(with_mean=True, with_std=True)
-    Xs = scaler.fit_transform(X)
-
-    pca = PCA(n_components=2, random_state=int(seed))
-    Z = pca.fit_transform(Xs)  # 2D projectie voor visualisatie
-
-    # MiniBatchKMeans voor stapsgewijze updates
-    kmeans = MiniBatchKMeans(
-        n_clusters=int(k),
-        random_state=int(seed),
-        n_init=1,
-        init="k-means++",
-        batch_size=int(batch_size),
-        reassignment_ratio=0.01,
-    )
-
-    # Maak batches
-    n = Xs.shape[0]
-    rng = np.random.RandomState(int(seed))
-    idx = np.arange(n)
-    rng.shuffle(idx)
-
-    inertias = []
-    for t in range(1, int(iters) + 1):
-        # Pak een batch (roterend door de data)
-        start = ((t - 1) * batch_size) % n
-        end = min(start + int(batch_size), n)
-        batch_idx = idx[start:end]
-        Xb = Xs[batch_idx]
-
-        # Eén update-stap
-        kmeans.partial_fit(Xb)
-
-        # Labels en inertia op volledige set
-        labels = kmeans.predict(Xs)
-        inertia = float(kmeans.inertia_)
-        inertias.append(inertia)
-
-        # Projecteer centers naar 2D
-        centers_2d = pca.transform(kmeans.cluster_centers_)
-
-        # Plot 1: 2D scatter met clusters + centers
-        fig_main = plt.figure(figsize=(7, 4))
-        ax1 = fig_main.add_subplot(111)
-        ax1.scatter(Z[:, 0], Z[:, 1], c=labels, s=22, alpha=0.85)
-        ax1.scatter(centers_2d[:, 0], centers_2d[:, 1], marker="x", s=120, linewidths=2)
-        ax1.set_title(f"K-means live — iteratie {t}/{iters} (k={k})")
-        ax1.set_xlabel("PCA component 1")
-        ax1.set_ylabel("PCA component 2")
-        ax1.grid(True, linestyle=":", linewidth=0.6)
-        plt.tight_layout()
-
-        # Plot 2: inertia-curve
-        fig_inertia = plt.figure(figsize=(7, 3.2))
-        ax2 = fig_inertia.add_subplot(111)
-        ax2.plot(range(1, len(inertias)+1), inertias, marker="o")
-        ax2.set_title("Inertia (doelfunctie) per iteratie — lager is beter")
-        ax2.set_xlabel("Iteratie")
-        ax2.set_ylabel("Inertia")
-        ax2.grid(True, linestyle=":", linewidth=0.6)
-        plt.tight_layout()
-
-        # Metrics: op laatste stap ook silhouette en cluster-groottes
-        metrics_lines = [f"**Iteratie:** {t}/{iters} — **Inertia:** {inertia:.2f}"]
-        if t == int(iters):
-            try:
-                sil = float(silhouette_score(Xs, labels))
-                metrics_lines.append(f"**Silhouette score:** {sil:.3f}")
-            except Exception:
-                metrics_lines.append("**Silhouette score:** (n.v.t.)")
-            # cluster groottes
-            sizes = np.bincount(labels, minlength=int(k))
-            size_str = ", ".join([f"cluster {i}: {sizes[i]}" for i in range(int(k))])
-            metrics_lines.append(f"**Cluster-groottes:** {size_str}")
-            metrics_lines.append("> Tip: probeer een andere *k* en vergelijk de inertia/silhouette.")
-
-        yield fig_main, fig_inertia, "\n".join(metrics_lines)
-
-with gr.Blocks(title="Unsupervised Learning — Live Clustering (K-means + PCA)") as demo:
-    gr.Markdown("# Unsupervised Learning — Live Clustering (K-means + PCA)")
-    gr.Markdown(INTRO_MD)
+    X = pd.DataFrame(d.data, columns=d.feature_names)
+    y = pd.Series(d.target, name="target")
+    # Voeg target erbij voor mogelijke kleurselecties, al is default BMI
+    df = X.copy()
+    df["target"] = y
+    return df
+
+# ------------------------------
+# PCA computation + visuals
+# ------------------------------
+def pca_biplot(color_feature="bmi", arrow_scale=2.0, point_size=32, alpha=0.85, n_components=10, standardize=True):
+    df = load_diabetes_df()
+    feats = [c for c in df.columns if c != "target"]
+    X = df[feats].values
+
+    # Standardize (diabetes is al ongeveer gestandaardiseerd, maar we doen dit expliciet voor duidelijkheid)
+    if standardize:
+        scaler = StandardScaler(with_mean=True, with_std=True)
+        Xs = scaler.fit_transform(X)
+    else:
+        Xs = X
+
+    # PCA
+    pca = PCA(n_components=min(n_components, Xs.shape[1]))
+    Z = pca.fit_transform(Xs)  # scores
+    loadings = pca.components_.T  # shape (features, components)
+    expl = pca.explained_variance_ratio_
+
+    # Kleur op geselecteerde feature
+    if color_feature not in df.columns:
+        color_feature = "bmi"
+    cvals = df[color_feature].values
+
+    # ---------------- Plot 1: PCA biplot (scores + feature vectors) ----------------
+    fig1 = plt.figure(figsize=(7.5, 5.5))
+    ax = fig1.add_subplot(111)
+    sc = ax.scatter(Z[:, 0], Z[:, 1], c=cvals, s=point_size, alpha=alpha)
+    cbar = plt.colorbar(sc, ax=ax, pad=0.02)
+    cbar.set_label(f"Kleur: {color_feature}")
+    ax.set_xlabel("PC1")
+    ax.set_ylabel("PC2")
+    ax.set_title("PCA biplot — punten (projectie) + pijlen (feature-bijdragen)")
+
+    # pijlen voor feature loadings (alleen PC1/PC2)
+    for i, feat 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, feat, 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()
+
+    # ---------------- Plot 2: Explained variance (bar + cumulative line) ----------------
+    fig2 = plt.figure(figsize=(7.5, 3.8))
+    ax2 = fig2.add_subplot(111)
+    xs = np.arange(1, len(expl) + 1)
+    ax2.bar(xs, expl, width=0.8, align="center")
+    ax2.plot(xs, np.cumsum(expl), marker="o")
+    ax2.set_xticks(xs)
+    ax2.set_xlabel("Principal Component")
+    ax2.set_ylabel("Explained variance ratio")
+    ax2.set_title("Uitlegvariantie per component (balken) + cumulatief (lijn)")
+    ax2.grid(True, linestyle=":", linewidth=0.6)
+    plt.tight_layout()
+
+    # ---------------- Tabel: top-features per PC1 en PC2 ----------------
+    load_df = pd.DataFrame({
+        "feature": feats,
+        "PC1_loading": loadings[:, 0],
+        "PC2_loading": loadings[:, 1],
+        "PC1_abs": np.abs(loadings[:, 0]),
+        "PC2_abs": np.abs(loadings[:, 1]),
+    })
+    # sorteer per component en merge een compacte weergave
+    top_pc1 = load_df.sort_values("PC1_abs", ascending=False)[["feature", "PC1_loading"]].head(6).reset_index(drop=True)
+    top_pc2 = load_df.sort_values("PC2_abs", ascending=False)[["feature", "PC2_loading"]].head(6).reset_index(drop=True)
+
+    top_pc1.rename(columns={"feature": "Feature (PC1)", "PC1_loading": "Loading PC1"}, inplace=True)
+    top_pc2.rename(columns={"feature": "Feature (PC2)", "PC2_loading": "Loading PC2"}, inplace=True)
+
+    # Combineer netjes naast elkaar
+    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)
+
+    # Beschrijving in gewone taal
+    summary_md = f"""### Wat zie je hier?
+- **Punten (personen)** geprojecteerd in 2D met **PCA**. Dicht bij elkaar = **lijkt op elkaar** over meerdere metingen.
+- **Kleur** = waarde van **{color_feature}** (bijv. BMI). Zo zie je meteen of die eigenschap een **gradiënt** vormt.
+- **Pijlen** = bijdrage van **features** aan de richting van **PC1/PC2**. Lengte ≈ hoe sterk die feature die richting beïnvloedt.
+- **Balkgrafiek** = per component hoeveel variatie hij uitlegt; **lijn** = cumulatief.
+
+### Hoe lees je de biplot?
+- Staat een pijl **rechts/boven**, dan drukt die feature de data die kant op in PC1/PC2.
+- Punten in de richting van een pijl hebben vaak **hogere waarden** voor die feature.
+- Kleurgradiënt (bijv. BMI): als kleuren geleidelijk veranderen langs een as, is dat **consistentie** met die component.
+
+> Tip: verander **pijl-schaal**, **puntgrootte** en **transparantie** om het patroon beter te zien.
+"""
+
+    return fig1, fig2, table, summary_md
+
+# ------------------------------
+# UI
+# ------------------------------
+with gr.Blocks(title="PCA Biplot — Diabetes (kleur: BMI)") as demo:
+    gr.Markdown("# PCA Biplot — Diabetes (kleur: BMI)")
+    gr.Markdown("""In deze demo zie je **live** hoe PCA de data samenvat. De punten zijn personen; pijlen laten zien welke features
+(zoals **bmi**, **bp**, **s1..s6**) de richting van de componenten bepalen. De **kleur** toont standaard **bmi**.
+""")
 
     with gr.Row():
         with gr.Column(scale=1):
-            k = gr.Slider(2, 10, value=3, step=1, label="Aantal clusters (k)")
-            iters = gr.Slider(5, 200, value=40, step=1, label="Iteraties")
-            batch_size = gr.Slider(16, 256, value=128, step=1, label="Batchgrootte")
-            seed = gr.Slider(0, 9999, value=42, step=1, label="Random seed")
-            run_btn = gr.Button("Cluster live")
+            color_feat = gr.Dropdown(
+                choices=["bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6", "age", "sex", "target"],
+                value="bmi",
+                label="Kleur op feature"
+            )
+            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 (voor variatieplot)")
+            standardize = gr.Checkbox(value=True, label="Standaardiseer features (aanbevolen)")
+            run_btn = gr.Button("Update visualisaties")
         with gr.Column(scale=2):
-            plot_main = gr.Plot(label="2D-projectie (PCA) met clusters en centers (live)")
-            plot_inertia = gr.Plot(label="Inertia per iteratie")
-            metrics = gr.Markdown()
-
-    run_btn.click(
-        fn=kmeans_live_generator,
-        inputs=[k, iters, batch_size, seed],
-        outputs=[plot_main, plot_inertia, metrics]
-    )
-
-    demo.load(
-        fn=kmeans_live_generator,
-        inputs=[k, iters, batch_size, seed],
-        outputs=[plot_main, plot_inertia, metrics]
-    )
+            plot_biplot = gr.Plot(label="PCA biplot — punten + pijlen")
+            plot_expl = gr.Plot(label="Uitlegvariantie per component")
+            table = gr.Dataframe(headers=["Feature (PC1)", "Loading PC1", "Feature (PC2)", "Loading PC2"], row_count=6)
+            summary = gr.Markdown()
+
+    inputs = [color_feat, arrow_scale, point_size, alpha, n_components, standardize]
+
+    run_btn.click(fn=pca_biplot, inputs=inputs, outputs=[plot_biplot, plot_expl, table, summary])
+    demo.load(fn=pca_biplot, inputs=inputs, outputs=[plot_biplot, plot_expl, table, summary])
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -2,3 +2,4 @@ gradio>=4.36.0
 matplotlib>=3.7.0
 numpy>=1.23.0
 scikit-learn>=1.2.0
+pandas>=1.5.0