Update app.py

app.py

@@ -1,6 +1,4 @@
-from pathlib import Path
-
-full_app = r'''import gradio as gr
+import gradio as gr
 import numpy as np
 import pandas as pd
 from pathlib import Path
@@ -14,125 +12,71 @@ from sklearn.mixture import GaussianMixture
 
 import plotly.graph_objects as go
 
-# ---------- UITLEGTEKSTEN ----------
+APP_TITLE = "Unsupervised Explorer (Parnassia)"
 
 EXPLAIN_MD = """
-Wat test ik hier?
+**Wat test ik hier?**
 
-We verkennen onbegeleide (unsupervised) structuur in data via clustering en dimensiereductie.
-Clustering: K-Means groepeert records in k clusters zonder labels.
-Dimensiereductie: PCA of t-SNE projecteert hoge-dimensiedata naar 2D/3D voor visuele inspectie.
-Hoe meet ik of dat gelukt is?
+We verkennen **onbegeleide (unsupervised)** structuur in data via clustering en dimensiereductie.
+- **Clustering:** K-Means groepeert records in *k* clusters (zonder labels).
+- **Dimensiereductie:** PCA of t-SNE projecteert hoge-dimensiedata naar 2D/3D voor visuele inspectie.
+
+**Hoe meet ik of dat gelukt is?**
+- **Elbow-plot (inertia):** helpt een redelijke *k* te kiezen.
+- **Silhouette-score:** meet clustercompactheid en -scheiding (hoger = beter).
+- **Projecties:** 2D/3D scatter met kleur per cluster + hover-informatie.
 
-Elbow-plot (inertia): helpt een redelijke k te kiezen.
-Silhouette-score: meet clustercompactheid en -scheiding (hoger is beter).
-Projecties: 2D/3D scatter met kleur per cluster, plus centroiden.
 Je kunt een eigen CSV uploaden of de synthetische demo gebruiken.
 """
 
 PSYCHIATRIE_MD = """
 ### Wat kun je hiermee in de psychiatrie?
 
-Stel: bij **Parnassia Groep** heb je een CSV-bestand met geanonimiseerde gegevens van patiënten, bijvoorbeeld scores op vragenlijsten (depressie, angst, slaap, stemming), aantal behandelsessies of leefstijlfactoren.
-
-Met deze app kun je **zonder labels** (dus zonder vooraf te zeggen “dit is diagnose X”) patronen laten zoeken in de data. Dat heet *unsupervised learning*. 
-
----
-
-### Wat levert dat op?
-- **Groepjes patiënten die op elkaar lijken**  
-  Het algoritme zet mensen met vergelijkbare patronen (bijvoorbeeld “hoge angst + slaapproblemen” of “lage stemming + weinig dagstructuur”) bij elkaar in clusters.
-
-- **Nieuwe inzichten in subgroepen**  
-  Misschien ontdek je dat er **3 duidelijke groepen** bestaan die niet netjes overeenkomen met de bestaande DSM-diagnoses, maar die wel iets zeggen over welke behandeling waarschijnlijk beter past.
-
-- **Visuele projecties**  
-  Door de data terug te brengen naar 2D of 3D kun je letterlijk zien: *“hier zit een wolk van patiënten die allemaal vergelijkbare profielen hebben, en daar zit een andere groep.”*
-
----
-
-### Waarom is dit waardevol?
-- **Voor behandelaren:** het geeft extra handvatten om te zien of iemand lijkt op een groep patiënten die goed reageerde op een bepaalde interventie.  
-- **Voor onderzoekers:** het helpt om nieuwe subtypen van psychische problematiek te ontdekken.  
-
-👉 Dit soort analyses zijn **niet bedoeld om diagnoses te vervangen**, maar juist om behandelaren te ondersteunen met extra inzichten.
+Met deze app kun je **zonder labels** patronen laten zoeken (*unsupervised learning*).  
+Dat kan helpen om **subgroepen** te zien die niet netjes in DSM-5-categorieën vallen, maar wel klinisch herkenbaar zijn.  
+Dit is aanvullend aan, niet ter vervanging van, klinische diagnostiek.
 """
 
 ELBOW_HELP_MD = """
 **Wat zie je in de elbow-plot?**  
-De elbow-plot laat zien hoe goed de data in groepen (clusters) past bij verschillende aantallen clusters (*k*).
-- Hoe meer clusters, hoe beter de data wordt opgesplitst.
-- Maar na een bepaald punt levert extra clusters bijna geen winst meer op.
-
-👉 Het knikpunt in de grafiek — de “elleboog” — is vaak een goede keuze voor het aantal clusters.
+De elbow-plot laat zien hoe goed de data in groepen (clusters) past bij verschillende aantallen clusters (*k*).  
+Na een bepaald punt levert extra clusters nauwelijks nog winst op: **het knikpunt (de elleboog)** is vaak een goede keuze.
 """
 
 PROJ_HELP_MD = """
-**Wat zie je in de 3D t-SNE plot?**  
-Deze grafiek laat de data teruggebracht zien naar 3 dimensies met **t-SNE**.  
+**Wat zie je in de t-SNE/PCA plot?**  
 - Elk bolletje = één patiënt.  
-- De kleur geeft aan in welk cluster de patiënt zit.  
-- Patiënten die dicht bij elkaar liggen, hebben vergelijkbare kenmerken (bijv. hoge angst + slaapproblemen).  
-- Beweeg met de muis over een bolletje om de gegevens van die patiënt te zien (zoals patiëntnummer en scores).  
-
-Het is dus een **visuele kaart** van de data: groepjes bolletjes vormen de clusters die het algoritme heeft gevonden.
+- De kleur geeft het cluster aan.  
+- Dicht bij elkaar = vergelijkbare kenmerken.  
+- Beweeg met de muis over een bolletje om patiëntnummer en geselecteerde kenmerken te zien.  
+Je kunt inzoomen en ronddraaien (bij 3D).
 """
 
 SETTINGS_HELP_MD = """
-**Wat betekenen deze instellingen?**
-- **Aantal clusters (k):** hoeveel groepen het algoritme maakt. Je kunt dit zelf kiezen of automatisch laten bepalen.
-- **Max k voor elbow:** tot welk aantal clusters de elbow-plot getest wordt.
-- **Standaardiseren:** zet alle variabelen op dezelfde schaal (aanraden!).
-- **Projectiemethode:** hoe de data naar 2D/3D wordt teruggebracht (PCA = sneller, t-SNE = vaak duidelijkere groepjes).
-- **Dimensies voor projectie:** of je de data in 2D of 3D wilt zien.
-- **Random seed:** bepaalt de “willekeur”. Zelfde seed = zelfde resultaat (handig om te herhalen).
-- **Auto k:** laat het algoritme automatisch het beste aantal clusters kiezen (via silhouette/BIC).
+**Instellingen (kort):**
+- **Aantal clusters (k):** hoeveel groepen het algoritme maakt. Handmatig of automatisch (silhouette/BIC).
+- **Max k voor elbow:** bereik voor de elbow-plot.
+- **Standaardiseren:** alle variabelen op dezelfde schaal (aanraden).
+- **Projectiemethode:** PCA (sneller) of t-SNE (vaak duidelijkere groepjes).
+- **Dimensies:** 2D of 3D weergave.
 """
 
 CENTERS_HELP_MD = """
 **Wat zijn clustercentra?**
 Elke cluster heeft een soort “gemiddelde patiënt” — dit noemen we het **clustercentrum**.  
 - Voor elke gekozen eigenschap (bijv. depressie, angst, slaapduur) berekent het **algoritme** het gemiddelde van alle patiënten in dat cluster.  
-- Dat gemiddelde is het **centrum van de groep**.  
-
-Zo kun je zien wat typisch is voor een cluster. Bijvoorbeeld:  
-- In **cluster 1** ligt het centrum bij “hogere depressiescores en lagere energie”.  
-- In **cluster 2** ligt het centrum bij “lagere depressiescores en betere kwaliteit van leven”.  
-
-Met deze tabel kun je dus begrijpen **wat de groepen van elkaar onderscheidt**.
+- Dat gemiddelde is het **centrum van de groep**.
 """
 
 CONCLUSIONS_MD = """
 **Wat levert dit nu op?**  
+Met de demo-data zie je dat het algoritme **clusters** onderscheidt. Dit illustreert dat de methode automatisch **verschillende typen patiënten** kan onderscheiden, ook zonder labels.  
 
-Met de synthetische demo-data zien we dat het algoritme **3 clusters** onderscheidt.  
-De data is opgebouwd rond drie kunstmatige patiëntgroepen met 8 kenmerken (*slaapprobleem, depressie, angst, somatiek, kwaliteit van leven, slaapduur, stemming, energie*).  
-
-De clusters verschillen ongeveer zo:  
-- **Cluster 1:** lage scores op bijna alle klachten → een groep met **milde problematiek**.  
-- **Cluster 2:** hogere scores op **slaapproblemen en depressie** → een groep die meer last heeft van **slaap en stemming**.  
-- **Cluster 3:** hogere scores op **angst en somatiek**, gecombineerd met **lagere energie** → een groep met meer **lichamelijke klachten en angst**.  
-
-👉 Dit laat zien dat de methode automatisch **verschillende typen patiënten** kan onderscheiden, ook al was er geen label of diagnose meegegeven.  
-
----
-
-**Waarom is dit waardevol voor Parnassia?**  
-De demo is natuurlijk beperkt en synthetisch, dus we trekken hier **geen medische conclusies**. Maar stel je voor dat we dit doen met echte patiëntdata bij Parnassia, waarin veel meer kenmerken zitten: vragenlijsten, behandelgeschiedenis, leefstijl, medicatie, etc.  
-
-Dan kan het algoritme helpen om:  
-- **Nieuwe subgroepen te ontdekken** die niet netjes in DSM-diagnoses passen, maar wel klinisch herkenbaar en relevant zijn.  
-- **Behandelaren extra handvatten te geven**, bijvoorbeeld: patiënten die sterk op elkaar lijken en goed reageerden op een bepaalde behandeling.  
-- **Onderzoek te ondersteunen**: welke factoren hangen samen, welke profielen zie je steeds terug?  
-
-Kortom: de synthetische data laat zien dát het werkt. Met echte datasets wordt het pas echt krachtig en waardevol voor zorg en behandeling.  
+**Waarom waardevol voor Parnassia?**  
+Met echte patiëntdata (meer kenmerken, behandelgeschiedenis) kan dit helpen om **subgroepen** te ontdekken, behandelkeuzes te ondersteunen en patronen zichtbaar te maken die je anders mist.
 """
 
 DEFAULT_CSV = "demo_unsupervised_synthetic.csv"
-NUMERIC_HINT = "Tip: selecteer alleen numerieke kolommen voor clustering (categorische kolommen eerst encoderen of uitsluiten)."
-WHY_COLS_MD = "**Waarom kolommen kiezen?**\nMet de kolomselectie vertel je het algoritme: *“Let bij het groeperen op deze kenmerken.”* Zo kun je irrelevante kolommen weghalen of juist focussen op wat je wilt onderzoeken."
-
-# ---------- DATA HULPFUNCTIES ----------
 
 def ensure_demo_csv():
     p = Path(DEFAULT_CSV)
@@ -156,282 +100,4 @@ def ensure_demo_csv():
 
 def load_dataframe(file_obj, sep, decimal):
     if file_obj is None:
-        path = ensure_demo_csv()
-        df = pd.read_csv(path)
-        source = f"Demo: {path}"
-    else:
-        df = pd.read_csv(file_obj.name, sep=sep, decimal=decimal)
-        source = f"Upload: {Path(file_obj.name).name}"
-    if "patient_id" not in df.columns:
-        df.insert(0, "patient_id", np.arange(1, len(df) + 1))
-    return df, source
-
-def _normalize_feature_list(feature_cols, df_columns):
-    if isinstance(feature_cols, pd.DataFrame):
-        values = feature_cols.iloc[:, 0].dropna().tolist()
-    elif isinstance(feature_cols, list):
-        if len(feature_cols) > 0 and isinstance(feature_cols[0], list):
-            values = [row[0] for row in feature_cols if row and row[0] is not None]
-        else:
-            values = feature_cols
-    else:
-        values = []
-    values = [str(v).strip() for v in values if str(v).strip() != ""]
-    values = [c for c in values if c in list(df_columns)]
-    return values
-
-def _make_hover_text(df, labels, features):
-    rows = []
-    for i in range(len(df)):
-        parts = [f"Patiënt #{int(df.loc[i, 'patient_id'])} — cluster {int(labels[i])}"]
-        for col in features:
-            val = df.loc[i, col]
-            try:
-                parts.append(f"{col}: {float(val):.2f}")
-            except Exception:
-                parts.append(f"{col}: {val}")
-        rows.append("<br>".join(parts))
-    return rows
-
-# ---------- MODEL / METRIEKEN ----------
-
-def compute_kmeans(df, features, k, scale, seed):
-    X = df[features].copy()
-    if scale:
-        scaler = StandardScaler().fit(X)
-        Xs = pd.DataFrame(scaler.transform(X), columns=X.columns)
-    else:
-        scaler = None
-        Xs = X
-    km = KMeans(n_clusters=k, n_init=10, random_state=seed)
-    labels = km.fit_predict(Xs)
-    centers = pd.DataFrame(km.cluster_centers_, columns=Xs.columns)
-    inertia = km.inertia_
-    sil = silhouette_score(Xs, labels) if k > 1 and len(np.unique(labels)) > 1 else float("nan")
-    return labels, centers, inertia, sil, scaler, Xs
-
-def elbow_curve(df, features, max_k, scale, seed):
-    X = df[features].copy()
-    if scale:
-        X = pd.DataFrame(StandardScaler().fit_transform(X), columns=X.columns)
-    inertias = []
-    ks = list(range(1, max_k + 1))
-    for k in ks:
-        km = KMeans(n_clusters=k, n_init=10, random_state=seed)
-        km.fit(X)
-        inertias.append(km.inertia_)
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(x=ks, y=inertias, mode="lines+markers", name="inertia"))
-    fig.update_layout(title="Elbow-plot (inertia)", xaxis_title="k", yaxis_title="inertia", height=400)
-    return fig
-
-def suggest_k(Xs, k_min, k_max, seed):
-    # Silhouette (k>=2)
-    sil_scores = {}
-    for k in range(max(2, k_min), max(k_min, k_max) + 1):
-        try:
-            km = KMeans(n_clusters=k, n_init=10, random_state=seed).fit(Xs)
-            sil = silhouette_score(Xs, km.labels_)
-            sil_scores[k] = sil
-        except Exception:
-            continue
-    k_sil = max(sil_scores, key=sil_scores.get) if sil_scores else None
-
-    # BIC via Gaussian Mixture (k>=1) - lager is beter
-    bic_scores = {}
-    for k in range(max(1, k_min), max(k_min, k_max) + 1):
-        try:
-            gm = GaussianMixture(n_components=k, random_state=seed).fit(Xs)
-            bic_scores[k] = gm.bic(Xs)
-        except Exception:
-            continue
-    k_bic = min(bic_scores, key=bic_scores.get) if bic_scores else None
-
-    k_final = k_sil or k_bic or None
-    return k_final, k_sil, k_bic, sil_scores, bic_scores
-
-def projection_plot(df, features, labels, centers, method, dim, seed, scaler, hover_text):
-    X = df[features].copy()
-    if scaler is None:
-        Xs = StandardScaler().fit_transform(X)
-        centers_s = None
-    else:
-        Xs = scaler.transform(X)
-        centers_s = centers.values if centers is not None and len(centers) > 0 else None
-
-    if method == "PCA":
-        pca = PCA(n_components=dim, random_state=seed)
-        Z = pca.fit_transform(Xs)
-        if centers_s is not None:
-            cent = pca.transform(centers_s)
-        else:
-            cent = None
-        expl = getattr(pca, "explained_variance_ratio_", None)
-        if expl is not None:
-            expl = expl[:dim]
-    else:
-        perplexity = max(5, min(30, len(Xs)-1))
-        tsne = TSNE(n_components=dim, random_state=seed, init="pca", perplexity=perplexity)
-        Z = tsne.fit_transform(Xs)
-        cent = None
-        expl = None
-
-    if dim == 2:
-        fig = go.Figure()
-        fig.add_trace(go.Scatter(
-            x=Z[:,0], y=Z[:,1], mode="markers",
-            marker=dict(size=6),
-            text=hover_text,
-            hovertemplate="%{text}<extra></extra>",
-            showlegend=False
-        ))
-        if cent is not None:
-            fig.add_trace(go.Scatter(
-                x=cent[:,0], y=cent[:,1], mode="markers+text",
-                marker=dict(size=12, symbol="x"),
-                text=[f"μ{j}" for j in range(len(cent))],
-                textposition="top center",
-                name="centroids"
-            ))
-        fig.update_layout(title=f"{method} projectie (2D) — kleur=cluster", height=500)
-    else:
-        fig = go.Figure(data=[go.Scatter3d(
-            x=Z[:,0], y=Z[:,1], z=Z[:,2],
-            mode="markers",
-            marker=dict(size=3),
-            text=hover_text,
-            hovertemplate="%{text}<extra></extra>",
-        )])
-        if cent is not None:
-            fig.add_trace(go.Scatter3d(
-                x=cent[:,0], y=cent[:,1], z=cent[:,2],
-                mode="markers+text",
-                marker=dict(size=6, symbol="x"),
-                text=[f"μ{j}" for j in range(len(cent))],
-                name="centroids"
-            ))
-        fig.update_layout(title=f"{method} projectie (3D) — kleur=cluster", height=600)
-
-    fig.update_traces(marker=dict(color=labels))
-    if expl is not None:
-        pct = " + ".join([f"{e*100:.1f}%" for e in expl])
-        fig.add_annotation(
-            xref="paper", yref="paper", x=0, y=-0.15, showarrow=False,
-            text=f"Uitlegvariantie (componenten): {pct}"
-        )
-    return fig
-
-# ---------- UI CALLBACK ----------
-
-def ui_run(file_obj, sep, decimal, feature_cols, k, scale, reducer, dim, max_k, seed, auto_k):
-    df, source = load_dataframe(file_obj, sep, decimal)
-    features = _normalize_feature_list(feature_cols, df.columns)
-    if len(features) == 0:
-        return (gr.update(value="Selecteer minimaal één numerieke feature (kolomnamen links invullen)."),
-                None, None, None, None)
-
-    # Voor automatische k-suggestie
-    X_raw = df[features].copy()
-    X_for_k = StandardScaler().fit_transform(X_raw) if scale else X_raw.values
-
-    k_suggested, k_sil, k_bic, sil_scores, bic_scores = suggest_k(X_for_k, k_min=2, k_max=max_k, seed=seed)
-    k_used = int(k_suggested) if auto_k and k_suggested is not None else int(k)
-
-    labels, centers, inertia, sil, scaler, Xs = compute_kmeans(df, features, k_used, scale, seed)
-    hover_text = _make_hover_text(df.reset_index(drop=True), labels, features)
-    fig_elbow = elbow_curve(df, features, max_k, scale, seed)
-    fig_proj = projection_plot(df, features, labels, centers, reducer, dim, seed, scaler, hover_text)
-
-    centers = centers[features]
-    centers.index.name = "cluster"
-    centers.reset_index(inplace=True)
-
-    md = f"**Bron:** {source}\n\n"
-    if auto_k and k_suggested is not None:
-        md += f"- **Auto-k** actief → gebruikte k = **{k_used}** (silhouette-suggestie={k_sil}, BIC-suggestie={k_bic})\n"
-    else:
-        md += f"- Handmatige k = **{k_used}**\n"
-        if k_suggested is not None:
-            md += f"  *(Tip: automatisch voorgesteld k = {k_suggested}; silhouette={k_sil}, BIC={k_bic})*\n"
-    md += f"- Gekozen features: `{features}`\n"
-    md += f"- inertia = **{inertia:.2f}**\n"
-    md += f"- silhouette = **{sil:.3f}** *(NA bij k=1 of 1 cluster)*\n"
-
-    # Vriendelijk leesbare labels-tabel
-    patient_ids = df["patient_id"].astype(int)
-    label_nums = pd.Series(labels).astype(int)
-    labels_df = pd.DataFrame({
-        "patiënt": patient_ids.map(lambda x: f"Patiënt #{x}"),
-        "clusterbeschrijving": label_nums.map(lambda y: f"Patiënt past in cluster {y}")
-    })
-
-    return md, fig_elbow, fig_proj, labels_df, centers
-
-# ---------- UI ----------
-
-with gr.Blocks(title="Unsupervised Explorer") as demo:
-    with gr.Row():
-        with gr.Column(scale=2):
-            file_in = gr.File(label="CSV upload (optioneel)")
-            with gr.Accordion("Parser-instellingen", open=False):
-                sep = gr.Dropdown([";", ",", "\\t"], value=",", label="Scheidingsteken (sep)")
-                decimal = gr.Dropdown([",", "."], value=".", label="Decimaalteken")
-
-            gr.Markdown(NUMERIC_HINT)
-            feature_cols = gr.Dataframe(
-                headers=["kolom"],
-                datatype=["str"],
-                row_count=(0, "dynamic"),
-                col_count=(1, "fixed"),
-                label="Welke kolommen gebruiken? (één per rij)",
-                value=[[f] for f in ["slaapprobleem", "depressie", "angst", "somatiek", "kwaliteit_van_leven", "slaapduur", "stemming", "energie"]]
-            )
-            gr.Markdown(WHY_COLS_MD)
-
-            with gr.Row():
-                k = gr.Slider(1, 12, value=6, step=1, label="Aantal clusters (k)")
-                max_k = gr.Slider(3, 20, value=10, step=1, label="Max k voor elbow")
-            with gr.Row():
-                scale = gr.Checkbox(True, label="Standaardiseren (aanraden)")
-                reducer = gr.Dropdown(["PCA", "t-SNE"], value="t-SNE", label="Projectiemethode")
-                dim = gr.Dropdown([2, 3], value=3, label="Dimensies voor projectie")
-                seed = gr.Slider(0, 10_000, value=42, step=1, label="Random seed")
-
-            auto_k = gr.Checkbox(True, label="Auto k (silhouette/BIC) toepassen")
-            gr.Markdown(SETTINGS_HELP_MD)
-
-            run_btn = gr.Button("Run clustering & visualisaties", variant="primary")
-            gr.Markdown(EXPLAIN_MD)
-            gr.Markdown(PSYCHIATRIE_MD)
-
-        with gr.Column(scale=3):
-            out_md = gr.Markdown()
-            elbow_plot = gr.Plot()
-            gr.Markdown(ELBOW_HELP_MD)
-            proj_plot = gr.Plot()
-            gr.Markdown(PROJ_HELP_MD)
-            labels_df = gr.Dataframe(label="Clusterlabels per rij (met patient_id)")
-            centers_df = gr.Dataframe(label="Clustercentra (feature-ruimte)")
-            gr.Markdown(CENTERS_HELP_MD)
-            gr.Markdown(CONCLUSIONS_MD)
-
-    run_btn.click(
-        fn=ui_run,
-        inputs=[file_in, sep, decimal, feature_cols, k, scale, reducer, dim, max_k, seed, auto_k],
-        outputs=[out_md, elbow_plot, proj_plot, labels_df, centers_df]
-    )
-
-    # Auto-run bij laden (met demo-data)
-    demo.load(
-        fn=ui_run,
-        inputs=[file_in, sep, decimal, feature_cols, k, scale, reducer, dim, max_k, seed, auto_k],
-        outputs=[out_md, elbow_plot, proj_plot, labels_df, centers_df]
-    )
-
-if __name__ == "__main__":
-    demo.launch()
-'''
-
-p = Path("/mnt/data/app_full_parnassia.py")
-p.write_text(full_app)
-str(p)
+        path