Update app.py

app.py

@@ -1,10 +1,15 @@
-# app.py — GGZ Agressie (synthetisch) — stabiele, uitlegbare versie
-# Fixes:
-# - Geen isotone overkalibratie; standaard 'sigmoid' (of pure LR)
-# - KeywordBoost-kenmerken (geweld-lexicon) voor robuuste signalen
-# - FeatureUnion werkt voor TF-IDF én BERT/XLM-R (dense→sparse adapter)
-# - Top-woorden uitlegbaarheid blijft bruikbaar met FeatureUnion-slice
-# - UI/outputs exact 22; auto-train faalpad matched
+# 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
@@ -25,21 +30,17 @@ from sklearn.metrics import (
 )
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.linear_model import LogisticRegression
-from sklearn.pipeline import Pipeline, FeatureUnion
+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, CalibratedClassifierCV
-from sklearn.metrics import brier_score_loss
+from sklearn.calibration import calibration_curve
 
-from scipy import sparse
-import re
-
-# --- MLflow + LIME ---
+# --- NEW: experiment tracking + explainability ---
 import mlflow, mlflow.sklearn
 from lime.lime_text import LimeTextExplainer
 
-# --- Optionele DL-deps voor BERT ---
+# --- Optional DL deps (voor BERT) ---
 try:
     import torch
     from transformers import AutoTokenizer, AutoModel
@@ -51,73 +52,80 @@ except Exception:
 # ============ 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")
-if not os.path.exists(INFO_IMAGE):
-    INFO_IMAGE = None
 
+# 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**
-Plak een stukje verslag in het tekstvak en je krijgt een kans terug plus een labeladvies.
-Je kunt hertrainen met TF-IDF (woord/char) of BERT/XLM-R, en je ziet scheiding (AUROC/AUPRC),
-kalibratie (Brier/reliability) en uitleg (LIME).
+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?**
-**Status & prestaties** — AUROC/AUPRC; extra: kalibratie (Brier), gains, lift, KS.  
-**Trainen** — kies featurizer en vergelijk.  
-**Visualisatie** — 2D/3D-projecties (label/kans).  
-**Evaluatie** — drempel schuiven; confusion matrix met uitleg.  
-**Predict** — rapportage + (optionele) context.  
-**Hertrain** — CSV met `rapportage`, optioneel `context`, en `agressie_volgende30d` (0/1).
+**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**
-Tekst → kenmerken (TF-IDF of BERT) → kans op 30-dagenrisico. Kalibratie (Brier/reliability)
-maakt kans→actie betrouwbaar; Gains/Lift/KS helpen bij triage (top x%). LIME toont bijdragen.
+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 = """
-**Technisch**
-Modellen: TF-IDF/char TF-IDF/XLM-R/DutchBERT/ClinicalBERT → Logistic Regression (+ opt. CalibratedClassifierCV(method='sigmoid'), class_weight='balanced')  
-Visualisatie: SVD(50) → t-SNE(2D/3D)  
-CSV: `rapportage` (str), optioneel `context` (str), `agressie_volgende30d` (0/1)
+**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")
 
-# ============ Context helpers ============
-CTX_START = "[CTX]"
-TARGET_START = "[TARGET]"
-SEP = "[SEP]"
-
-def concat_with_context(context: str, current: str) -> str:
-    context = (context or "").strip()
-    current = (current or "").strip()
-    if context:
-        return f"{CTX_START} {context} {SEP} {TARGET_START} {current}"
-    return f"{TARGET_START} {current}"
-
 # ============ Data loading ============
 def _resolve_csv_path(uploaded=None):
     if uploaded is not None:
         return uploaded.name if hasattr(uploaded, "name") else uploaded
-    for p in [
+    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 in de repo-root of upload een CSV met "
-        "`rapportage` en `agressie_volgende30d` (en optioneel `context`)."
+        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):
@@ -127,54 +135,22 @@ def load_dataset(file_obj=None):
     missing = required - set(df.columns)
     if missing:
         raise ValueError(f"CSV mist verplichte kolommen: {missing}")
-    if "context" not in df.columns:
-        df["context"] = ""
     df = df.dropna(subset=["rapportage", "agressie_volgende30d"]).copy()
     df["agressie_volgende30d"] = (df["agressie_volgende30d"].astype(int) > 0).astype(int)
-    df["rapportage_ctx"] = df.apply(lambda r: concat_with_context(r.get("context",""), r["rapportage"]), axis=1)
     return df
 
-# ============ Extra features ============
-class KeywordBoost(BaseEstimator, TransformerMixin):
-    """Kleine lexicon-feature: vangt 'geweld'-signalen. Geeft 2 kolommen: count, binary."""
-    def __init__(self, lexicon=None):
-        self.lexicon = lexicon or [
-            r"\bgewelddadig(e|heid)?\b",
-            r"\bgeweld\b",
-            r"\bextreem\s+gewelddadig\b",
-            r"\b(ontzettend|heel|zeer)\s+boos\b",
-            r"\bwoedend\b",
-            r"\bbedreig\w*\b", r"\bbedreigend\b",
-            r"\b(sla(an|at|gen|g)|slaan)\b", r"\bschop(pen|t|te)?\b",
-            r"\baanval(len|lig)\b",
-            r"\bagressie(f|viteit)?\b", r"\bagressief\b",  # vaak spelfout met 1 g/s
-        ]
-        self._pat = re.compile("|".join(self.lexicon), flags=re.IGNORECASE)
-
-    def fit(self, X, y=None): return self
-    def transform(self, X):
-        texts = pd.Series(X).astype(str)
-        counts = texts.str.count(self._pat).fillna(0).to_numpy().reshape(-1,1)
-        binary = (counts > 0).astype(int)
-        # output als sparse voor compatibiliteit met TF-IDF
-        return sparse.csr_matrix(np.hstack([counts, binary]).astype("float32"))
-
-class DenseAdapter(BaseEstimator, TransformerMixin):
-    """Wrapt een dense transformer (bv. HFTextEmbedder) en zet uitkomst om naar CSR-sparse."""
-    def __init__(self, base):
-        self.base = base
-    def fit(self, X, y=None):
-        self.base.fit(X, y)
-        return self
-    def transform(self, X):
-        arr = self.base.transform(X)
-        if sparse.issparse(arr):
-            return arr
-        return sparse.csr_matrix(arr)
-
 # ============ HF Text Embedder ============
 class HFTextEmbedder(BaseEstimator, TransformerMixin):
-    def __init__(self, model_name="emilyalsentzer/Bio_ClinicalBERT", max_length=128, batch_size=16, device=None):
+    """
+    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
@@ -182,20 +158,21 @@ class HFTextEmbedder(BaseEstimator, TransformerMixin):
         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)
-            self._tokenizer.add_special_tokens({"additional_special_tokens":[CTX_START, TARGET_START, SEP]})
         if self._model is None:
-            self._model = AutoModel.from_pretrained(self.model_name)
-            self._model.resize_token_embeddings(len(self._tokenizer))
-            self._model.to(self._dev)
+            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
+        self._ensure_backend()
+        return self
+
     @torch.no_grad()
     def transform(self, X):
         self._ensure_backend()
@@ -205,70 +182,50 @@ class HFTextEmbedder(BaseEstimator, TransformerMixin):
         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
-            mask = toks.attention_mask.unsqueeze(-1)
-            pooled = (outs * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1)
+            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 ============
-_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()
-
 def _clf_and_vectorizer_from_pipe(pipe):
     vec = pipe.named_steps.get("txt")
     clf = pipe.named_steps.get("clf")
     return vec, clf
 
-def _get_lr_from_calibrator(clf):
-    # CalibratedClassifierCV(method='sigmoid') expose't estimator
-    return getattr(clf, "estimator", getattr(clf, "base_estimator", clf))
-
 def tfidf_global_top_words(pipe, k=20):
-    """
-    Haal top pro/anti woorden uit TF-IDF deel, ook als er een FeatureUnion is met KeywordBoost.
-    """
+    """Top-k 'pro-agressie' en 'anti-agressie' woorden (alleen bij TF-IDF)."""
     vec, clf = _clf_and_vectorizer_from_pipe(pipe)
-    # Zoek TF-IDF transformer en aantal features
-    tfidf = None
-    n_tfidf = None
-    if isinstance(vec, FeatureUnion):
-        # zoek subtransformer 'tfidf'
-        for name, tr in vec.transformer_list:
-            if name == "tfidf":
-                tfidf = tr
-                break
-        if tfidf is None or not hasattr(tfidf, "get_feature_names_out"):
-            return [], []
-        feature_names = np.array(tfidf.get_feature_names_out())
-        n_tfidf = len(feature_names)
-    else:
-        if not hasattr(vec, "get_feature_names_out"):
-            return [], []
-        tfidf = vec
-        feature_names = np.array(tfidf.get_feature_names_out())
-        n_tfidf = len(feature_names)
-
-    lr = _get_lr_from_calibrator(clf)
-    if not hasattr(lr, "coef_"):
+    if not hasattr(vec, "get_feature_names_out"):
         return [], []
-    coefs = lr.coef_[0]
-    # Bij FeatureUnion komen TF-IDF kolommen eerst (we voegen KeywordBoost erna toe)
-    tfidf_coefs = coefs[:n_tfidf]
-    top_pos_idx = np.argsort(tfidf_coefs)[-k:][::-1]
-    top_neg_idx = np.argsort(tfidf_coefs)[:k]
+    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])
 
-# ============ Metrics helpers & plots ============
+_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()
@@ -288,47 +245,77 @@ def _build_report_markdown(rep: dict, thr: float) -> str:
     weighted = rep.get("weighted avg", {})
     s0 = int(rep.get("0", {}).get("support", 0))
     s1 = int(rep.get("1", {}).get("support", 0))
-    return f"""
+    md = f"""
 ### ℹ️ Uitleg bij het classification report (drempel = {thr:.2f})
-0 = geen agressie, 1 = agressie. Drempel bepaalt label 1 (≥) of 0 (<).
-Support(0/1): {s0}/{s1} — Accuracy: {acc:.3f} — Macro F1: {macro.get('f1-score', 0):.3f} — Weighted F1: {weighted.get('f1-score', 0):.3f}.
+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
 
-def best_threshold_f1(y_true, y_score):
-    thr = np.linspace(0, 1, 1001)
-    best_t, best_f1 = 0.5, -1
-    for t in thr:
-        y_pred = (y_score >= t).astype(int)
-        f1 = f1_score(y_true, y_pred, zero_division=0)
-        if f1 > best_f1:
-            best_f1, best_t = f1, float(t)
-    return best_t, best_f1
-
+# 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)
-    fig = go.Figure(data=go.Heatmap(z=z, x=["Pred 0", "Pred 1"], y=["True 0", "True 1"], colorscale="Blues", showscale=True))
+    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()
-    for (r,c,text) in [(0,0,f"TN: {tn}"), (0,1,f"FP: {fp}"), (1,0,f"FN: {fn}"), (1,1,f"TP: {tp}")]:
-        fig.add_annotation(x=["Pred 0","Pred 1"][c], y=["True 0","True 1"][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))
+    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")
+    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")
+    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):
@@ -337,7 +324,7 @@ def make_prob_hist(y_true, y_score):
                        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")
+    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):
@@ -345,105 +332,129 @@ def make_threshold_metrics_fig(y_true, y_score, thr_line=0.5):
     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)})
+        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]))
+    fig.update_layout(margin=dict(l=10, r=10, t=40, b=10), template="simple_white", yaxis=dict(range=[0,1]))
     return fig
 
-# -------- Nieuwe diagnostische plots --------
-def make_calibration_fig(y_true, y_score):
-    prob_true, prob_pred = calibration_curve(y_true, y_score, n_bins=10, strategy="quantile")
-    brier = brier_score_loss(y_true, y_score)
+# -------- 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=prob_pred, y=prob_true, mode="lines+markers", name="gekalibreerde kansen"))
-    fig.add_trace(go.Scatter(x=[0,1], y=[0,1], mode="lines", name="perfect", line=dict(dash="dash")))
-    fig.update_layout(title=f"Kalibratie (reliability) — Brier={brier:.3f}",
-                      xaxis_title="Voorspelde kans", yaxis_title="Werkelijke kans",
-                      template="simple_white", margin=dict(l=10,r=10,t=40,b=10))
-    return fig, float(brier)
-
-def make_cumulative_gains_fig(y_true, y_score):
+    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()
-    n = len(df)
-    x = (np.arange(1, n+1) / n)
-    y = (df["cum_pos"] / max(total_pos, 1e-9))
+    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=y, mode="lines", name="model"))
-    fig.add_trace(go.Scatter(x=x, y=x, mode="lines", name="random", line=dict(dash="dash")))
-    fig.update_layout(title="Cumulative Gains",
-                      xaxis_title="Fractie van populatie (gesorteerd op kans)",
-                      yaxis_title="Fractie gevangen positieven",
-                      template="simple_white", margin=dict(l=10,r=10,t=40,b=10))
+    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):
-    df = pd.DataFrame({"y": y_true, "p": y_score}).sort_values("p", ascending=False).reset_index(drop=True)
-    total_pos = df["y"].sum()
-    base_rate = total_pos / max(len(df), 1e-9)
-    x, lift = [], []
-    for k in range(1, len(df)+1):
-        frac = k / len(df)
-        captured = df.loc[:k-1, "y"].sum() / max(k, 1e-9)
-        lift.append(captured / max(base_rate, 1e-9))
-        x.append(frac)
+    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=lift, mode="lines", name="lift"))
-    fig.add_hline(y=1.0, line_dash="dash")
-    fig.update_layout(title="Lift-curve",
-                      xaxis_title="Fractie van populatie (gesorteerd op kans)",
-                      yaxis_title="Lift (t.o.v. random=1)",
-                      template="simple_white", margin=dict(l=10,r=10,t=40,b=10))
+    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")
-    pos = df[df["y"]==1]["p"].values
-    neg = df[df["y"]==0]["p"].values
-    grid = np.linspace(0, 1, 201)
-    cdf_pos = np.searchsorted(np.sort(pos), grid, side="right") / max(len(pos), 1e-9)
-    cdf_neg = np.searchsorted(np.sort(neg), grid, side="right") / max(len(neg), 1e-9)
-    diff = np.abs(cdf_pos - cdf_neg)
-    ks_idx = int(np.argmax(diff))
-    ks_x, ks_y = float(grid[ks_idx]), float(diff[ks_idx])
+    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=grid, y=cdf_pos, mode="lines", name="CDF positief"))
-    fig.add_trace(go.Scatter(x=grid, y=cdf_neg, mode="lines", name="CDF negatief"))
-    fig.add_vline(x=ks_x, line_dash="dot", annotation_text=f"KS={ks_y:.3f} @ {ks_x:.2f}")
-    fig.update_layout(title="KS-curve (Kolmogorov–Smirnov)",
-                      xaxis_title="Score", yaxis_title="Cumulatieve fractie",
-                      template="simple_white", margin=dict(l=10,r=10,t=40,b=10))
-    return fig, ks_y, ks_x
+    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 metrics_table(y_true, y_score, thr):
-    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
+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(
@@ -456,104 +467,56 @@ def build_and_train(
     bert_maxlen=128,
     bert_batch=16
 ):
-    X = df["rapportage_ctx"].astype(str).values
+    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
     )
 
-    kb = KeywordBoost()
-
-    def make_lr(sigmoid=True):
-        base = LogisticRegression(max_iter=3000, class_weight="balanced")
-        if sigmoid:
-            # stabielere kalibratie dan isotonic op kleine sets
-            return CalibratedClassifierCV(estimator=base, method="sigmoid", cv=3)
-        return base
-
     if featurizer == "TF-IDF":
-        tfidf = TfidfVectorizer(max_features=max_features, ngram_range=(1, ngram_max))
-        feats = FeatureUnion([("tfidf", tfidf), ("kb", kb)])
-        clf = make_lr(sigmoid=True)
-        pipe = Pipeline([("txt", feats), ("clf", clf)])
-        pipe.fit(X_train, y_train)
-        y_score = pipe.predict_proba(X_test)[:, 1]
-        # alleen TF-IDF deel voor SVD/TSNE (eerste blok kolommen)
-        n_tfidf = len(tfidf.get_feature_names_out())
-        txt_all = feats.transform(X)
-        X_tfidf_only = txt_all[:, :n_tfidf]
-
-    elif featurizer == "TF-IDF (char 3–5)":
-        tfidf = TfidfVectorizer(analyzer="char_wb", ngram_range=(3,5), min_df=2, max_features=max_features)
-        feats = FeatureUnion([("tfidf", tfidf), ("kb", kb)])
-        clf = make_lr(sigmoid=True)
-        pipe = Pipeline([("txt", feats), ("clf", clf)])
+        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]
-        n_tfidf = len(tfidf.get_feature_names_out())
-        txt_all = feats.transform(X)
-        X_tfidf_only = txt_all[:, :n_tfidf]
-
+        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)
-        emb_sparse = DenseAdapter(emb)
-        feats = FeatureUnion([("bert", emb_sparse), ("kb", kb)])
-        clf = make_lr(sigmoid=True)
-        pipe = Pipeline([("txt", feats), ("clf", clf)])
+        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]
-        # voor visualisatie gebruiken we de BERT-embeddings (eerste blok kolommen)
-        emb_sample = emb.transform(["x"])
-        n_emb = emb_sample.shape[1]
-        X_all = feats.transform(X)
-        X_tfidf_only = X_all[:, :n_emb]  # hier: "embeddings-only" voor SVD
-
+        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)
-        emb_sparse = DenseAdapter(emb)
-        feats = FeatureUnion([("bert", emb_sparse), ("kb", kb)])
-        clf = make_lr(sigmoid=True)
-        pipe = Pipeline([("txt", feats), ("clf", clf)])
+        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]
-        emb_sample = emb.transform(["x"])
-        n_emb = emb_sample.shape[1]
-        X_all = feats.transform(X)
-        X_tfidf_only = X_all[:, :n_emb]
-
-    elif featurizer == "XLM-RoBERTa":
-        emb = HFTextEmbedder(model_name="xlm-roberta-base",
-                             max_length=bert_maxlen, batch_size=bert_batch)
-        emb_sparse = DenseAdapter(emb)
-        feats = FeatureUnion([("bert", emb_sparse), ("kb", kb)])
-        clf = make_lr(sigmoid=True)
-        pipe = Pipeline([("txt", feats), ("clf", clf)])
-        pipe.fit(X_train, y_train)
-        y_score = pipe.predict_proba(X_test)[:, 1]
-        emb_sample = emb.transform(["x"])
-        n_emb = emb_sample.shape[1]
-        X_all = feats.transform(X)
-        X_tfidf_only = X_all[:, :n_emb]
-
+        txt_all = pipe.named_steps["txt"].transform(X)  # dense
     else:
-        raise ValueError("Onbekende featurizer. Kies 'TF-IDF', 'TF-IDF (char 3–5)', 'ClinicalBERT', 'DutchBERT' of 'XLM-RoBERTa'.")
+        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/3D) op gekozen basisfeatures
+    # 2D/3D embedding: SVD (50) -> t-SNE (2D en 3D)
     svd = TruncatedSVD(n_components=50, random_state=random_state)
-    X50 = svd.fit_transform(X_tfidf_only)
+    X50 = svd.fit_transform(txt_all)
 
-    tsne2 = TSNE(n_components=2, random_state=random_state, perplexity=30, learning_rate="auto", init="pca")
+    # 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)
 
-    tsne3 = TSNE(n_components=3, random_state=random_state, perplexity=30, learning_rate="auto", init="pca")
+    # 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)
@@ -565,7 +528,7 @@ def build_and_train(
         "x3": x3, "y3": y3, "z3": z3,
         "label": df["agressie_volgende30d"].values,
         "kans": proba_all,
-        "rapportage": df["rapportage"].astype(str).str.slice(0, 180) + "..."
+        "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:
@@ -575,55 +538,180 @@ def build_and_train(
     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, df
+    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)
+            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:
+            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)
+            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)
+            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)")
+        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)"))
+        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}<br>%{text}<extra></extra>",
+        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,
-    "thr_suggested": 0.5
+    "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, full_df = build_and_train(
+    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.startswith("TF-IDF"):
+        if featurizer == "TF-IDF":
             mlflow.log_param("tfidf_max_features", max_features)
             mlflow.log_param("tfidf_ngram_max", ngram_max)
         else:
@@ -634,86 +722,103 @@ def do_train(file_obj=None, test_size=0.2, seed=42,
         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=full_df)
+                  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")
 
-    cm_plot = make_confusion_heatmap(eval_pack[1], eval_pack[2], thr=0.5)
-
-    preview_df = full_df.head(10)[["rapportage","context","agressie_volgende30d"]]
-
-    t_star, _ = best_threshold_f1(eval_pack[1], eval_pack[2])
-    GLOBAL["thr_suggested"] = t_star
+    # 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)
 
-    cal_fig, brier = make_calibration_fig(eval_pack[1], eval_pack[2])
-    gains_fig = make_cumulative_gains_fig(eval_pack[1], eval_pack[2])
-    lift_fig = make_lift_fig(eval_pack[1], eval_pack[2])
-    ks_fig, ks_val, ks_at = make_ks_fig(eval_pack[1], eval_pack[2])
-    cls_bar = make_class_balance_bar(full_df)
-    len_hist = make_text_length_hist(full_df)
+    # Confusion heatmap op basis van default drempel
+    cm_plot = make_confusion_heatmap(y_true, y_score, thr=0.5)
 
-    thr_md = f"**Aanbevolen drempel (F1):** `{t_star:.2f}` · **Brier:** `{brier:.3f}` · **KS:** `{ks_val:.3f}` (score ≈ `{ks_at:.2f}`)"
-    status_msg = f"✅ Model getraind met {featurizer}. AUROC: {auroc:.3f} | AUPRC: {auprc:.3f} | Suggested thr (F1): {t_star:.2f}"
+    # 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,
+        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, brier, gains_fig, lift_fig, ks_fig, thr_md, cls_bar, len_hist
+        cal_fig, gains_fig, lift_fig, ks_fig, profile_df
     )
 
-def predict_one(text, ctx=None):
+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
-    merged = concat_with_context(ctx or "", text)
-    proba = float(GLOBAL["pipe"].predict_proba([merged])[:, 1][0])
-    thr_use = float(GLOBAL.get("thr_suggested", 0.5))
-    label = int(proba >= thr_use)
+    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 {thr_use:.2f})\n"
+        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("""
     <style>
+      /* Zelfde gradient-stijl voor alle 3 knoppen */
       #train-btn, #retrain-btn, #predict-btn {
         background: linear-gradient(90deg, #ef4444 0%, #f97316 100%);
-        color: white !important; font-weight: 700; border: none !important;
+        color: white !important;
+        font-weight: 700;
+        border: none !important;
+      }
+      #train-btn:hover, #retrain-btn:hover, #predict-btn:hover {
+        filter: brightness(0.95);
+      }
+      /* Scrollbare DataFrame container */
+      #data-preview {
+        max-height: 320px;
+        overflow: auto;
       }
-      #train-btn:hover, #retrain-btn:hover, #predict-btn:hover { filter: brightness(0.95); }
-      #data-preview { max-height: 320px; overflow: auto; }
-      #data-preview table { width: 100%; }
+      #data-preview table {
+        width: 100%;
+      }
+      /* Afbeelding direct onder projectie zonder top-ruimte */
       #viz-img { margin-top: 0 !important; padding-top: 0 !important; }
       #viz-img img { display: block; margin-top: 0 !important; }
     </style>
     """)
 
+    # 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)
+        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", "TF-IDF (char 3–5)", "ClinicalBERT", "DutchBERT", "XLM-RoBERTa"],
+            choices=["TF-IDF", "ClinicalBERT", "DutchBERT"],
             value="TF-IDF",
             label="Kies featurizer"
         )
@@ -729,11 +834,12 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
     with gr.Row():
         auroc_box = gr.Number(label="AUROC", precision=3)
         auprc_box = gr.Number(label="AUPRC", precision=3)
-        thr_badge = gr.Markdown()
 
+    # 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")
@@ -742,7 +848,11 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
                 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_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)")
@@ -752,6 +862,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
             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():
@@ -763,11 +874,9 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
                     roc_plot = gr.Plot(label="ROC-curve")
                 with gr.TabItem("Precision–Recall"):
                     pr_plot = gr.Plot(label="PR-curve")
-            with gr.Tabs():
+                # ---- Nieuw: extra tabs ----
                 with gr.TabItem("Kalibratie"):
-                    calib_plot = gr.Plot(label="Reliability diagram")
-                    brier_box = gr.Number(label="Brier-score", precision=3)
-                    gr.Markdown("Lagere Brier is beter; lijn dicht bij de diagonaal = goede 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"):
@@ -775,29 +884,30 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
                 with gr.TabItem("KS-curve"):
                     ks_plot = gr.Plot(label="KS-curve")
                 with gr.TabItem("Dataset-profiel"):
-                    cls_bar_plot = gr.Plot(label="Klassenbalans")
-                    len_hist_plot = gr.Plot(label="Tekstlengteverdeling")
+                    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 is extreem geagiteerd, weigert medicatie...")
-            with gr.Row():
-                ctx_txt = gr.Textbox(lines=6, label="Vorige context (optioneel)",
-                                     placeholder="Bijv.: eerdere observaties of citaten uit het dossier...")
+                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 `rapportage` (tekst), optioneel `context`, en `agressie_volgende30d` (0/1).")
-    csv_in = gr.File(label="Upload CSV (kolommen: rapportage, [context], agressie_volgende30d)")
+    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", "TF-IDF (char 3–5)", "ClinicalBERT", "DutchBERT", "XLM-RoBERTa"],
-                          value="TF-IDF", label="Tekst-featurizer")
+        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")
@@ -806,33 +916,35 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
         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"
-                "- Metrics vs. drempel — precision, recall, F1 over de drempel.\n"
-                "- Kansverdeling — voorspelde kansen per werkelijke klasse.\n"
-                "- ROC & PR — scheidingskracht, nuttig bij onbalans.\n"
-                "- Kalibratie — betrouwbaarheid van kansen (Brier lager is beter).\n"
-                "- Gains/Lift/KS — inzicht voor triage (top x% casussen)."
+                "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."
             )
 
-    # Toggles
+    # Toggle zichtbaarheid param-rijen
     def _toggle_quick(choice):
         return (
-            gr.update(visible=(choice.startswith("TF-IDF"))),
-            gr.update(visible=(choice in ("ClinicalBERT", "DutchBERT", "XLM-RoBERTa")))
+            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.startswith("TF-IDF"))),
-            gr.update(visible=(choice in ("ClinicalBERT", "DutchBERT", "XLM-RoBERTa")))
+            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
+    # ===== Interactie-functies =====
     def _update_eval(t):
         if GLOBAL["eval"] is None:
             return None, None, None, None, None
@@ -841,19 +953,22 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
         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
-        cols = [c for c in ["rapportage","context","agressie_volgende30d"] if c in df.columns]
-        show = df[cols]
-        return show.head(10) if mode.startswith("Eerste") else show
+        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, ctx_txt], outputs=[md_out, proba_out])
+    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))
@@ -864,9 +979,10 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
                  fig_out_label, fig_out_prob,
                  rep_df, cm_df, cm_plot, rep_md,
                  roc_plot, pr_plot, hist_plot, thr_plot,
-                 calib_plot, brier_box, gains_plot, lift_plot, ks_plot, thr_badge, cls_bar_plot, len_hist_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))
@@ -877,57 +993,62 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="red", neutral_hue="slate")) as
                  fig_out_label, fig_out_prob,
                  rep_df, cm_df, cm_plot, rep_md,
                  roc_plot, pr_plot, hist_plot, thr_plot,
-                 calib_plot, brier_box, gains_plot, lift_plot, ks_plot, thr_badge, cls_bar_plot, len_hist_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
-        return make_scatter(pdf, color_mode="label", dim=dim), make_scatter(pdf, color_mode="kans",  dim=dim)
+        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: exact 22 outputs bij error
+    # ---- 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, None, None, None
-            )
+            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,
-                       calib_plot, brier_box, gains_plot, lift_plot, ks_plot, thr_badge, cls_bar_plot, len_hist_plot])
+                       cal_plot, gains_plot, lift_plot, ks_plot, profile_df_out])
 
-    # Explainability
+    # --- Explainability tab/accordion ---
     with gr.Accordion("🪄 Uitleg (Explainability)", open=False):
-        gr.Markdown("LIME legt afzonderlijke voorspellingen uit. 'Top woorden' werken voor TF-IDF-varianten.")
+        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")
+            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, ctx=""):
+        def _do_explain(text):
             if GLOBAL["pipe"] is None:
                 return "Train eerst een model.", None, None
-            merged = concat_with_context(ctx or "", text or "")
-            html = lime_explain_text(GLOBAL["pipe"], merged, num_features=8)
+            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, ctx_txt], outputs=[lime_html, top_pos_df, top_neg_df])
+        btn_explain.click(_do_explain, inputs=txt_explain, outputs=[lime_html, top_pos_df, top_neg_df])
 
     gr.Markdown(FOOTER)