Upload 2 files

app.py

@@ -7,68 +7,109 @@ from sklearn import datasets
 from sklearn.preprocessing import StandardScaler
 from sklearn.decomposition import PCA
 
-# ------------------------------
-# Data loading
-# ------------------------------
+# Mapping van sklearn-featurecodes naar begrijpelijke NL labels
+FEATURE_LABELS = {
+    "age": "Leeftijd",
+    "sex": "Geslacht",
+    "bmi": "BMI (Body Mass Index)",
+    "bp": "Bloeddruk",
+    "s1": "Totale cholesterol",
+    "s2": "LDL-cholesterol",
+    "s3": "HDL-cholesterol",
+    "s4": "Chol./HDL-verhouding",
+    "s5": "Triglyceriden",
+    "s6": "Bloedsuiker (glucose)",
+    "target": "Doelscore (progressie)",
+}
+
+# Omgekeerde mapping voor dropdown-keuze -> kolomnaam
+LABEL_TO_KEY = {v: k for k, v in FEATURE_LABELS.items()}
+
+MEDICAL_MD = r"""
+### Wat is dit en waarom is het belangrijk?  
+
+Artsen en onderzoekers meten vaak heel veel dingen van patiënten: **BMI, bloeddruk, bloedwaarden, cholesterol, suikers** enzovoort.  
+Al die getallen tegelijk vergelijken is bijna onmogelijk.  
+
+Met deze techniek (**PCA-biplot**) maak je er een **kaart** van:  
+- Elk **punt** = één patiënt.  
+- Patiënten die **op elkaar lijken** in hun metingen liggen dicht bij elkaar.  
+- **Kleuren** (bijv. BMI) laten zien of een eigenschap een duidelijke **trend** of **gradiënt** vormt.  
+- **Pijlen** tonen welke metingen het meest bijdragen aan de richting van de kaart.  
+
+> Belangrijk: dit voorbeeld gebruikt een **echte medische dataset** (de `diabetes` dataset uit de scikit-learn bibliotheek).  
+> De gegevens zijn afkomstig uit een onderzoek met **echte mensen**, maar zijn **geanonimiseerd** en uitsluitend bedoeld voor educatie en analyse.  
+
+---
+
+### Wat levert dit op in de medische wetenschap?  
+- Ziekenhuizen kunnen **patronen ontdekken** in grote hoeveelheden patiëntgegevens.  
+- Je ziet of **bepaalde metingen samenhangen** met ziektebeelden of risico’s (bijvoorbeeld of BMI samen oploopt met bepaalde bloedwaarden).  
+- Onderzoekers krijgen zo **hypotheses**: *“Deze groep patiënten lijkt op elkaar — misschien hebben ze een vergelijkbaar risico of dezelfde behandeling nodig.”*  
+- Het helpt ook om **uitbijters** te vinden: patiënten die heel anders scoren dan de rest, wat een signaal kan zijn om nader te onderzoeken.  
+
+---
+
+### Simpel gezegd  
+Dit is een manier om **veel medische informatie overzichtelijk te maken**.  
+Artsen kunnen sneller zien **welke metingen ertoe doen** en **waar mogelijk verbanden zitten**.  
+Dat maakt onderzoek en diagnose een stuk slimmer en efficiënter.  
+"""
+
 def load_diabetes_df():
     d = datasets.load_diabetes()
-    X = pd.DataFrame(d.data, columns=d.feature_names)
+    X = pd.DataFrame(d.data, columns=d.feature_names)  # ['age','sex','bmi','bp','s1'..'s6']
     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):
+def pca_biplot(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 = [c for c in df.columns if c != "target"]
-    X = df[feats].values
+    feature_keys = [c for c in df.columns if c != "target"]  # codes
+    # Kleur-feature van label -> key
+    color_key = LABEL_TO_KEY.get(color_label, "bmi")
+
+    X = df[feature_keys].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]))
+    pca = PCA(n_components=min(int(n_components), Xs.shape[1]))
     Z = pca.fit_transform(Xs)  # scores
-    loadings = pca.components_.T  # shape (features, components)
+    loadings = pca.components_.T  # (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
+    # kleurwaarden
+    cvals = df[color_key].values
 
-    # ---------------- Plot 1: PCA biplot (scores + feature vectors) ----------------
-    fig1 = plt.figure(figsize=(7.5, 5.5))
+    # ---------------- Plot 1: Biplot ----------------
+    fig1 = plt.figure(figsize=(7.8, 5.6))
     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}")
+    cbar.set_label(f"Kleur: {FEATURE_LABELS.get(color_key, color_key)}")
     ax.set_xlabel("PC1")
     ax.set_ylabel("PC2")
-    ax.set_title("PCA biplot — punten (projectie) + pijlen (feature-bijdragen)")
+    ax.set_title("PCA-biplot — punten (patiënten) + pijlen (belangrijkste metingen)")
 
-    # pijlen voor feature loadings (alleen PC1/PC2)
-    for i, feat in enumerate(feats):
+    # pijlen + labels in NL
+    for i, key in enumerate(feature_keys):
         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.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()
 
-    # ---------------- Plot 2: Explained variance (bar + cumulative line) ----------------
-    fig2 = plt.figure(figsize=(7.5, 3.8))
+    # ---------------- Plot 2: Explained variance ----------------
+    fig2 = plt.figure(figsize=(7.8, 3.8))
     ax2 = fig2.add_subplot(111)
     xs = np.arange(1, len(expl) + 1)
     ax2.bar(xs, expl, width=0.8, align="center")
@@ -80,40 +121,36 @@ def pca_biplot(color_feature="bmi", arrow_scale=2.0, point_size=32, alpha=0.85,
     ax2.grid(True, linestyle=":", linewidth=0.6)
     plt.tight_layout()
 
-    # ---------------- Tabel: top-features per PC1 en PC2 ----------------
+    # ---------------- Tabel: top-features per PC1/PC2 (NL labels) ----------------
     load_df = pd.DataFrame({
-        "feature": feats,
+        "feature_key": feature_keys,
         "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)
+    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.rename(columns={"feature": "Feature (PC1)", "PC1_loading": "Loading PC1"}, inplace=True)
-    top_pc2.rename(columns={"feature": "Feature (PC2)", "PC2_loading": "Loading PC2"}, inplace=True)
+    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)
 
-    # 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
+    # Uitlegtekst bijwerken met NL-label van kleur
+    color_label_nl = FEATURE_LABELS.get(color_key, color_key)
     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.
+- **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.
 
 ### 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.
+- Staat een pijl **rechts/boven**, dan duwt die meting de punten die kant op in PC1/PC2.
+- Liggen punten **in de richting** van een pijl? Dan hebben die patiënten gemiddeld **hogere waarden** voor die meting.
 """
 
     return fig1, fig2, table, summary_md
@@ -121,63 +158,33 @@ def pca_biplot(color_feature="bmi", arrow_scale=2.0, point_size=32, alpha=0.85,
 # ------------------------------
 # UI
 # ------------------------------
-STORY_MD_MEDICAL = r'''
-### Wat is dit en waarom is het belangrijk?  
-
-Artsen en onderzoekers meten vaak heel veel dingen van patiënten: **BMI, bloeddruk, bloedwaarden, cholesterol, suikers** enzovoort.  
-Al die getallen tegelijk vergelijken is bijna onmogelijk.  
-
-Met deze techniek (**PCA-biplot**) maak je er een **kaart** van:  
-- Elk **punt** = één patiënt.  
-- Patiënten die **op elkaar lijken** in hun metingen liggen dicht bij elkaar.  
-- **Kleuren** (bijv. BMI) laten zien of een eigenschap een duidelijke **trend** of **gradiënt** vormt.  
-- **Pijlen** tonen welke metingen het meest bijdragen aan de richting van de kaart.  
-
-> Belangrijk: dit voorbeeld gebruikt een **echte medische dataset** (de `diabetes` dataset uit de scikit-learn bibliotheek).  
-> De gegevens zijn afkomstig uit een onderzoek met **echte mensen**, maar zijn **geanonimiseerd** en uitsluitend bedoeld voor educatie en analyse.  
-
----
-
-### Wat levert dit op in de medische wetenschap?  
-- Ziekenhuizen kunnen **patronen ontdekken** in grote hoeveelheden patiëntgegevens.  
-- Je ziet of **bepaalde metingen samenhangen** met ziektebeelden of risico’s (bijvoorbeeld of BMI samen oploopt met bepaalde bloedwaarden).  
-- Onderzoekers krijgen zo **hypotheses**: *“Deze groep patiënten lijkt op elkaar — misschien hebben ze een vergelijkbaar risico of dezelfde behandeling nodig.”*  
-- Het helpt ook om **uitbijters** te vinden: patiënten die heel anders scoren dan de rest, wat een signaal kan zijn om nader te onderzoeken.  
-
----
-
-### Simpel gezegd  
-Dit is een manier om **veel medische informatie overzichtelijk te maken**.  
-Artsen kunnen sneller zien **welke metingen ertoe doen** en **waar mogelijk verbanden zitten**.  
-Dat maakt onderzoek en diagnose een stuk slimmer en efficiënter.  
-'''
-
-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.Blocks(title="PCA Biplot — Diabetes (NL labels)") as demo:
+    gr.Markdown("# PCA Biplot — Diabetes (NL labels)")
+    gr.Markdown("""In deze demo zie je **live** hoe PCA de data samenvat. De punten zijn patiënten; pijlen laten zien welke metingen
+(zoals **BMI**, **Bloeddruk**, **Cholesterol**, **Glucose**) de richting van de componenten bepalen. De **kleur** toont standaard **BMI**.
 """)
 
     with gr.Row():
         with gr.Column(scale=1):
+            color_choices = [FEATURE_LABELS[k] for k in ["bmi","bp","s1","s2","s3","s4","s5","s6","age","sex","target"]]
             color_feat = gr.Dropdown(
-                choices=["bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6", "age", "sex", "target"],
-                value="bmi",
-                label="Kleur op feature"
+                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 (voor variatieplot)")
-            standardize = gr.Checkbox(value=True, label="Standaardiseer features (aanbevolen)")
+            standardize = gr.Checkbox(value=True, label="Standaardiseer metingen (aanbevolen)")
             run_btn = gr.Button("Update visualisaties")
             gr.Markdown("> *Medisch nut:* deze biplot maakt grote hoeveelheden patiëntmetingen direct inzichtelijk.")
         with gr.Column(scale=2):
-            plot_biplot = gr.Plot(label="PCA biplot — punten + pijlen")
+            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()
-            medical_md_block = gr.Markdown(STORY_MD_MEDICAL)
+            medical_md_block = gr.Markdown(MEDICAL_MD)
 
     inputs = [color_feat, arrow_scale, point_size, alpha, n_components, standardize]