# app.py — GGZ Agressie (synthetisch) — One-page UI
# - Auto-train bij openen met TF-IDF
# - Handmatig trainen zonder CSV upload: kies TF-IDF / ClinicalBERT / DutchBERT
# - (Optioneel) Hertrain met eigen CSV (nu altijd zichtbaar)
# - MLflow experiment tracking + LIME explainability tab
# - Confusion matrix met betekenislabels + Markdown-uitleg bij classification report
# - Extra: Confusion-matrix heatmap-plot onder de tabel
# - Evaluatieplots links (met datavoorbeeld erboven); Predict rechts
# - Visualisatie: 2D/3D-projecties (label & kans) + afbeelding direct onder kans-plot
# - Classification report met eenheden (% en aantallen)
# - Datavoorbeeld: eerste 10 rijen of hele dataset (scrollbaar via CSS)
# - Extra tabs: Kalibratie, Cumulative Gains, Lift, KS-curve, Dataset-profiel
import os
import typing as _t
import numpy as np
import pandas as pd
import gradio as gr
import plotly.express as px
import plotly.graph_objects as go
from pathlib import Path
from huggingface_hub import hf_hub_download
from sklearn.model_selection import train_test_split
from sklearn.metrics import (
roc_auc_score, average_precision_score,
classification_report, confusion_matrix,
precision_score, recall_score, f1_score,
roc_curve, precision_recall_curve
)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.decomposition import TruncatedSVD
from sklearn.manifold import TSNE
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.calibration import calibration_curve
# --- NEW: experiment tracking + explainability ---
import mlflow, mlflow.sklearn
from lime.lime_text import LimeTextExplainer
# --- Optional DL deps (voor BERT) ---
try:
import torch
from transformers import AutoTokenizer, AutoModel
except Exception:
torch = None
AutoTokenizer = None
AutoModel = None
# ============ Config & Intro ============
DEFAULT_CSV = "synthetische_ggz_agressie_dataset_1000.csv"
# Afbeelding die direct onder de 2D/3D-kans-plot verschijnt (bestand naast app.py)
INFO_IMAGE = str(Path(__file__).resolve().parent / "imglk;l;kl.png")
# Volledige-breedte koptekst
SLOGAN = "Studieobject Marcel Ooms: Veiligere zorg begint hier: het 30-dagenrisico op agressie onderbouwd en uitlegbaar."
# Gebruikersvriendelijke intro: alleen kop vet
INTRO = """
**Van verslag naar risico: kans op agressie in de komende 30 dagen**
Wat doet deze pagina voor jou?
Deze demo helpt om uit vrije-tekstrapportages snel een inschatting van het risico op agressief gedrag in de komende 30 dagen te krijgen. Plak een stukje verslag in het tekstvak en je krijgt een kans (probabiliteit) terug, plus een voorgesteld label op basis van een drempel die je zelf kunt verschuiven. Zo kun je risico vroegtijdig signaleren en bepalen welke acties passen: extra observatie, bijsturing in het behandelplan of overleg in het team.
Hoe werkt het in grote lijnen (zonder technisch gedoe):
- Bij het openen staat er al een startmodel klaar.
- Je kunt hertrainen met drie aanpakken: TF-IDF, ClinicalBERT of DutchBERT.
- De grafieken laten zien hoe nauwkeurig het model is en hoe de drempel precision en recall beïnvloedt.
- Met LIME zie je welke woorden in de tekst het meest hebben bijgedragen aan de inschatting; dat maakt de uitkomst uitlegbaar.
Belangrijk om te weten:
- Dit is een demonstratie op synthetische data. De uitkomst is een waarschijnlijkheid, geen zekerheid.
- Het systeem voorspelt niet of iemand agressief wordt, maar schat de kans binnen 30 dagen in op basis van tekstsignalen.
- Gebruik de uitkomst altijd naast klinische expertise en bestaande veiligheidsprotocollen.
"""
# Herschreven rechter tekstblok: alleen kopjes vet
WHAT_YOU_SEE = """
**Wat zie je op deze pagina?**
**Status & prestaties**
Hier zie je hoe goed het model onderscheid maakt. AUROC en AUPRC tonen in één oogopslag hoe betrouwbaar de inschatting is; hoger is beter.
**Handmatig trainen (zonder upload)**
Kies een featurizer (TF-IDF, ClinicalBERT of DutchBERT) en klik op Train algoritme. Je kunt opties aanpassen en direct vergelijken wat in jouw setting het beste werkt.
**Visualisatie**
De interactieve 2D/3D-plot laat elke tekst als een punt zien. Kleur en positie helpen om patronen te herkennen; met de muis zie je extra uitleg per punt. Er zijn twee weergaven: kleur naar werkelijk label en kleur naar voorspelde kans.
**Evaluatie**
Met de drempel-schuif bepaal je wanneer “hoog risico” wordt toegekend. Je ziet wat dat betekent voor precision, recall en F1. Zo kun je kiezen tussen minder valse alarmen of meer signalen oppikken.
**Predict**
Plak een rapportage in het tekstvak en krijg meteen een kans en een voorgesteld label. Het is een hulpmiddel voor vroegtijdige signalering, geen definitieve uitspraak.
**Hertrain met eigen CSV**
Upload een CSV met de juiste kolommen en train het model opnieuw. De nieuwe prestaties en grafieken worden direct bijgewerkt.
"""
# Verhaal over ML dat direct onder de afbeelding komt: alleen kop vet
ML_STORY = """
**Van ruwe data naar beslisinformatie**
De afbeelding schetst de weg van ruwe data naar beslisinformatie. We starten met tekst: observaties, verslagen en notities. Met historische labels leert een algoritme patronen herkennen. In de verwerking wordt tekst omgezet naar kenmerken (bijvoorbeeld TF-IDF of BERT-embeddings) en leert het model welke combinaties iets zeggen over het risico op agressie binnen 30 dagen.
Het resultaat is een waarschijnlijkheid, geen absolute waarheid. Die kans helpt teams om eerder te signaleren en bewust te kiezen: wil je minder valse alarmen (hogere precision) of juist meer signaal oppikken (hogere recall)? De mens blijft aan het roer: de uitkomst is uitlegbaar met LIME, meetbaar met AUROC/AUPRC en bedoeld om het klinisch oordeel te ondersteunen.
"""
FOOTER = """
**Technische noot**
Modellen: TF-IDF → Logistic Regression; ClinicalBERT/DutchBERT → Logistic Regression
Visualisatie: SVD(50) → t-SNE(2D/3D) op de gekozen tekstfeatures
CSV-loader: lokaal (map van dit bestand) of via Hugging Face Hub
"""
# MLflow experiment
mlflow.set_experiment("ggz-agressie")
# ============ Data loading ============
def _resolve_csv_path(uploaded=None):
if uploaded is not None:
return uploaded.name if hasattr(uploaded, "name") else uploaded
candidates = [
os.path.join(os.getcwd(), DEFAULT_CSV),
os.path.join(os.path.dirname(__file__), DEFAULT_CSV),
DEFAULT_CSV,
]
for p in candidates:
if os.path.exists(p):
return p
repo_id = os.environ.get("SPACE_ID")
if repo_id:
return hf_hub_download(repo_id=repo_id, filename=DEFAULT_CSV)
raise FileNotFoundError(
f"Kon {DEFAULT_CSV} niet vinden. Zet het bestand in de repo-root "
"of upload een CSV met kolommen `rapportage` en `agressie_volgende30d`."
)
def load_dataset(file_obj=None):
path = _resolve_csv_path(file_obj)
df = pd.read_csv(path)
required = {"rapportage", "agressie_volgende30d"}
missing = required - set(df.columns)
if missing:
raise ValueError(f"CSV mist verplichte kolommen: {missing}")
df = df.dropna(subset=["rapportage", "agressie_volgende30d"]).copy()
df["agressie_volgende30d"] = (df["agressie_volgende30d"].astype(int) > 0).astype(int)
return df
# ============ HF Text Embedder ============
class HFTextEmbedder(BaseEstimator, TransformerMixin):
"""
Sklearn-compatibele transformer die sentence-embeddings maakt met een HF encoder.
- Mean-pooling over token embeddings (mask-aware)
- Batching en device auto-select
"""
def __init__(self,
model_name: str = "emilyalsentzer/Bio_ClinicalBERT",
max_length: int = 128,
batch_size: int = 16,
device: _t.Optional[str] = None):
self.model_name = model_name
self.max_length = max_length
self.batch_size = batch_size
self.device = device
self._tokenizer = None
self._model = None
self._dev = None
def _ensure_backend(self):
if torch is None or AutoTokenizer is None or AutoModel is None:
raise RuntimeError("BERT-embeddings vereisen 'torch' en 'transformers'.")
self._dev = self.device or ("cuda" if torch.cuda.is_available() else "cpu")
if self._tokenizer is None:
self._tokenizer = AutoTokenizer.from_pretrained(self.model_name)
if self._model is None:
self._model = AutoModel.from_pretrained(self.model_name).to(self._dev)
self._model.eval()
def fit(self, X, y=None):
self._ensure_backend()
return self
@torch.no_grad()
def transform(self, X):
self._ensure_backend()
texts = pd.Series(X).astype(str).tolist()
if not texts:
return np.zeros((0, 768), dtype=np.float32)
embs = []
for i in range(0, len(texts), self.batch_size):
batch = texts[i:i+self.batch_size]
toks = self._tokenizer(
batch, padding=True, truncation=True,
max_length=self.max_length, return_tensors="pt"
).to(self._dev)
outs = self._model(**toks).last_hidden_state # (B, T, H)
mask = toks.attention_mask.unsqueeze(-1) # (B, T, 1)
summed = (outs * mask).sum(dim=1) # (B, H)
counts = mask.sum(dim=1).clamp(min=1) # (B, 1)
pooled = summed / counts # (B, H)
embs.append(pooled.cpu().numpy())
return np.vstack(embs)
# ============ Explainability helpers ============
def _clf_and_vectorizer_from_pipe(pipe):
vec = pipe.named_steps.get("txt")
clf = pipe.named_steps.get("clf")
return vec, clf
def tfidf_global_top_words(pipe, k=20):
"""Top-k 'pro-agressie' en 'anti-agressie' woorden (alleen bij TF-IDF)."""
vec, clf = _clf_and_vectorizer_from_pipe(pipe)
if not hasattr(vec, "get_feature_names_out"):
return [], []
feature_names = np.array(vec.get_feature_names_out())
coefs = clf.coef_[0]
top_pos_idx = np.argsort(coefs)[-k:][::-1]
top_neg_idx = np.argsort(coefs)[:k]
return list(feature_names[top_pos_idx]), list(feature_names[top_neg_idx])
_lime_explainer = LimeTextExplainer(class_names=["geen agressie", "agressie"])
def lime_explain_text(pipe, text, num_features=8):
def predict_proba_text(texts):
p1 = pipe.predict_proba(texts)[:, 1]
p0 = 1 - p1
return np.vstack([p0, p1]).T
exp = _lime_explainer.explain_instance(text, predict_proba_text, num_features=num_features)
return exp.as_html()
# ============ Metrics helpers ============
def _format_confusion_df(cm: np.ndarray) -> pd.DataFrame:
"""
Maakt een confusion-matrix dataframe met uitleg per cel (TN/FP/FN/TP).
Klassen: 0 = 'geen agressie', 1 = 'agressie'.
"""
if cm.shape != (2, 2):
return pd.DataFrame(cm, index=["True 0", "True 1"], columns=["Pred 0", "Pred 1"])
tn, fp, fn, tp = cm.ravel()
data = [
[f"{tn} — TN (True Negatives: echte negatieven)",
f"{fp} — FP (False Positives: fout-positieven)"],
[f"{fn} — FN (False Negatives: fout-negatieven)",
f"{tp} — TP (True Positives: echte positieven)"]
]
idx = ["True 0 (geen agressie)", "True 1 (agressie)"]
cols = ["Pred 0 (geen agressie)", "Pred 1 (agressie)"]
return pd.DataFrame(data, index=idx, columns=cols)
def _build_report_markdown(rep: dict, thr: float) -> str:
acc = rep.get("accuracy", 0)
macro = rep.get("macro avg", {})
weighted = rep.get("weighted avg", {})
s0 = int(rep.get("0", {}).get("support", 0))
s1 = int(rep.get("1", {}).get("support", 0))
md = f"""
### ℹ️ Uitleg bij het classification report (drempel = {thr:.2f})
Klasselabels
0 = geen agressie, 1 = agressie.
De drempel bepaalt wanneer de kans wordt omgezet naar label 1 (≥ drempel) of 0 (< drempel).
Velden in het rapport
Precision: van alle voorspelde positieven (label 1), welk deel was echt positief?
Recall (sensitiviteit): van alle werkelijk positieven (label 1), welk deel hebben we gevonden?
F1-score: harmonisch gemiddelde van precision en recall.
Support: aantal voorbeelden per klasse.
Accuracy: (TP + TN) / totaal — gevoelig voor class imbalance.
Macro avg: ongewogen gemiddelde over klassen.
Weighted avg: gewogen gemiddelde (weging = support).
Huidige set (support/accuracy)
Support klasse 0: {s0}, klasse 1: {s1}.
Accuracy (totaal): {acc:.3f}.
Macro avg F1: {macro.get('f1-score', 0):.3f}, Weighted avg F1: {weighted.get('f1-score', 0):.3f}.
Drempel-tips
Drempel omhoog → vaak hogere precision maar lagere recall.
Drempel omlaag → vaak hogere recall maar lagere precision.
"""
return md
# Visuele confusion-matrix (heatmap)
def make_confusion_heatmap(y_true, y_score, thr=0.5):
y_pred = (y_score >= thr).astype(int)
cm = confusion_matrix(y_true, y_pred, labels=[0, 1])
z = cm.astype(int)
xlabels = ["Pred 0", "Pred 1"]
ylabels = ["True 0", "True 1"]
fig = go.Figure(
data=go.Heatmap(
z=z, x=xlabels, y=ylabels,
colorscale="Blues", showscale=True
)
)
# Annotaties (TN, FP, FN, TP)
tn, fp, fn, tp = z.ravel()
annotations = [
(0, 0, f"TN: {tn}"),
(0, 1, f"FP: {fp}"),
(1, 0, f"FN: {fn}"),
(1, 1, f"TP: {tp}"),
]
for r, c, text in annotations:
fig.add_annotation(x=xlabels[c], y=ylabels[r], text=text, showarrow=False)
fig.update_layout(
title=f"Confusion matrix (drempel = {thr:.2f})",
xaxis_title="Voorspelling",
yaxis_title="Werkelijkheid",
template="simple_white",
margin=dict(l=10, r=10, t=40, b=10)
)
return fig
# -------- Eval-plots --------
def make_roc_fig(y_true, y_score, auroc=None):
fpr, tpr, _ = roc_curve(y_true, y_score)
title = f"ROC-curve (AUROC={auroc:.3f})" if auroc is not None else "ROC-curve"
fig = px.area(x=fpr, y=tpr, title=title, labels={"x":"False Positive Rate", "y":"True Positive Rate"})
fig.add_shape(type="line", x0=0, x1=1, y0=0, y1=1, line=dict(dash="dash"))
fig.update_layout(margin=dict(l=10, r=10, t=40, b=10), template="simple_white")
return fig
def make_pr_fig(y_true, y_score, auprc=None):
prec, rec, _ = precision_recall_curve(y_true, y_score)
title = f"Precision–Recall (AUPRC={auprc:.3f})" if auprc is not None else "Precision–Recall"
fig = px.area(x=rec, y=prec, title=title, labels={"x":"Recall", "y":"Precision"})
fig.update_layout(margin=dict(l=10, r=10, t=40, b=10), template="simple_white")
return fig
def make_prob_hist(y_true, y_score):
df = pd.DataFrame({"kans": y_score, "label": np.where(y_true==1, "Werkelijk: agressie (1)", "Werkelijk: geen agressie (0)")})
fig = px.histogram(df, x="kans", color="label", barmode="overlay", nbins=40,
title="Verdeling voorspelde kansen per werkelijke klasse",
labels={"kans":"Voorspelde kans"})
fig.update_traces(opacity=0.6)
fig.update_layout(margin=dict(l=10, r=10, t=40, b=10), template="simple_white")
return fig
def make_threshold_metrics_fig(y_true, y_score, thr_line=0.5):
thresholds = np.linspace(0.0, 1.0, 101)
rows = []
for t in thresholds:
y_pred = (y_score >= t).astype(int)
rows.append({
"threshold": t,
"precision": precision_score(y_true, y_pred, zero_division=0),
"recall": recall_score(y_true, y_pred, zero_division=0),
"f1": f1_score(y_true, y_pred, zero_division=0),
})
df = pd.DataFrame(rows)
df_m = df.melt(id_vars="threshold", value_vars=["precision","recall","f1"], var_name="metric", value_name="score")
fig = px.line(df_m, x="threshold", y="score", color="metric",
title="Metrics vs. drempel (precision/recall/F1)",
labels={"threshold":"Drempel", "score":"Score"})
fig.add_vline(x=float(thr_line), line_dash="dash", annotation_text=f"drempel={thr_line:.2f}", annotation_position="top")
fig.update_layout(margin=dict(l=10, r=10, t=40, b=10), template="simple_white", yaxis=dict(range=[0,1]))
return fig
# -------- Extra evaluaties: Kalibratie / Gains / Lift / KS --------
def make_calibration_fig(y_true, y_score, n_bins=10):
frac_pos, mean_pred = calibration_curve(y_true, y_score, n_bins=n_bins, strategy="quantile")
fig = go.Figure()
fig.add_trace(go.Scatter(x=[0,1], y=[0,1], mode="lines", name="Perfect gekalibreerd", line=dict(dash="dash")))
fig.add_trace(go.Scatter(x=mean_pred, y=frac_pos, mode="lines+markers", name="Model"))
fig.update_layout(
title="Kalibratie (Reliability Diagram)",
xaxis_title="Gemiddelde voorspelde kans",
yaxis_title="Werkelijk aandeel positieven",
template="simple_white",
margin=dict(l=10, r=10, t=40, b=10)
)
return fig
def _gains_data(y_true, y_score):
df = pd.DataFrame({"y": y_true, "p": y_score}).sort_values("p", ascending=False).reset_index(drop=True)
df["cum_pos"] = df["y"].cumsum()
total_pos = df["y"].sum()
total = len(df)
pct_samples = (np.arange(1, total+1) / total)
cum_gain = (df["cum_pos"] / (total_pos if total_pos > 0 else 1))
return pct_samples, cum_gain
def make_gains_fig(y_true, y_score):
x, gains = _gains_data(y_true, y_score)
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=x, mode="lines", name="Baseline (random)", line=dict(dash="dash")))
fig.add_trace(go.Scatter(x=x, y=gains, mode="lines", name="Cumulative Gains"))
fig.update_layout(
title="Cumulative Gains",
xaxis_title="Percentage van populatie (gesorteerd op kans)",
yaxis_title="Percentage van positieven gedekt",
template="simple_white",
margin=dict(l=10, r=10, t=40, b=10),
yaxis=dict(range=[0,1]), xaxis=dict(range=[0,1])
)
return fig
def make_lift_fig(y_true, y_score):
x, gains = _gains_data(y_true, y_score)
lift = gains / np.clip(x, 1e-9, None)
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=np.ones_like(x), mode="lines", name="Baseline (lift=1)", line=dict(dash="dash")))
fig.add_trace(go.Scatter(x=x, y=lift, mode="lines", name="Lift"))
fig.update_layout(
title="Lift-curve",
xaxis_title="Percentage van populatie (gesorteerd op kans)",
yaxis_title="Lift",
template="simple_white",
margin=dict(l=10, r=10, t=40, b=10)
)
return fig
def make_ks_fig(y_true, y_score):
df = pd.DataFrame({"y": y_true, "p": y_score}).sort_values("p", ascending=False).reset_index(drop=True)
total_pos = df["y"].sum()
total_neg = len(df) - total_pos
df["tp_cum"] = df["y"].cumsum() / (total_pos if total_pos > 0 else 1)
df["fp_cum"] = ((1 - df["y"]).cumsum()) / (total_neg if total_neg > 0 else 1)
ks_series = (df["tp_cum"] - df["fp_cum"]).abs()
ks_max_idx = int(ks_series.values.argmax()) if len(ks_series) else 0
ks_value = float(ks_series.iloc[ks_max_idx]) if len(ks_series) else 0.0
x = (np.arange(1, len(df)+1) / len(df)) if len(df) else np.array([0])
fig = go.Figure()
fig.add_trace(go.Scatter(x=x, y=df["tp_cum"], mode="lines", name="TPR cumulatief"))
fig.add_trace(go.Scatter(x=x, y=df["fp_cum"], mode="lines", name="FPR cumulatief"))
if len(x):
fig.add_vline(x=float(x[ks_max_idx]), line_dash="dash",
annotation_text=f"KS={ks_value:.3f}", annotation_position="top")
fig.update_layout(
title="KS-curve",
xaxis_title="Percentage van populatie (gesorteerd op kans)",
yaxis_title="Cumulatieve ratio",
template="simple_white",
margin=dict(l=10, r=10, t=40, b=10),
yaxis=dict(range=[0,1]), xaxis=dict(range=[0,1])
)
return fig
def make_dataset_profile(df):
text = df["rapportage"].astype(str)
lengths = text.str.len()
pos = df["agressie_volgende30d"].astype(int)
prof = pd.DataFrame({
"kenmerk": [
"Aantal rijen",
"Aantal positieven (1)",
"Aantal negatieven (0)",
"Positiefratio",
"Tekstlengte — gemiddeld",
"Tekstlengte — mediaan",
"Tekstlengte — p10",
"Tekstlengte — p90",
],
"waarde": [
int(len(df)),
int(pos.sum()),
int((1 - pos).sum()),
f"{(pos.mean()*100):.1f}%",
f"{lengths.mean():.1f}",
int(lengths.median()),
int(np.percentile(lengths, 10)),
int(np.percentile(lengths, 90)),
]
})
return prof
# ============ Model & Viz ============
def build_and_train(
df,
test_size=0.2,
random_state=42,
featurizer="TF-IDF",
max_features=4000,
ngram_max=2,
bert_maxlen=128,
bert_batch=16
):
X = df["rapportage"].astype(str).values
y = df["agressie_volgende30d"].values
X_train, X_test, y_train, y_test, idx_train, idx_test = train_test_split(
X, y, np.arange(len(X)),
test_size=test_size, random_state=random_state, stratify=y
)
if featurizer == "TF-IDF":
txt = TfidfVectorizer(max_features=max_features, ngram_range=(1, ngram_max))
clf = LogisticRegression(max_iter=3000)
pipe = Pipeline([("txt", txt), ("clf", clf)])
pipe.fit(X_train, y_train)
y_score = pipe.predict_proba(X_test)[:, 1]
txt_all = pipe.named_steps["txt"].transform(X) # sparse
elif featurizer == "ClinicalBERT":
emb = HFTextEmbedder(model_name="emilyalsentzer/Bio_ClinicalBERT",
max_length=bert_maxlen, batch_size=bert_batch)
clf = LogisticRegression(max_iter=3000)
pipe = Pipeline([("txt", emb), ("clf", clf)])
pipe.fit(X_train, y_train)
y_score = pipe.predict_proba(X_test)[:, 1]
txt_all = pipe.named_steps["txt"].transform(X) # dense
elif featurizer == "DutchBERT":
emb = HFTextEmbedder(model_name="wietsedv/bert-base-dutch-cased",
max_length=bert_maxlen, batch_size=bert_batch)
clf = LogisticRegression(max_iter=3000)
pipe = Pipeline([("txt", emb), ("clf", clf)])
pipe.fit(X_train, y_train)
y_score = pipe.predict_proba(X_test)[:, 1]
txt_all = pipe.named_steps["txt"].transform(X) # dense
else:
raise ValueError("Onbekende featurizer. Kies 'TF-IDF', 'ClinicalBERT' of 'DutchBERT'.")
auroc = float(roc_auc_score(y_test, y_score))
auprc = float(average_precision_score(y_test, y_score))
# 2D/3D embedding: SVD (50) -> t-SNE (2D en 3D)
svd = TruncatedSVD(n_components=50, random_state=random_state)
X50 = svd.fit_transform(txt_all)
# t-SNE 2D
tsne2 = TSNE(n_components=2, random_state=random_state, perplexity=30,
learning_rate="auto", init="pca")
X2 = tsne2.fit_transform(X50)
x2 = (X2[:, 0] - np.min(X2[:, 0])) / (np.ptp(X2[:, 0]) + 1e-9)
y2 = (X2[:, 1] - np.min(X2[:, 1])) / (np.ptp(X2[:, 1]) + 1e-9)
# t-SNE 3D
tsne3 = TSNE(n_components=3, random_state=random_state, perplexity=30,
learning_rate="auto", init="pca")
X3 = tsne3.fit_transform(X50)
x3 = (X3[:, 0] - np.min(X3[:, 0])) / (np.ptp(X3[:, 0]) + 1e-9)
y3 = (X3[:, 1] - np.min(X3[:, 1])) / (np.ptp(X3[:, 1]) + 1e-9)
z3 = (X3[:, 2] - np.min(X3[:, 2])) / (np.ptp(X3[:, 2]) + 1e-9)
proba_all = pipe.predict_proba(X)[:, 1]
plot_df = pd.DataFrame({
"x": x2, "y": y2,
"x3": x3, "y3": y3, "z3": z3,
"label": df["agressie_volgende30d"].values,
"kans": proba_all,
"rapportage": df["rapportage"].str.slice(0, 180) + "..."
})
for col in ["PHQ9_baseline","GAD7_baseline","stress_niveau_1_5","slaap_uren","sociale_steun_0_10","zorgsetting"]:
if col in df.columns:
plot_df[col] = df[col]
test_mask = np.zeros(len(plot_df), dtype=bool)
test_mask[idx_test] = True
plot_df["split"] = np.where(test_mask, "test", "train")
return pipe, (X_test, y_test, y_score), plot_df, auroc, auprc
def make_scatter(plot_df, color_mode="label", dim="2D"):
"""
Algemene scattermaker:
- color_mode: 'label' of 'kans'
- dim: '2D' of '3D'
"""
hover_cols = ["rapportage", "kans", "split"]
if color_mode == "label":
color = plot_df["label"].map({0: "geen agressie", 1: "agressie"})
title_2d = "2D projectie (t-SNE) — kleur = werkelijk label"
title_3d = "3D projectie (t-SNE) — kleur = werkelijk label"
if dim == "2D":
fig = px.scatter(
plot_df, x="x", y="y", color=color,
hover_data=hover_cols, title=title_2d, opacity=0.85
)
else:
fig = px.scatter_3d(
plot_df, x="x3", y="y3", z="z3", color=color,
hover_data=hover_cols, title=title_3d, opacity=0.9
)
else: # 'kans'
title_2d = "2D projectie (t-SNE) — kleur = voorspelde kans"
title_3d = "3D projectie (t-SNE) — kleur = voorspelde kans"
if dim == "2D":
fig = px.scatter(
plot_df, x="x", y="y", color="kans",
hover_data=hover_cols, title=title_2d,
color_continuous_scale="Turbo", opacity=0.9
)
else:
fig = px.scatter_3d(
plot_df, x="x3", y="y3", z="z3", color="kans",
hover_data=hover_cols, title=title_3d,
color_continuous_scale="Turbo", opacity=0.9
)
# Styling + ASTITELS
if dim == "2D":
fig.update_traces(marker=dict(size=8, line=dict(width=0)))
fig.update_layout(
margin=dict(l=10, r=10, t=40, b=10),
template="simple_white",
xaxis_title="x (t-SNE)",
yaxis_title="y (t-SNE)"
)
else:
fig.update_traces(marker=dict(size=4))
fig.update_layout(
margin=dict(l=10, r=10, t=40, b=10),
template="simple_white",
scene=dict(
xaxis_title="x (t-SNE)",
yaxis_title="y (t-SNE)",
zaxis_title="z (t-SNE)"
)
)
return fig
# --- (Niet meer gebruikt) Beslissingslandschap-overlay ---
def make_prob_with_decision_landscape(plot_df, grid_n=150):
"""
Achtergrond: LR(x,y)->label geeft per gridcel P(klasse=1).
Voorgrond: punten gekleurd naar model-kans (plot_df['kans']).
Wordt behouden voor referentie, maar niet meer gebruikt in de UI.
"""
X2 = plot_df[["x", "y"]].values
y = plot_df["label"].values.astype(int)
clf = LogisticRegression(max_iter=2000)
clf.fit(X2, y)
gx = np.linspace(0.0, 1.0, grid_n)
gy = np.linspace(0.0, 1.0, grid_n)
XX, YY = np.meshgrid(gx, gy)
grid = np.c_[XX.ravel(), YY.ravel()]
proba = clf.predict_proba(grid)[:, 1].reshape(XX.shape)
heat = go.Heatmap(
x=gx, y=gy, z=proba,
zmin=0, zmax=1,
colorscale="Turbo",
showscale=True,
colorbar=dict(title="kans (landschap)")
)
fig = go.Figure(data=[heat])
fig.update_layout(
title="2D projectie (t-SNE) — kleur = voorspelde kans (met beslissingslandschap)",
template="simple_white",
margin=dict(l=10, r=10, t=40, b=10),
xaxis_title="x (t-SNE)", yaxis_title="y (t-SNE)"
)
fig.add_trace(go.Scatter(
x=plot_df["x"], y=plot_df["y"],
mode="markers",
marker=dict(
size=8,
opacity=0.85,
color=plot_df["kans"],
colorscale="Turbo",
showscale=False,
line=dict(width=0)
),
text=(
"kans=" + plot_df["kans"].round(3).astype(str) +
" | split=" + plot_df["split"].astype(str)
),
hovertemplate="x=%{x:.3f}, y=%{y:.3f}
%{text}",
name="punten"
))
fig.update_xaxes(range=[0, 1])
fig.update_yaxes(range=[0, 1])
return fig
def metrics_table(y_true, y_score, thr):
"""
Maakt het classification report met eenheden (%, aantallen) voor compacte weergave.
- precision/recall/f1: percentages met 1 decimaal (bijv. 87.5%)
- support: integer
- accuracy: extra kolom 'accuracy_%' met percentage
"""
y_pred = (y_score >= thr).astype(int)
rep = classification_report(y_true, y_pred, output_dict=True, zero_division=0)
rep_df = pd.DataFrame(rep).T
rep_df_disp = rep_df.copy()
for col in ["precision", "recall", "f1-score"]:
if col in rep_df_disp:
rep_df_disp[col] = (rep_df_disp[col] * 100).round(1).map(
lambda v: f"{v:.1f}%" if pd.notnull(v) else ""
)
if "support" in rep_df_disp:
rep_df_disp["support"] = rep_df_disp["support"].map(
lambda v: f"{int(v)}" if pd.notnull(v) else ""
)
if "accuracy" in rep:
acc_pct = f"{rep['accuracy'] * 100:.1f}%"
rep_df_disp["accuracy_%"] = ""
if "accuracy" in rep_df_disp.index:
rep_df_disp.loc["accuracy", "accuracy_%"] = acc_pct
rep_df_disp = rep_df_disp.fillna("")
cm = confusion_matrix(y_true, y_pred)
cm_df = _format_confusion_df(cm)
rep_md = _build_report_markdown(rep, thr)
return rep_df_disp, cm_df, rep_md
# ============ State & Train ============
GLOBAL = {
"pipe": None, "plot_df": None, "eval": None,
"auroc": None, "auprc": None,
"featurizer": "TF-IDF",
"df": None, # bewaar dataset voor datavoorbeeld
}
def do_train(file_obj=None, test_size=0.2, seed=42,
featurizer="TF-IDF", max_features=4000, ngram_max=2,
bert_maxlen=128, bert_batch=16):
df = load_dataset(file_obj)
pipe, eval_pack, plot_df, auroc, auprc = build_and_train(
df, test_size, seed, featurizer, max_features, ngram_max, bert_maxlen, bert_batch
)
# MLflow logging
with mlflow.start_run(run_name=f"{featurizer}"):
mlflow.log_param("featurizer", featurizer)
mlflow.log_param("test_size", test_size)
if featurizer == "TF-IDF":
mlflow.log_param("tfidf_max_features", max_features)
mlflow.log_param("tfidf_ngram_max", ngram_max)
else:
mlflow.log_param("bert_maxlen", bert_maxlen)
mlflow.log_param("bert_batch", bert_batch)
mlflow.log_metric("auroc", auroc)
mlflow.log_metric("auprc", auprc)
mlflow.sklearn.log_model(pipe, artifact_path="model")
GLOBAL.update(pipe=pipe, plot_df=plot_df, eval=eval_pack,
auroc=auroc, auprc=auprc, featurizer=featurizer, df=df)
# Tabel + uitleg
rep_df, cm_df, rep_md = metrics_table(eval_pack[1], eval_pack[2], thr=0.5)
# Plots basis
roc_fig = make_roc_fig(eval_pack[1], eval_pack[2], auroc)
pr_fig = make_pr_fig(eval_pack[1], eval_pack[2], auprc)
hist_fig = make_prob_hist(eval_pack[1], eval_pack[2])
thr_fig = make_threshold_metrics_fig(eval_pack[1], eval_pack[2], thr_line=0.5)
# Standaard visualisaties: 2D
fig_label = make_scatter(plot_df, color_mode="label", dim="2D")
fig_prob = make_scatter(plot_df, color_mode="kans", dim="2D")
# Extra evaluaties
y_true, y_score = eval_pack[1], eval_pack[2]
cal_fig = make_calibration_fig(y_true, y_score, n_bins=10)
gains_fig = make_gains_fig(y_true, y_score)
lift_fig = make_lift_fig(y_true, y_score)
ks_fig = make_ks_fig(y_true, y_score)
profile_df = make_dataset_profile(df)
# Confusion heatmap op basis van default drempel
cm_plot = make_confusion_heatmap(y_true, y_score, thr=0.5)
# Datavoorbeeld (standaard: eerste 10 rijen)
preview_df = df.head(10)
status_msg = f"✅ Model getraind met {featurizer}. AUROC: {auroc:.3f} | AUPRC: {auprc:.3f}"
return (
status_msg, auroc, auprc,
preview_df, # datavoorbeeld output
fig_label, fig_prob,
rep_df, cm_df, cm_plot, rep_md,
roc_fig, pr_fig, hist_fig, thr_fig,
cal_fig, gains_fig, lift_fig, ks_fig, profile_df
)
def predict_one(text):
if GLOBAL["pipe"] is None:
return "Nog geen model getraind.", None
if not text or text.strip() == "":
return "Voer een rapportage in.", None
proba = float(GLOBAL["pipe"].predict_proba([text])[:, 1][0])
label = int(proba >= 0.5)
md = (
f"Kans op agressie (30d): {proba:.3f} — "
f"voorspelde klasse: {label} (drempel 0.50)\n"
f"Featurizer: {GLOBAL.get('featurizer','?')}"
)
return md, proba
# ============ UI ============
with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as demo:
# Volledige-breedte kopregel (h1)
gr.Markdown(f"# {SLOGAN}")
# --- opvallende styling voor de knoppen + scrollbare data-preview ---
gr.HTML("""
""")
# Introductie & overzicht naast elkaar
with gr.Row():
with gr.Column(scale=1):
gr.Markdown(INTRO)
with gr.Column(scale=1):
gr.Markdown(WHAT_YOU_SEE)
# ---- Handmatig trainen (zonder CSV upload) ----
gr.Markdown("## 🛠️ Handmatig trainen (zonder CSV upload)")
with gr.Row():
featur_quick = gr.Radio(
choices=["TF-IDF", "ClinicalBERT", "DutchBERT"],
value="TF-IDF",
label="Kies featurizer"
)
with gr.Row(visible=True) as tfidf_quick_row:
max_features_q = gr.Slider(1000, 12000, value=4000, step=1000, label="TF-IDF max_features")
ngram_max_q = gr.Radio(choices=[1, 2], value=2, label="n-gram max")
with gr.Row(visible=False) as bert_quick_row:
bert_maxlen_q = gr.Slider(64, 256, value=128, step=8, label="BERT max_length")
bert_batch_q = gr.Slider(4, 64, value=16, step=4, label="BERT batch_size")
train_quick_btn = gr.Button("Train algoritme", variant="primary", elem_id="train-btn")
status = gr.Markdown()
with gr.Row():
auroc_box = gr.Number(label="AUROC", precision=3)
auprc_box = gr.Number(label="AUPRC", precision=3)
# Visualisatie + evaluatie-tabellen
with gr.Row():
with gr.Column(scale=3):
gr.Markdown("### 🔍 Visualisatie")
# Gezamenlijke toggle voor dimensie
proj_dim = gr.Radio(choices=["2D", "3D"], value="2D", label="Projectiedimensie (geldt voor beide projecties)")
with gr.Column():
fig_out_label = gr.Plot(label="Projectie — kleur = werkelijk label")
fig_out_prob = gr.Plot(label="Projectie — kleur = voorspelde kans")
viz_img = gr.Image(value=INFO_IMAGE, show_label=False, interactive=False, elem_id="viz-img")
gr.Markdown(ML_STORY)
with gr.Column(scale=2):
gr.Markdown("### 📄 Datavoorbeeld")
data_preview_mode = gr.Radio(
choices=["Eerste 10 rijen", "Gehele dataset (scrollbaar)"],
value="Eerste 10 rijen",
label="Weergave"
)
data_preview = gr.Dataframe(label="Dataset", interactive=False, elem_id="data-preview")
gr.Markdown("### ⚙️ Evaluatie (tabellen & drempel)")
thr = gr.Slider(0.05, 0.95, value=0.5, step=0.05, label="Drempel (threshold)")
rep_df = gr.Dataframe(label="Classification report")
cm_df = gr.Dataframe(label="Confusion matrix (met uitleg)")
cm_plot = gr.Plot(label="Confusion matrix (heatmap)")
rep_md = gr.Markdown(label="Uitleg classification report")
# === Twee kolommen — links plots (met tabs), rechts predict ===
with gr.Row():
with gr.Column(scale=3):
with gr.Tabs():
with gr.TabItem("Metrics vs. drempel"):
thr_plot = gr.Plot(label="Precision/Recall/F1 over drempel")
with gr.TabItem("Kansverdeling"):
hist_plot = gr.Plot(label="Verdeling voorspelde kansen")
with gr.TabItem("ROC"):
roc_plot = gr.Plot(label="ROC-curve")
with gr.TabItem("Precision–Recall"):
pr_plot = gr.Plot(label="PR-curve")
# ---- Nieuw: extra tabs ----
with gr.TabItem("Kalibratie"):
cal_plot = gr.Plot(label="Kalibratie (Reliability Diagram)")
with gr.TabItem("Cumulative Gains"):
gains_plot = gr.Plot(label="Cumulative Gains")
with gr.TabItem("Lift"):
lift_plot = gr.Plot(label="Lift-curve")
with gr.TabItem("KS-curve"):
ks_plot = gr.Plot(label="KS-curve")
with gr.TabItem("Dataset-profiel"):
profile_df_out = gr.Dataframe(label="Dataset-profiel", interactive=False)
with gr.Column(scale=2):
gr.Markdown("### 🗣️ Predict (vrije tekst)")
with gr.Row():
txt = gr.Textbox(
lines=12, label="Rapportage (NL)",
placeholder="Bijv.: Patiënt oogt geagiteerd, slaapt slecht, weigert medicatie..."
)
btn = gr.Button("Voorspel", elem_id="predict-btn")
md_out = gr.Markdown()
proba_out = gr.Number(label="Kans", precision=3)
# ===== Hertrain met eigen CSV — ALTIJD ZICHTBAAR =====
gr.Markdown("## 🔁 Hertrain met eigen CSV")
gr.Markdown(
"Upload een CSV met kolommen `rapportage` (tekst) en `agressie_volgende30d` (0/1). "
"Kies je parameters en klik Train opnieuw (met upload)."
)
csv_in = gr.File(label="Upload CSV (kolommen: rapportage, agressie_volgende30d)")
with gr.Row():
test_size = gr.Slider(0.1, 0.4, value=0.2, step=0.05, label="Test set grootte")
seed = gr.Slider(1, 999, value=42, step=1, label="Random seed")
with gr.Row():
featur = gr.Radio(choices=["TF-IDF", "ClinicalBERT", "DutchBERT"], value="TF-IDF", label="Tekst-featurizer")
with gr.Row(visible=True) as tfidf_row:
max_features = gr.Slider(1000, 12000, value=4000, step=1000, label="TF-IDF max_features")
ngram_max = gr.Radio(choices=[1, 2], value=2, label="n-gram max")
with gr.Row(visible=False) as bert_row:
bert_maxlen = gr.Slider(64, 256, value=128, step=8, label="BERT max_length")
bert_batch = gr.Slider(4, 64, value=16, step=4, label="BERT batch_size")
retrain_btn = gr.Button("Train opnieuw (met upload)", elem_id="retrain-btn")
# << VERPLAATST: uitleg over de evaluatieplots — lager in dezelfde kolom >>
with gr.Row():
with gr.Column(scale=2, min_width=0):
gr.Markdown(
"### ℹ️ Over de evaluatieplots\n\n"
"De onderstaande grafieken laten zien hoe het model presteert bij verschillende drempels en uitkomsten:\n\n"
"- Metrics vs. drempel — toont hoe precision, recall en F1-score veranderen als je de drempel aanpast.\n"
"- Kansverdeling — laat zien hoe voorspelde kansen verdeeld zijn over de echte klassen (0/1).\n"
"- ROC-curve — vergelijkt True Positive Rate met False Positive Rate (AUROC = scheidingskracht).\n"
"- Precision–Recall-curve — nuttig bij ongebalanceerde data; focust op de positieve klasse.\n\n"
"Gebruik ze samen om te bepalen waar je drempel moet liggen en hoe betrouwbaar het model is."
)
# Toggle zichtbaarheid param-rijen
def _toggle_quick(choice):
return (
gr.update(visible=(choice == "TF-IDF")),
gr.update(visible=(choice in ("ClinicalBERT", "DutchBERT")))
)
featur_quick.change(_toggle_quick, inputs=featur_quick, outputs=[tfidf_quick_row, bert_quick_row])
def _toggle_rows(choice):
return (
gr.update(visible=(choice == "TF-IDF")),
gr.update(visible=(choice in ("ClinicalBERT", "DutchBERT")))
)
featur.change(_toggle_rows, inputs=featur, outputs=[tfidf_row, bert_row])
# ===== Interactie-functies =====
def _update_eval(t):
if GLOBAL["eval"] is None:
return None, None, None, None, None
y_true, y_score = GLOBAL["eval"][1], GLOBAL["eval"][2]
rep, cm, rep_md_text = metrics_table(y_true, y_score, t)
thr_fig_new = make_threshold_metrics_fig(y_true, y_score, thr_line=float(t))
cm_plot_new = make_confusion_heatmap(y_true, y_score, thr=float(t))
return rep, cm, cm_plot_new, rep_md_text, thr_fig_new
thr.release(_update_eval, inputs=thr, outputs=[rep_df, cm_df, cm_plot, rep_md, thr_plot])
# Datavoorbeeld wisselen
def _refresh_preview(mode):
df = GLOBAL.get("df")
if df is None or not isinstance(df, pd.DataFrame):
return None
if mode.startswith("Eerste"):
return df.head(10)
return df
data_preview_mode.change(_refresh_preview, inputs=data_preview_mode, outputs=data_preview)
btn.click(predict_one, inputs=txt, outputs=[md_out, proba_out])
# Handmatig trainen (zonder CSV upload)
def _train_quick(featur, max_features_q, ngram_max_q, bert_maxlen_q, bert_batch_q):
return do_train(None, 0.2, 42, featur, int(max_features_q), int(ngram_max_q),
int(bert_maxlen_q), int(bert_batch_q))
train_quick_btn.click(
_train_quick,
inputs=[featur_quick, max_features_q, ngram_max_q, bert_maxlen_q, bert_batch_q],
outputs=[status, auroc_box, auprc_box, data_preview,
fig_out_label, fig_out_prob,
rep_df, cm_df, cm_plot, rep_md,
roc_plot, pr_plot, hist_plot, thr_plot,
cal_plot, gains_plot, lift_plot, ks_plot, profile_df_out]
)
# Upload-hertrain
def _retrain(csv_in, test_size, seed, featur, max_features, ngram_max, bert_maxlen, bert_batch):
return do_train(csv_in, test_size, int(seed), featur, int(max_features), int(ngram_max),
int(bert_maxlen), int(bert_batch))
retrain_btn.click(
_retrain,
inputs=[csv_in, test_size, seed, featur, max_features, ngram_max, bert_maxlen, bert_batch],
outputs=[status, auroc_box, auprc_box, data_preview,
fig_out_label, fig_out_prob,
rep_df, cm_df, cm_plot, rep_md,
roc_plot, pr_plot, hist_plot, thr_plot,
cal_plot, gains_plot, lift_plot, ks_plot, profile_df_out]
)
# ---- Dimensie-toggle werkt op beide projecties ----
def _update_projection(dim):
pdf = GLOBAL.get("plot_df")
if pdf is None:
return None, None
fig_lbl = make_scatter(pdf, color_mode="label", dim=dim)
fig_prb = make_scatter(pdf, color_mode="kans", dim=dim)
return fig_lbl, fig_prb
proj_dim.change(_update_projection, inputs=proj_dim, outputs=[fig_out_label, fig_out_prob])
# ---- Auto-train bij openen met TF-IDF ----
def _auto_train():
try:
return do_train(None, 0.2, 42, "TF-IDF", 4000, 2, 128, 16)
except Exception as e:
return (f"❌ Fout bij laden/trainen: `{e}`",
None, None, None,
None, None,
None, None, None, None,
None, None, None, None,
None, None, None, None, None)
demo.load(_auto_train, inputs=None,
outputs=[status, auroc_box, auprc_box, data_preview,
fig_out_label, fig_out_prob,
rep_df, cm_df, cm_plot, rep_md,
roc_plot, pr_plot, hist_plot, thr_plot,
cal_plot, gains_plot, lift_plot, ks_plot, profile_df_out])
# --- Explainability tab/accordion ---
with gr.Accordion("🪄 Uitleg (Explainability)", open=False):
gr.Markdown("Leg uit waarom het model een voorspelling maakt (LIME).")
with gr.Row():
txt_explain = gr.Textbox(lines=4, label="Tekst om uit te leggen",
placeholder="Plak hier een rapportage voor uitleg")
btn_explain = gr.Button("Genereer uitleg")
lime_html = gr.HTML(label="LIME uitleg (per voorbeeld)")
# Optioneel: globale top-woorden (alleen TF-IDF)
top_pos_df = gr.Dataframe(headers=["Top pro-agressie woorden"], row_count=5)
top_neg_df = gr.Dataframe(headers=["Top anti-agressie woorden"], row_count=5)
def _do_explain(text):
if GLOBAL["pipe"] is None:
return "Train eerst een model.", None, None
html = lime_explain_text(GLOBAL["pipe"], text, num_features=8)
pos, neg = tfidf_global_top_words(GLOBAL["pipe"], k=15)
pos = [[w] for w in pos] if pos else None
neg = [[w] for w in neg] if neg else None
return html, pos, neg
btn_explain.click(_do_explain, inputs=txt_explain, outputs=[lime_html, top_pos_df, top_neg_df])
gr.Markdown(FOOTER)
if __name__ == "__main__":
demo.launch()