Upload 2 files

app.py

@@ -0,0 +1,142 @@
+
+import gradio as gr
+import numpy as np
+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():
+    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)
+
+    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")
+        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]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=4.36.0
+matplotlib>=3.7.0
+numpy>=1.23.0
+scikit-learn>=1.2.0