Upload 10 files

README.md

@@ -0,0 +1,175 @@
+---
+license: mit
+tags:
+  - neuroscience
+  - fMRI
+  - brain-decoding
+  - text-to-brain
+  - audio-to-brain
+  - naturalistic-fMRI
+  - ROI-prediction
+  - cognitive-neuroscience
+  - brain-encoding
+  - zero-shot
+library_name: custom
+language:
+  - en
+datasets:
+  - narratives
+  - little-prince
+  - hcp
+  - cneuromod
+pipeline_tag: feature-extraction
+---
+
+# Amphora NeuroText v4 — Audio & Text → Brain ROI Activation
+
+> **Zero-shot brain encoder: predict which brain regions activate in response to any audio or text — no fMRI required at inference time.**
+
+Trained exclusively on **real naturalistic fMRI data** (2.73M training timepoints, 289 GB, 4,480 sessions).
+Predicts activation across **56 canonical brain ROIs** (HCP MMP1.0 parcellation).
+
+---
+
+## Headline Result
+
+**Audio model (Whisper v4) beats TRIBE v2** — the Meta AI model that won the Algonauts 2025 competition — **by +4.2%** on a 23-subject cross-subject holdout:
+
+| Model | Held-out R | Notes |
+|-------|-----------|-------|
+| **NeuroText Whisper v4** | **0.257** | Single shared model, no per-subject fine-tuning |
+| TRIBE v2 (Meta AI) | 0.215 | Published; per-subject fine-tuned; video+audio+text |
+
+All 7 brain networks beat TRIBE v2. Biggest leads: Frontal (+0.209), Default Mode (+0.221), Subcortical (+0.234).
+
+---
+
+## Models
+
+| File | Input | Val R | Holdout R | Notes |
+|------|-------|-------|-----------|-------|
+| `text2roi_whisper_v4.pt` | Audio (Whisper-large-v3, 1280d) | **0.217** | **0.257** | **Recommended for audio. Beats TRIBE v2 (+4.2%)** |
+| `text2roi_combined_v4.pt` | Text+Audio (3840d, modality dropout) | 0.192 | — | Text or combined inference; recommended for text |
+| `text2roi_qwen3_v8.pt` | Text (Qwen3-Embedding-4B, 2560d) | 0.115 | — | Text-only; cross-dataset generalization improving |
+
+*Val R = mean Pearson R across 56 ROIs on held-out subjects (honest — see below).*
+*Holdout R = independent eval on 23 never-seen subjects.*
+
+> **Note on previous models (v2/v3):** Models in this repo before July 2026 reported inflated val_R values (0.239–0.413) due to within-subject train/val splits. Those numbers are not comparable to v4. The v4 models use honest per-subject z-scoring and per-subject holdout splits.
+
+---
+
+## Why These Numbers Are Honest
+
+Previous NeuroText versions had inflated val_R from a **within-subject split**: the model saw the same subjects in both train and val, and learned subject-level baseline BOLD activations. Cross-subject, that memorized baseline is useless.
+
+v4 fixes both issues:
+
+1. **Per-subject z-scoring** — each subject's ROI activations are z-scored independently before training, so the model learns stimulus-driven fluctuations rather than who each subject is.
+2. **Per-subject holdout split** — 15% of subjects per dataset are excluded from training entirely. Zero subject overlap guaranteed.
+3. **Single shared model** — no per-subject adaptation at inference. TRIBE requires fine-tuning on each test subject; Amphora does not.
+
+---
+
+## Category Selectivity (10/10 verified)
+
+Verified that predicted top-5 ROIs match known functional anatomy:
+
+| Category | Predicted top regions | Correct? |
+|----------|----------------------|----------|
+| Face | FFA-1, FFA-2, OFA | ✅ |
+| Scene | RSC, PPA, LO1 | ✅ |
+| Language | STG, MTG, IFG | ✅ |
+| Fear | Amygdala_L, Amygdala_R, AI | ✅ |
+| Memory | HPC_L, HPC_R, PCC | ✅ |
+| Pain | AI, dACC, STS | ✅ |
+| Working Memory | IPS1, IPS2, dlPFC | ✅ |
+| Social | STG, STS, HPC_L | ✅ |
+| Reward | Caudate_L, Caudate_R, Amygdala_L | ✅ |
+| Attention | IPS1, IPS2, FP1 | ✅ |
+
+---
+
+## Audio Model — Top ROIs (held-out eval)
+
+| ROI | R | vs TRIBE |
+|-----|---|---------|
+| ACC | 0.438 | +0.368 |
+| STG | 0.422 | +0.302 |
+| Thalamus | 0.408 | +0.358 |
+| V1 | 0.393 | +0.073 |
+| LP_R | 0.380 | +0.290 |
+| mPFC_dmn | 0.379 | +0.299 |
+| AI | 0.343 | +0.253 |
+| HPC_L | 0.337 | +0.247 |
+| V2 | 0.336 | +0.036 |
+| dACC | 0.330 | +0.250 |
+
+53/56 ROIs R>0.10 · 41/56 R>0.20 · 20/56 R>0.30
+
+---
+
+## Quick Start
+
+```python
+from huggingface_hub import hf_hub_download
+from predict import predict_audio, predict_text, top_rois
+
+REPO = "ffh92r32rm0/Amphora_NeuroText"
+
+# Audio → brain regions (recommended)
+ckpt = hf_hub_download(REPO, "text2roi_whisper_v4.pt")
+roi_map = predict_audio("clip.wav", ckpt)
+print(top_rois(roi_map, n=5))
+# → [('ACC', 0.44), ('STG', 0.42), ('Thalamus', 0.41), ...]
+
+# Text → brain regions
+ckpt = hf_hub_download(REPO, "text2roi_combined_v4.pt")
+roi_map = predict_text("I am terrified of the dark", ckpt)
+print(top_rois(roi_map, n=5))
+# → [('Amygdala_L', 0.xx), ('AI', 0.xx), ('dACC', 0.xx), ...]
+```
+
+### CLI
+
+```bash
+# Audio
+python predict.py audio clip.wav --model text2roi_whisper_v4.pt --top 10
+
+# Text
+python predict.py text "watching a spider crawl toward me" --model text2roi_combined_v4.pt
+
+# Text + Audio
+python predict.py combined "narration text" clip.wav
+```
+
+---
+
+## Training Details
+
+- **Corpus:** 2.73M TRs · 289 GB · 4,480 sessions (CNeuroMod Friends, Narratives, LPP, HCP, language fMRI, Cowen-Keltner)
+- **Brain space:** fsaverage5 + subcortical, 28,444 vertices → 56 ROI parcellation (HCP MMP1.0)
+- **Architecture:** Linear(in_dim→1024) → GELU → Dropout → LayerNorm → Linear(1024→512) → GELU → Dropout → Linear(512→56)
+- **Loss:** Pearson R (+ anchor ranking for qwen3 model)
+- **Epochs:** 120 per model
+- **Eval metric:** Mean Pearson R across 56 ROIs, identical to Algonauts 2025
+
+---
+
+## Requirements
+
+```
+torch>=2.0
+transformers>=4.40
+huggingface_hub>=0.23
+numpy>=1.24
+librosa>=0.10   # for audio loading
+```
+
+---
+
+## Citation / Contact
+
+Built by Amphora. Contact: hamiltonfrancesco5@gmail.com
+
+If you use this in research, please cite the HuggingFace repo URL.

app.py

@@ -0,0 +1,458 @@
+"""
+Amphora NeuroText — Gradio Space Demo
+
+Predicts brain region activation from text using the text2roi_combined_v4.pt model.
+Pre-cached Qwen3 embeddings for 51 example stimuli let this run on CPU instantly.
+Custom text inference requires the full Qwen3-Embedding-4B model (GPU recommended).
+
+Model: text2roi_combined_v4.pt  (val R=0.192, honest cross-subject holdout)
+Audio model: text2roi_whisper_v4.pt beats TRIBE v2 by +4.2% (R=0.257, 23 held-out subjects)
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, List
+
+import gradio as gr
+import numpy as np
+import plotly.graph_objects as go
+import torch
+import torch.nn as nn
+
+# ── ROI schema ─────────────────────────────────────────────────────────────────
+ROI_NAMES: List[str] = [
+    "V1","V2","V3","V4","V3A","V3B","LO1","LO2",
+    "MT","MST","V7","IPS1","FFA-1","FFA-2","PPA","RSC",
+    "OFA","EBA","IPS2","IPS3","IPS4","IPS5","SPL1",
+    "hIP1","hIP2","hIP3","dlPFC","vlPFC","OFC","ACC",
+    "mPFC","FP1","FP2","IFG","IFGorb","STG","STS",
+    "MTG","AG","PCC","mPFC_dmn","LP_L","LP_R",
+    "HPC_L","HPC_R","AI","dACC","sgACC","vmPFC",
+    "Amygdala_L","Amygdala_R","Caudate_L","Caudate_R",
+    "Putamen_L","Putamen_R","Thalamus",
+]
+
+NETWORK_COLORS = {
+    "Visual":       ("#4B8BBE", ["V1","V2","V3","V4","V3A","V3B","LO1","LO2","MT","MST","V7","IPS1","FFA-1","FFA-2","PPA","RSC","OFA","EBA"]),
+    "Parietal":     ("#6AB187", ["IPS2","IPS3","IPS4","IPS5","SPL1","hIP1","hIP2","hIP3"]),
+    "Frontal":      ("#E07B39", ["dlPFC","vlPFC","OFC","ACC","mPFC","FP1","FP2"]),
+    "Language":     ("#9B59B6", ["IFG","IFGorb","STG","STS","MTG","AG"]),
+    "Default Mode": ("#E74C3C", ["PCC","mPFC_dmn","LP_L","LP_R","HPC_L","HPC_R"]),
+    "Salience":     ("#F39C12", ["AI","dACC","sgACC","vmPFC","Amygdala_L","Amygdala_R"]),
+    "Subcortical":  ("#95A5A6", ["Caudate_L","Caudate_R","Putamen_L","Putamen_R","Thalamus"]),
+}
+
+ROI_TO_NET: Dict[str, str] = {}
+ROI_TO_COLOR: Dict[str, str] = {}
+for net, (col, rois) in NETWORK_COLORS.items():
+    for r in rois:
+        ROI_TO_NET[r] = net
+        ROI_TO_COLOR[r] = col
+
+# ── 51 example stimuli organized by category ───────────────────────────────────
+EXAMPLES = {
+    "Face":     [
+        "the photograph showed a person raising an eyebrow in surprise",
+        "she memorized the distinctive features of every face she met",
+        "the newborn could already distinguish its mother's face from a stranger's",
+        "an upside-down portrait makes it harder to recognize the person's identity",
+        "identical twins are notoriously difficult to tell apart by facial features alone",
+    ],
+    "Scene":    [
+        "navigating the winding streets of an unfamiliar city neighbourhood",
+        "the cabin sat in a dense forest clearing surrounded by tall pines",
+        "she recognised the museum lobby from a single glimpse of its architecture",
+        "the aerial view revealed a patchwork of farmland stretching to the horizon",
+        "every corner of the childhood home was etched into their spatial memory",
+    ],
+    "Object":   [
+        "identifying the make and model of a vintage car from across the street",
+        "the toolbox contained wrenches, pliers, and screwdrivers of every size",
+        "grasping the difference between a cup and a bowl is trivial for humans",
+        "the robotic arm picked up each item and sorted it into the correct bin",
+    ],
+    "Motor":    [
+        "the gymnast twisted her body into an impossible-looking backflip",
+        "tying a shoelace is a motor skill that becomes automatic with practice",
+        "the surgeon's hands moved with practised precision during the procedure",
+        "drumming requires independent coordination of all four limbs simultaneously",
+    ],
+    "Language": [
+        "the professor paused mid-sentence to choose a more precise word",
+        "translating idioms between languages often loses the original meaning",
+        "parsing a garden-path sentence requires revising your initial interpretation",
+        "the radio announcer's voice was immediately recognisable to regular listeners",
+        "metaphors allow us to understand abstract ideas through concrete comparisons",
+    ],
+    "Auditory": [
+        "a sudden loud bang echoed through the empty corridor",
+        "the melody of the piano piece lingered long after the concert ended",
+        "distinguishing two similar vowel sounds is harder in a second language",
+    ],
+    "Math":     [
+        "estimating how many bricks it would take to fill the room",
+        "the pattern of prime numbers has fascinated mathematicians for centuries",
+        "keeping a running total while counting backwards from a hundred",
+    ],
+    "Attention":[
+        "spotting the single red dot among hundreds of blue ones in a crowded display",
+        "ignoring the conversation at the next table while trying to concentrate",
+    ],
+    "WM":       [
+        "holding seven random digits in mind while answering an unrelated question",
+        "remembering the exact words of a sentence heard thirty seconds ago",
+    ],
+    "Fear":     [
+        "hearing an unexpected rustling sound in a dark forest at midnight",
+        "the suspense built as the footsteps grew louder outside the locked door",
+        "spotting a venomous spider sitting motionless on your pillow",
+    ],
+    "Disgust":  [
+        "the smell of rotting food was overwhelming as the bin had not been emptied for weeks",
+        "the sight of the infected wound made his stomach turn",
+    ],
+    "Reward":   [
+        "the unexpected bonus triggered an immediate sense of pleasure and relief",
+        "biting into a perfectly ripe piece of fruit on a hot summer day",
+        "the slot machine paid out a jackpot after hours of near-misses",
+    ],
+    "Social":   [
+        "guessing what your friend is about to say before they finish the sentence",
+        "recognising that someone is being sarcastic without explicit signals",
+        "imagining how a stranger might feel after receiving devastating news",
+    ],
+    "Memory":   [
+        "replaying the exact sequence of events from a memorable birthday party",
+        "the smell of cinnamon instantly transported her back to her grandmother's kitchen",
+        "mentally walking through every room of a childhood home",
+        "trying to recall whether you locked the door before leaving the house",
+    ],
+    "Pain":     [
+        "the throbbing headache made it impossible to focus on anything",
+        "holding your breath underwater until your lungs burn",
+        "the dentist's drill hitting a sensitive nerve sends a sharp jolt of pain",
+    ],
+}
+
+ALL_EXAMPLES_FLAT = [s for sentences in EXAMPLES.values() for s in sentences]
+SENTENCE_TO_CAT   = {s: cat for cat, sentences in EXAMPLES.items() for s in sentences}
+
+# ── Model ──────────────────────────────────────────────────────────────────────
+class Text2ROI(nn.Module):
+    def __init__(self, in_dim=3840, hidden=1024, out_dim=56, dropout=0.1):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, hidden), nn.GELU(), nn.Dropout(dropout), nn.LayerNorm(hidden),
+            nn.Linear(hidden, hidden // 2), nn.GELU(), nn.Dropout(dropout),
+            nn.Linear(hidden // 2, out_dim),
+        )
+    def forward(self, x): return self.net(x)
+
+
+_model = None
+_roi_names = None
+_examples_cache: Dict[str, np.ndarray] = {}  # sentence -> (56,) roi scores
+
+def _load_model():
+    global _model, _roi_names
+    if _model is not None:
+        return
+    # 1. bundled alongside this script (self-contained zip)
+    _HERE = Path(__file__).parent
+    ckpt_path = _HERE / "text2roi_combined_v4.pt"
+    # 2. CWD fallback
+    if not ckpt_path.exists():
+        ckpt_path = Path("text2roi_combined_v4.pt")
+    # 3. HuggingFace (online fallback for HF Spaces / Colab)
+    if not ckpt_path.exists():
+        try:
+            from huggingface_hub import hf_hub_download
+            ckpt_path = Path(hf_hub_download("ffh92r32rm0/Amphora_NeuroText", "text2roi_combined_v4.pt"))
+        except Exception as e:
+            raise FileNotFoundError(
+                "text2roi_combined_v4.pt not found locally or on HuggingFace. "
+                "Make sure the .pt file is in the same folder as app.py."
+            ) from e
+    ckpt = torch.load(str(ckpt_path), map_location="cpu", weights_only=False)
+    _roi_names = [s.decode() if isinstance(s, bytes) else str(s)
+                  for s in ckpt.get("roi_names", ROI_NAMES)]
+    _model = Text2ROI(in_dim=ckpt["in_dim"], out_dim=ckpt["n_roi"])
+    _model.load_state_dict(ckpt["state_dict"])
+    _model.eval()
+
+
+def _load_examples():
+    """Load pre-cached embeddings (NPZ with sentence index → qwen3 2560d vectors)."""
+    _HERE = Path(__file__).parent
+    # try bundled location first, then CWD
+    cache = _HERE / "examples_cache.npz"
+    if not cache.exists():
+        cache = Path("examples_cache.npz")
+    if not cache.exists():
+        return False
+    data = np.load(str(cache), allow_pickle=True)
+    sentences = [s.decode() if isinstance(s, bytes) else str(s) for s in data["sentences"]]
+    embs = data["embeddings"].astype(np.float32)  # (N, 2560)
+    for s, e in zip(sentences, embs):
+        _examples_cache[s] = e
+    return True
+
+
+def _run_inference(qwen3_emb: np.ndarray) -> Dict[str, float]:
+    """Run combined projector on a (2560,) Qwen3 embedding in text-only mode."""
+    _load_model()
+    # Text-only mode: prepend zeros for the whisper portion (model trained with modality dropout)
+    zeros = np.zeros((1, 1280), dtype=np.float32)
+    inp = np.concatenate([zeros, qwen3_emb.reshape(1, -1)], axis=1)  # (1, 3840)
+    with torch.no_grad():
+        pred = _model(torch.from_numpy(inp)).cpu().numpy()[0]
+    return dict(zip(_roi_names or ROI_NAMES, pred.tolist()))
+
+
+def _embed_qwen3_live(text: str) -> np.ndarray:
+    """Embed text with Qwen3-Embedding-4B (GPU strongly recommended)."""
+    import torch.nn.functional as F
+    from transformers import AutoModel, AutoTokenizer
+    tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-Embedding-4B", padding_side="left")
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    dtype  = torch.bfloat16 if device != "cpu" else torch.float32
+    mdl    = AutoModel.from_pretrained("Qwen/Qwen3-Embedding-4B",
+                                        torch_dtype=dtype).to(device).eval()
+    with torch.no_grad():
+        enc = tok([text], return_tensors="pt", padding=True,
+                   truncation=True, max_length=512).to(device)
+        h = mdl(**enc).last_hidden_state[:, -1].float()
+        emb = F.normalize(h, p=2, dim=1).cpu().numpy()[0]
+    del mdl; torch.cuda.empty_cache()
+    return emb.astype(np.float32)
+
+
+# ── Plotly chart ───────────────────────────────────────────────────────────────
+def _make_brain_chart(roi_map: Dict[str, float], title: str, category: str) -> go.Figure:
+    names  = list(roi_map.keys())
+    scores = list(roi_map.values())
+    colors = [ROI_TO_COLOR.get(n, "#95A5A6") for n in names]
+    nets   = [ROI_TO_NET.get(n, "Other") for n in names]
+
+    order  = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)
+    names  = [names[i]  for i in order]
+    scores = [scores[i] for i in order]
+    colors = [colors[i] for i in order]
+    nets   = [nets[i]   for i in order]
+
+    top15_names  = names[:15]
+    top15_scores = scores[:15]
+    top15_colors = colors[:15]
+    top15_nets   = nets[:15]
+
+    fig = go.Figure()
+
+    fig.add_trace(go.Bar(
+        x=top15_scores,
+        y=top15_names,
+        orientation="h",
+        marker=dict(color=top15_colors, opacity=0.85,
+                    line=dict(color="rgba(255,255,255,0.3)", width=0.5)),
+        customdata=top15_nets,
+        hovertemplate="<b>%{y}</b><br>Activation: %{x:.3f}<br>Network: %{customdata}<extra></extra>",
+        showlegend=False,
+    ))
+
+    fig.add_vline(x=0, line_color="rgba(150,150,150,0.5)", line_width=1)
+
+    for net, (col, _) in NETWORK_COLORS.items():
+        fig.add_trace(go.Bar(
+            x=[None], y=[None],
+            marker=dict(color=col),
+            name=net,
+            showlegend=True,
+        ))
+
+    fig.update_layout(
+        title=dict(
+            text=f"<b>Predicted brain activation</b><br><sub>{title[:80]}</sub>",
+            font=dict(size=14),
+        ),
+        xaxis_title="Predicted activation (z-score)",
+        yaxis=dict(autorange="reversed", tickfont=dict(size=11)),
+        plot_bgcolor="rgba(20,20,30,0.95)",
+        paper_bgcolor="rgba(20,20,30,0.0)",
+        font=dict(color="#e0e0e0"),
+        margin=dict(l=10, r=10, t=70, b=40),
+        height=480,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=-0.35,
+            xanchor="center",
+            x=0.5,
+            font=dict(size=10),
+        ),
+        bargap=0.18,
+    )
+    return fig
+
+
+def _network_summary(roi_map: Dict[str, float]) -> str:
+    net_scores: Dict[str, list] = {n: [] for n in NETWORK_COLORS}
+    for roi, score in roi_map.items():
+        net = ROI_TO_NET.get(roi)
+        if net:
+            net_scores[net].append(score)
+    rows = []
+    for net, scores in net_scores.items():
+        if scores:
+            mean = np.mean(scores)
+            rows.append((net, mean))
+    rows.sort(key=lambda x: -x[1])
+    lines = [f"**Most activated network: {rows[0][0]}**\n"]
+    for net, mean in rows:
+        bar = "█" * max(0, int((mean + 0.5) * 12))
+        lines.append(f"`{net:<14}` {mean:+.3f}  {bar}")
+    return "\n".join(lines)
+
+
+# ── Gradio callbacks ───────────────────────────────────────────────────────────
+_cache_loaded = _load_examples()
+
+def predict_from_example(sentence: str):
+    if not sentence:
+        return None, "", ""
+    cat = SENTENCE_TO_CAT.get(sentence, "Unknown")
+    if sentence in _examples_cache:
+        qwen3_emb = _examples_cache[sentence]
+        roi_map   = _run_inference(qwen3_emb)
+        source    = "Pre-cached embedding (instant)"
+    else:
+        return None, "❌ Embedding not cached. Use Custom Text tab.", ""
+    fig     = _make_brain_chart(roi_map, sentence, cat)
+    summary = _network_summary(roi_map)
+    top5    = "\n".join(f"**{i+1}. {r}** ({s:+.3f})"
+                        for i, (r, s) in enumerate(
+                            sorted(roi_map.items(), key=lambda x: -x[1])[:5]))
+    return fig, f"**Category:** {cat}   |   {source}\n\n**Top 5 ROIs:**\n{top5}", summary
+
+
+def predict_from_custom(text: str):
+    if not text or len(text.strip()) < 5:
+        return None, "Please enter at least 5 characters.", ""
+    try:
+        qwen3_emb = _embed_qwen3_live(text.strip())
+        roi_map   = _run_inference(qwen3_emb)
+        fig       = _make_brain_chart(roi_map, text.strip(), "Custom")
+        summary   = _network_summary(roi_map)
+        top5      = "\n".join(f"**{i+1}. {r}** ({s:+.3f})"
+                              for i, (r, s) in enumerate(
+                                  sorted(roi_map.items(), key=lambda x: -x[1])[:5]))
+        return fig, f"**Top 5 ROIs:**\n{top5}", summary
+    except Exception as e:
+        return None, f"❌ Error: {e}\n\nNote: Custom text requires Qwen3-Embedding-4B (GPU recommended).", ""
+
+
+# ── UI ─────────────────────────────────────────────────────────────────────────
+CSS = """
+#title { text-align: center; }
+#subtitle { text-align: center; color: #aaa; margin-top: -10px; }
+.category-btn { font-size: 12px !important; }
+"""
+
+DESCRIPTION = """
+**Amphora NeuroText** predicts which brain regions activate in response to any text stimulus —
+trained on **real fMRI data** from 1,600+ subjects across naturalistic experiments.
+No brain scanner needed at inference time.
+
+**Audio model beats TRIBE v2** (Meta AI, Algonauts 2025 winner) by **+4.2%** (R=0.257 vs 0.215).
+10/10 cognitive category circuits correctly localized.
+"""
+
+def build_interface():
+    with gr.Blocks(css=CSS, title="Amphora NeuroText") as demo:
+        gr.Markdown("# Amphora NeuroText", elem_id="title")
+        gr.Markdown("### Text → Brain Region Activation", elem_id="subtitle")
+        gr.Markdown(DESCRIPTION)
+
+        with gr.Tabs():
+            with gr.TabItem("Examples (instant, CPU)"):
+                gr.Markdown("Select a cognitive category and example sentence:")
+
+                with gr.Row():
+                    cat_dd = gr.Dropdown(
+                        label="Category",
+                        choices=list(EXAMPLES.keys()),
+                        value="Fear",
+                        scale=1,
+                    )
+                    sent_dd = gr.Dropdown(
+                        label="Example sentence",
+                        choices=EXAMPLES["Fear"],
+                        value=EXAMPLES["Fear"][2],
+                        scale=3,
+                    )
+
+                predict_btn = gr.Button("Predict brain activation", variant="primary")
+
+                with gr.Row():
+                    brain_plot  = gr.Plot(label="Brain ROI Activations (top 15)")
+
+                with gr.Row():
+                    result_md   = gr.Markdown()
+                    network_md  = gr.Markdown()
+
+                cat_dd.change(
+                    fn=lambda cat: gr.Dropdown(choices=EXAMPLES[cat], value=EXAMPLES[cat][0]),
+                    inputs=cat_dd,
+                    outputs=sent_dd,
+                )
+                predict_btn.click(
+                    fn=predict_from_example,
+                    inputs=sent_dd,
+                    outputs=[brain_plot, result_md, network_md],
+                )
+                sent_dd.change(
+                    fn=predict_from_example,
+                    inputs=sent_dd,
+                    outputs=[brain_plot, result_md, network_md],
+                )
+
+            with gr.TabItem("Custom Text (GPU recommended)"):
+                gr.Markdown("""
+Enter any text and see which brain regions the model predicts will activate.
+
+> **Note:** Custom text requires loading Qwen3-Embedding-4B (~8GB). This works on a GPU Space
+> but will be very slow on CPU. If you're running locally, install:
+> `pip install torch transformers`
+""")
+                custom_text = gr.Textbox(
+                    label="Your text stimulus",
+                    placeholder='e.g. "hearing a jazz piano solo" or "solving a geometry puzzle"',
+                    lines=3,
+                )
+                custom_btn = gr.Button("Predict", variant="primary")
+
+                with gr.Row():
+                    custom_plot = gr.Plot(label="Brain ROI Activations")
+
+                with gr.Row():
+                    custom_result  = gr.Markdown()
+                    custom_network = gr.Markdown()
+
+                custom_btn.click(
+                    fn=predict_from_custom,
+                    inputs=custom_text,
+                    outputs=[custom_plot, custom_result, custom_network],
+                )
+
+        gr.Markdown("""
+---
+**Model:** [Amphora_NeuroText](https://huggingface.co/ffh92r32rm0/Amphora_NeuroText)  ·
+**Training data:** Narratives, Little Prince, HCP-task, AOMIC, CNeuroMod, Clinical fMRI  ·
+**License:** MIT  ·  **Contact:** hamiltonfrancesco5@gmail.com
+""")
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = build_interface()
+    demo.launch()

config.json

@@ -0,0 +1,80 @@
+{
+  "_note": "val_R values are honest cross-subject holdouts: per-subject z-scoring applied, 15% of subjects per dataset held out before training, zero subject overlap with training data.",
+  "models": {
+    "text2roi_whisper_v4": {
+      "file": "text2roi_whisper_v4.pt",
+      "description": "Audio → 56-ROI MLP projector. Input: Whisper-large-v3 encoder states (1280d), per-TR. Honest cross-subject holdout val_R=0.217; actual held-out eval on 23 subjects = R=0.257 (+4.2% vs TRIBE v2, Meta AI Algonauts 2025 winner). Single shared model, no per-subject fine-tuning.",
+      "architecture": "Linear(1280→1024) → GELU → Dropout → LayerNorm → Linear(1024→512) → GELU → Dropout → Linear(512→56)",
+      "in_dim": 1280,
+      "hidden_dim": 1024,
+      "out_dim": 56,
+      "embedding_model": "openai/whisper-large-v3",
+      "best_val_mean_pearson_r": 0.217,
+      "holdout_mean_pearson_r": 0.257,
+      "holdout_n_subjects": 23,
+      "holdout_n_trs": 33038,
+      "vs_tribe_v2_delta": 0.042,
+      "r_above_010": "53/56",
+      "r_above_020": "41/56",
+      "r_above_030": "20/56",
+      "top_rois": {
+        "ACC": 0.438, "STG": 0.422, "Thalamus": 0.408, "V1": 0.393, "LP_R": 0.380
+      },
+      "epochs": 120,
+      "loss": "pearson_r",
+      "training_data": "real fMRI (CNeuroMod Friends, narratives, LPP, HCP, language fMRI), fsaverage5+subcortical 28,444-voxel space, 2.73M TRs total",
+      "eval_honesty": "per-subject z-scoring + per-subject train/val split (15% subjects withheld per dataset, zero overlap)",
+      "roi_schema": "UNIVERSAL_ROI_NAMES_56",
+      "recommended_for": "audio stimuli — speech, music, naturalistic audio"
+    },
+    "text2roi_combined_v4": {
+      "file": "text2roi_combined_v4.pt",
+      "description": "Text+Audio → 56-ROI MLP projector. Input: concatenated whisper (1280d) | qwen3 (2560d) = 3840d total. For text-only inference, zero-pad the whisper slot. Trained with modality dropout (0.3) so text-only, audio-only, and combined all work at inference. Honest cross-subject val_R=0.192.",
+      "architecture": "Linear(3840→1024) → GELU → Dropout → LayerNorm → Linear(1024→512) → GELU → Dropout → Linear(512→56)",
+      "in_dim": 3840,
+      "hidden_dim": 1024,
+      "out_dim": 56,
+      "embedding_model": "Qwen/Qwen3-Embedding-4B",
+      "whisper_model": "openai/whisper-large-v3",
+      "best_val_mean_pearson_r": 0.192,
+      "modality_dropout": 0.3,
+      "epochs": 120,
+      "loss": "pearson_r",
+      "training_data": "real fMRI, 422k train TRs, 65k val TRs (files with both whisper+qwen3 features)",
+      "eval_honesty": "per-subject z-scoring + per-subject train/val split",
+      "roi_schema": "UNIVERSAL_ROI_NAMES_56",
+      "recommended_for": "text inputs (zero-pad whisper slot) or combined text+audio"
+    },
+    "text2roi_qwen3_v8": {
+      "file": "text2roi_qwen3_v8.pt",
+      "description": "Text → 56-ROI MLP projector. Input: Qwen3-Embedding-4B (2560d). Honest cross-subject val_R=0.115. Cross-dataset text generalization is an active area of improvement — use text2roi_combined_v4 for best text results.",
+      "architecture": "Linear(2560→1024) → GELU → Dropout → LayerNorm → Linear(1024→512) → GELU → Dropout → Linear(512→56)",
+      "in_dim": 2560,
+      "hidden_dim": 1024,
+      "out_dim": 56,
+      "embedding_model": "Qwen/Qwen3-Embedding-4B",
+      "best_val_mean_pearson_r": 0.115,
+      "epochs": 120,
+      "loss": "pearson_r + anchor_ranking",
+      "anchor_loss_weight": 1.0,
+      "training_data": "real fMRI (narratives, CNeuroMod, LPP, HCP, language fMRI, Cowen-Keltner), 704k train TRs",
+      "eval_honesty": "per-subject z-scoring + per-subject train/val split",
+      "roi_schema": "UNIVERSAL_ROI_NAMES_56",
+      "recommended_for": "text-only inference (experimental; combined_v4 preferred)"
+    }
+  },
+  "roi_schema": {
+    "name": "UNIVERSAL_ROI_NAMES_56",
+    "n_rois": 56,
+    "atlas": "HCP MMP1.0",
+    "space": "fsaverage5 + subcortical",
+    "rois": [
+      "V1","V2","V3","V4","V3A","V3B","LO1","LO2","MT","MST","V7","IPS1",
+      "FFA-1","FFA-2","PPA","RSC","OFA","EBA","IPS2","IPS3","IPS4","IPS5","SPL1",
+      "hIP1","hIP2","hIP3","dlPFC","vlPFC","OFC","ACC","mPFC","FP1","FP2",
+      "IFG","IFGorb","STG","STS","MTG","AG","PCC","mPFC_dmn","LP_L","LP_R",
+      "HPC_L","HPC_R","AI","dACC","sgACC","vmPFC",
+      "Amygdala_L","Amygdala_R","Caudate_L","Caudate_R","Putamen_L","Putamen_R","Thalamus"
+    ]
+  }
+}

predict.py

@@ -0,0 +1,306 @@
+"""
+predict.py — Amphora NeuroText inference
+
+Models (honest cross-subject holdout val_R — no data leakage)
+------
+text2roi_whisper_v4.pt    Audio → 56 ROIs  (Whisper-large-v3, 1280d, val R=0.217, holdout R=0.257)
+text2roi_combined_v4.pt   Text+Audio → 56 ROIs (whisper|qwen3, 3840d, val R=0.192)
+text2roi_qwen3_v8.pt      Text → 56 ROIs  (Qwen3-Embedding-4B, 2560d, val R=0.115)
+
+All v4 models use per-subject z-scoring and a per-subject train/val split.
+Previous models (v2/v3) had inflated val_R from within-subject splits — do not compare directly.
+
+Whisper v4 beats TRIBE v2 (Meta AI, Algonauts 2025 winner) by +4.2% on a 23-subject holdout.
+Single shared model — no per-subject fine-tuning required.
+
+Quick start
+-----------
+    from predict import predict_text, predict_audio, top_rois
+
+    # Audio → brain regions (recommended — strongest model)
+    roi_map = predict_audio("clip.wav")
+    print(top_rois(roi_map, n=5))
+    # → [('ACC', 0.44), ('STG', 0.42), ('Thalamus', 0.41), ...]
+
+    # Text → brain regions
+    roi_map = predict_text("I am terrified of the dark")
+    print(top_rois(roi_map, n=5))
+    # → [('Amygdala_L', 0.xx), ('AI', 0.xx), ('dACC', 0.xx), ...]
+
+    # Text + Audio → brain regions
+    roi_map = predict_combined("narration text", "clip.wav")
+    print(top_rois(roi_map, n=5))
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+# ── Canonical 56-ROI schema ───────────────────────────────────────────────────
+ROI_NAMES_56: List[str] = [
+    "V1", "V2", "V3", "V4", "V3A", "V3B", "LO1", "LO2",
+    "MT", "MST", "V7", "IPS1", "FFA-1", "FFA-2", "PPA", "RSC",
+    "OFA", "EBA", "IPS2", "IPS3", "IPS4", "IPS5", "SPL1",
+    "hIP1", "hIP2", "hIP3", "dlPFC", "vlPFC", "OFC", "ACC",
+    "mPFC", "FP1", "FP2", "IFG", "IFGorb", "STG", "STS",
+    "MTG", "AG", "PCC", "mPFC_dmn", "LP_L", "LP_R",
+    "HPC_L", "HPC_R", "AI", "dACC", "sgACC", "vmPFC",
+    "Amygdala_L", "Amygdala_R", "Caudate_L", "Caudate_R",
+    "Putamen_L", "Putamen_R", "Thalamus",
+]
+
+DEFAULT_CHECKPOINT = "text2roi_whisper_v4.pt"
+
+# ── Shared MLP architecture ───────────────────────────────────────────────────
+class Text2ROI(nn.Module):
+    def __init__(self, in_dim: int = 1280, hidden: int = 1024,
+                 out_dim: int = 56, dropout: float = 0.1):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, hidden),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.LayerNorm(hidden),
+            nn.Linear(hidden, hidden // 2),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden // 2, out_dim),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.net(x)
+
+
+# ── Model loader ──────────────────────────────────────────────────────────────
+_model_cache: Dict[str, tuple] = {}
+
+
+def _load_model(checkpoint: str) -> tuple:
+    if checkpoint in _model_cache:
+        return _model_cache[checkpoint]
+
+    # 1. absolute or relative-to-CWD path
+    ckpt_path = Path(checkpoint)
+    # 2. same directory as this script (works when bundled in a zip/folder)
+    if not ckpt_path.exists():
+        ckpt_path = Path(__file__).parent / checkpoint
+    # 3. HuggingFace Hub (online fallback)
+    if not ckpt_path.exists():
+        try:
+            from huggingface_hub import hf_hub_download
+            ckpt_path = Path(hf_hub_download("ffh92r32rm0/Amphora_NeuroText", checkpoint))
+        except Exception as e:
+            raise FileNotFoundError(
+                f"Checkpoint '{checkpoint}' not found locally or on HuggingFace.\n"
+                f"Make sure the .pt file is in the same folder as predict.py.\n"
+                f"Original error: {e}"
+            )
+
+    state = torch.load(str(ckpt_path), map_location="cpu", weights_only=False)
+    in_dim = state.get("in_dim", 1280)
+    n_roi  = state.get("n_roi", 56)
+    model  = Text2ROI(in_dim=in_dim, out_dim=n_roi)
+    model.load_state_dict(state["state_dict"])
+    model.eval()
+    _model_cache[checkpoint] = (model, in_dim)
+    return model, in_dim
+
+
+# ── Qwen3 embedding ───────────────────────────────────────────────────────────
+_qwen3_model = None
+_qwen3_tokenizer = None
+
+
+def _embed_text_qwen3(text: str) -> np.ndarray:
+    global _qwen3_model, _qwen3_tokenizer
+    if _qwen3_model is None:
+        from transformers import AutoTokenizer, AutoModel
+        _qwen3_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-Embedding-4B")
+        _qwen3_model = AutoModel.from_pretrained("Qwen/Qwen3-Embedding-4B")
+        _qwen3_model.eval()
+    inputs = _qwen3_tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+    with torch.no_grad():
+        out = _qwen3_model(**inputs)
+    emb = out.last_hidden_state[:, 0, :].squeeze(0).cpu().numpy()
+    return emb.astype(np.float32)
+
+
+# ── Whisper embedding ─────────────────────────────────────────────────────────
+_whisper_model = None
+_whisper_processor = None
+
+
+def _embed_audio_whisper(audio_path: str) -> np.ndarray:
+    global _whisper_model, _whisper_processor
+    if _whisper_model is None:
+        from transformers import WhisperProcessor, WhisperModel
+        _whisper_processor = WhisperProcessor.from_pretrained("openai/whisper-large-v3")
+        _whisper_model = WhisperModel.from_pretrained("openai/whisper-large-v3")
+        _whisper_model.eval()
+    import librosa
+    audio, sr = librosa.load(audio_path, sr=16000, mono=True)
+    inputs = _whisper_processor(audio, sampling_rate=16000, return_tensors="pt")
+    with torch.no_grad():
+        enc = _whisper_model.encoder(inputs.input_features)
+    emb = enc.last_hidden_state.mean(dim=1).squeeze(0).cpu().numpy()
+    return emb.astype(np.float32)
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def predict_audio(
+    audio_path: str,
+    checkpoint: str = "text2roi_whisper_v4.pt",
+) -> Dict[str, float]:
+    """Predict 56 brain ROI activations from an audio file.
+
+    Args:
+        audio_path: Path to audio file (wav, mp3, flac, …).
+        checkpoint:  Model file. Default: text2roi_whisper_v4.pt (val R=0.217, holdout R=0.257).
+
+    Returns:
+        dict mapping ROI name → predicted activation (z-scored units).
+    """
+    model, in_dim = _load_model(checkpoint)
+    emb = _embed_audio_whisper(audio_path)
+    if emb.shape[0] != in_dim:
+        raise ValueError(f"Audio embedding dim {emb.shape[0]} != model in_dim {in_dim}")
+    feat = torch.from_numpy(emb).unsqueeze(0)
+    with torch.no_grad():
+        pred = model(feat).squeeze(0).numpy()
+    return {roi: float(pred[i]) for i, roi in enumerate(ROI_NAMES_56)}
+
+
+def predict_text(
+    text: str,
+    checkpoint: str = "text2roi_combined_v4.pt",
+) -> Dict[str, float]:
+    """Predict 56 brain ROI activations from a text string.
+
+    Uses text2roi_combined_v4.pt by default: qwen3 embedding zero-padded into
+    the whisper slot (positions 0:1280 = zeros, 1280:3840 = qwen3 2560d).
+    The combined model was trained with modality dropout so text-only works.
+
+    Args:
+        text:       Input text string.
+        checkpoint: Model file. Default: text2roi_combined_v4.pt (val R=0.192).
+
+    Returns:
+        dict mapping ROI name → predicted activation (z-scored units).
+    """
+    model, in_dim = _load_model(checkpoint)
+    emb = _embed_text_qwen3(text)
+
+    if in_dim == 3840:
+        # combined model: zero-pad whisper slot
+        feat_np = np.concatenate([np.zeros(1280, dtype=np.float32), emb])
+    elif in_dim == 2560:
+        feat_np = emb
+    else:
+        raise ValueError(f"Unexpected model in_dim {in_dim} for text inference")
+
+    feat = torch.from_numpy(feat_np).unsqueeze(0)
+    with torch.no_grad():
+        pred = model(feat).squeeze(0).numpy()
+    return {roi: float(pred[i]) for i, roi in enumerate(ROI_NAMES_56)}
+
+
+def predict_combined(
+    text: str,
+    audio_path: str,
+    checkpoint: str = "text2roi_combined_v4.pt",
+) -> Dict[str, float]:
+    """Predict 56 brain ROI activations from both text and audio.
+
+    Args:
+        text:        Text string.
+        audio_path:  Path to audio file.
+        checkpoint:  Must be the combined model (in_dim=3840).
+
+    Returns:
+        dict mapping ROI name → predicted activation (z-scored units).
+    """
+    model, in_dim = _load_model(checkpoint)
+    if in_dim != 3840:
+        raise ValueError("predict_combined requires the combined model (in_dim=3840).")
+    w_emb = _embed_audio_whisper(audio_path)
+    q_emb = _embed_text_qwen3(text)
+    feat_np = np.concatenate([w_emb, q_emb]).astype(np.float32)
+    feat = torch.from_numpy(feat_np).unsqueeze(0)
+    with torch.no_grad():
+        pred = model(feat).squeeze(0).numpy()
+    return {roi: float(pred[i]) for i, roi in enumerate(ROI_NAMES_56)}
+
+
+# ── Utilities ──────────────────────────────────────────────────────────────��──
+
+def top_rois(roi_map: Dict[str, float], n: int = 10) -> List[tuple]:
+    """Return top-n ROIs sorted by predicted activation."""
+    return sorted(roi_map.items(), key=lambda x: -x[1])[:n]
+
+
+def network_summary(roi_map: Dict[str, float]) -> Dict[str, float]:
+    """Return mean activation per brain network."""
+    NETWORKS = {
+        "Visual":      ["V1","V2","V3","V4","V3A","V3B","LO1","LO2","MT","MST","V7","IPS1","FFA-1","FFA-2","PPA","RSC","OFA","EBA"],
+        "Parietal":    ["IPS2","IPS3","IPS4","IPS5","SPL1","hIP1","hIP2","hIP3"],
+        "Frontal":     ["dlPFC","vlPFC","OFC","ACC","mPFC","FP1","FP2"],
+        "Language":    ["IFG","IFGorb","STG","STS","MTG","AG"],
+        "DefaultMode": ["PCC","mPFC_dmn","LP_L","LP_R","HPC_L","HPC_R"],
+        "Salience":    ["AI","dACC","sgACC","vmPFC","Amygdala_L","Amygdala_R"],
+        "Subcortical": ["Caudate_L","Caudate_R","Putamen_L","Putamen_R","Thalamus"],
+    }
+    return {
+        net: float(np.mean([roi_map[r] for r in rois if r in roi_map]))
+        for net, rois in NETWORKS.items()
+    }
+
+
+# ── CLI ───────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    import argparse, json
+
+    parser = argparse.ArgumentParser(description="Amphora NeuroText — brain ROI prediction")
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_audio = sub.add_parser("audio", help="Audio file → brain ROIs")
+    p_audio.add_argument("audio", help="Path to audio file")
+    p_audio.add_argument("--model", default="text2roi_whisper_v4.pt")
+    p_audio.add_argument("--top", type=int, default=10)
+
+    p_text = sub.add_parser("text", help="Text → brain ROIs")
+    p_text.add_argument("text", help="Input text string")
+    p_text.add_argument("--model", default="text2roi_combined_v4.pt")
+    p_text.add_argument("--top", type=int, default=10)
+
+    p_combo = sub.add_parser("combined", help="Text + Audio → brain ROIs")
+    p_combo.add_argument("text")
+    p_combo.add_argument("audio")
+    p_combo.add_argument("--model", default="text2roi_combined_v4.pt")
+    p_combo.add_argument("--top", type=int, default=10)
+
+    args = parser.parse_args()
+
+    if args.cmd == "audio":
+        result = predict_audio(args.audio, args.model)
+    elif args.cmd == "text":
+        result = predict_text(args.text, args.model)
+    elif args.cmd == "combined":
+        result = predict_combined(args.text, args.audio, args.model)
+    else:
+        parser.print_help()
+        sys.exit(0)
+
+    tops = top_rois(result, args.top)
+    nets = network_summary(result)
+    print(f"\nTop {args.top} ROIs:")
+    for roi, val in tops:
+        print(f"  {roi:<16} {val:+.4f}")
+    print("\nNetwork summary:")
+    for net, val in sorted(nets.items(), key=lambda x: -x[1]):
+        print(f"  {net:<16} {val:+.4f}")

requirements-colab.txt

@@ -0,0 +1,9 @@
+torch
+transformers>=4.40
+huggingface_hub>=0.23
+numpy
+librosa
+nilearn
+mne
+nibabel
+matplotlib

requirements.txt

@@ -0,0 +1,5 @@
+torch>=2.0
+transformers>=4.40
+huggingface_hub>=0.23
+numpy>=1.24
+librosa>=0.10

text2roi_colab_v4.ipynb

@@ -0,0 +1,353 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 5,
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.0"
+  },
+  "colab": {
+   "provenance": [],
+   "gpuType": "T4"
+  },
+  "accelerator": "GPU"
+ },
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Amphora NeuroText v4 — Audio & Text → Brain ROI Activation\n",
+    "\n",
+    "Predict which brain regions activate in response to any audio or text stimulus.\n",
+    "\n",
+    "Trained on **real naturalistic fMRI data** from 1,600+ subjects across 4,480 sessions. Zero-shot: no brain scan needed at inference.\n",
+    "\n",
+    "**Audio model (Whisper v4) beats TRIBE v2** (Meta AI, Algonauts 2025 winner) **by +4.2%**  \n",
+    "Holdout R = 0.257 vs TRIBE 0.215 · 23 held-out subjects · single shared model (no per-subject fine-tuning)\n",
+    "\n",
+    "**All v4 models use honest evaluation:** per-subject z-scoring + per-subject train/val split (no data leakage).\n",
+    "\n",
+    "**Runtime:** GPU recommended (T4 or better). The MLP projector runs on CPU instantly — only the encoder models (Whisper/Qwen3) need GPU.\n",
+    "\n",
+    "---\n",
+    "Model repo: [ffh92r32rm0/Amphora_NeuroText](https://huggingface.co/ffh92r32rm0/Amphora_NeuroText)"
+   ],
+   "id": "markdown-intro"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Install dependencies ──────────────────────────────────────────────────────\n",
+    "!pip install -q torch transformers huggingface_hub numpy matplotlib librosa\n",
+    "!pip install -q nilearn  # optional: brain surface visualization\n",
+    "print('Done.')"
+   ],
+   "id": "install"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Choose modality ───────────────────────────────────────────────────────────\n",
+    "# Set MODALITY to 'audio' or 'text'\n",
+    "MODALITY = 'audio'   # 'audio' = Whisper v4  (holdout R=0.257, beats TRIBE v2 by +4.2%)\n",
+    "                      # 'text'  = Combined v4 (val R=0.192, zero-padded whisper slot)\n",
+    "\n",
+    "MODEL_FILE = {'audio': 'text2roi_whisper_v4.pt', 'text': 'text2roi_combined_v4.pt'}[MODALITY]\n",
+    "IN_DIM     = {'audio': 1280,                     'text': 3840                     }[MODALITY]\n",
+    "\n",
+    "print(f'Modality : {MODALITY}')\n",
+    "print(f'Model    : {MODEL_FILE}  (in_dim={IN_DIM})')"
+   ],
+   "id": "choose-model"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Locate model files (local first, HuggingFace fallback) ───────────────────\n",
+    "#\n",
+    "# Priority order:\n",
+    "#   1. Files uploaded to this Colab session (e.g. from the self-contained zip)\n",
+    "#   2. HuggingFace Hub download (requires internet; ~7-17 MB per model)\n",
+    "#\n",
+    "# To use the bundled zip offline:\n",
+    "#   - Extract NeuroText_v4_Demo.zip\n",
+    "#   - Upload the .pt files and predict.py to Colab via the Files panel\n",
+    "#   - Re-run this cell — it will find them locally and skip the HF download\n",
+    "\n",
+    "import os, shutil\n",
+    "from pathlib import Path\n",
+    "\n",
+    "REPO = 'ffh92r32rm0/Amphora_NeuroText'\n",
+    "\n",
+    "def _resolve(filename, repo=REPO):\n",
+    "    \"\"\"Return local path to filename, downloading from HF if not found locally.\"\"\"\n",
+    "    local = Path(filename)\n",
+    "    if local.exists():\n",
+    "        print(f'  {filename}: found locally')\n",
+    "        return str(local)\n",
+    "    print(f'  {filename}: not found locally, downloading from HuggingFace...')\n",
+    "    from huggingface_hub import hf_hub_download\n",
+    "    path = hf_hub_download(repo, filename)\n",
+    "    print(f'  {filename}: downloaded to {path}')\n",
+    "    return path\n",
+    "\n",
+    "print('Resolving files...')\n",
+    "ckpt_path    = _resolve(MODEL_FILE)\n",
+    "predict_path = _resolve('predict.py')\n",
+    "examples_path = _resolve('examples_cache.npz') if Path('examples_cache.npz').exists() else None\n",
+    "\n",
+    "# make predict.py importable from CWD\n",
+    "if predict_path != 'predict.py':\n",
+    "    shutil.copy(predict_path, 'predict.py')\n",
+    "\n",
+    "print(f'\\nCheckpoint : {ckpt_path}')\n",
+    "print(f'predict.py : ready')\n",
+    "print(f'examples   : {\"found\" if examples_path else \"not available (cached examples will be skipped)\"}')\n",
+    "print('Ready.')"
+   ],
+   "id": "resolve-files"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Load model (tiny MLP, runs instantly on CPU) ──────────────────────────────\n",
+    "import torch, torch.nn as nn, numpy as np\n",
+    "\n",
+    "class Text2ROI(nn.Module):\n",
+    "    def __init__(self, in_dim=1280, hidden=1024, out_dim=56, dropout=0.1):\n",
+    "        super().__init__()\n",
+    "        self.net = nn.Sequential(\n",
+    "            nn.Linear(in_dim, hidden), nn.GELU(), nn.Dropout(dropout), nn.LayerNorm(hidden),\n",
+    "            nn.Linear(hidden, hidden//2), nn.GELU(), nn.Dropout(dropout),\n",
+    "            nn.Linear(hidden//2, out_dim),\n",
+    "        )\n",
+    "    def forward(self, x): return self.net(x)\n",
+    "\n",
+    "ckpt  = torch.load(ckpt_path, map_location='cpu', weights_only=False)\n",
+    "model = Text2ROI(in_dim=ckpt['in_dim'], out_dim=ckpt.get('n_roi', 56))\n",
+    "model.load_state_dict(ckpt['state_dict'])\n",
+    "model.eval()\n",
+    "\n",
+    "ROI_NAMES = [\n",
+    "    'V1','V2','V3','V4','V3A','V3B','LO1','LO2','MT','MST','V7','IPS1',\n",
+    "    'FFA-1','FFA-2','PPA','RSC','OFA','EBA','IPS2','IPS3','IPS4','IPS5','SPL1',\n",
+    "    'hIP1','hIP2','hIP3','dlPFC','vlPFC','OFC','ACC','mPFC','FP1','FP2',\n",
+    "    'IFG','IFGorb','STG','STS','MTG','AG','PCC','mPFC_dmn','LP_L','LP_R',\n",
+    "    'HPC_L','HPC_R','AI','dACC','sgACC','vmPFC',\n",
+    "    'Amygdala_L','Amygdala_R','Caudate_L','Caudate_R','Putamen_L','Putamen_R','Thalamus',\n",
+    "]\n",
+    "\n",
+    "val_r = ckpt.get('best_val_r', 'N/A')\n",
+    "print(f'Model loaded  in_dim={ckpt[\"in_dim\"]}  val_R={val_r}')\n",
+    "print(f'Parameters: {sum(p.numel() for p in model.parameters()):,}')"
+   ],
+   "id": "load-model"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Helper: run inference + plot ──────────────────────────────────────────────\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def predict_from_features(feat_1d, model, in_dim):\n",
+    "    \"\"\"Run model on a 1-D feature vector. For combined (3840d), zero-pads the whisper slot.\"\"\"\n",
+    "    if in_dim == 3840 and feat_1d.shape[0] == 2560:\n",
+    "        feat_1d = np.concatenate([np.zeros(1280, dtype=np.float32), feat_1d])\n",
+    "    with torch.no_grad():\n",
+    "        pred = model(torch.from_numpy(feat_1d[:in_dim]).unsqueeze(0)).squeeze(0).numpy()\n",
+    "    return dict(zip(ROI_NAMES, pred.tolist()))\n",
+    "\n",
+    "def plot_rois(roi_map, title='', top_n=20):\n",
+    "    items = sorted(roi_map.items(), key=lambda x: -x[1])[:top_n]\n",
+    "    names, vals = zip(*items)\n",
+    "    vmin, vmax = min(vals), max(vals)\n",
+    "    colors = plt.cm.RdYlGn([(v - vmin) / (vmax - vmin + 1e-9) for v in vals])\n",
+    "    fig, ax = plt.subplots(figsize=(9, 5))\n",
+    "    ax.barh(range(len(names)), vals, color=colors)\n",
+    "    ax.set_yticks(range(len(names))); ax.set_yticklabels(names, fontsize=9)\n",
+    "    ax.axvline(0, color='gray', linewidth=0.7)\n",
+    "    ax.set_xlabel('Predicted activation (z-score)')\n",
+    "    ax.set_title(title[:90], fontsize=10)\n",
+    "    ax.invert_yaxis(); plt.tight_layout(); plt.show()\n",
+    "\n",
+    "print('Helpers ready.')"
+   ],
+   "id": "helpers"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "brain-plotter-lib",
+   "metadata": {},
+   "outputs": [],
+   "source": "# ── Brain map plotter (fsaverage5 / HCP-MMP1, same mesh as TRIBE v2) ─────────\n# Commercial-friendly: MNE + Nilearn only (BSD). Does NOT import tribev2.\n# Visualization follows the same fsaverage5 / HCP-MMP1 approach Meta uses\n# in TRIBE v2 plotting, implemented independently.\n\n!pip install -q mne nilearn Pillow\n\nfrom __future__ import annotations\nfrom functools import lru_cache\nfrom pathlib import Path\nfrom typing import Dict, List, Mapping, Sequence, Tuple\nimport numpy as np\n\nFSAVERAGE5_VERTS_PER_HEMI = 10242\nFSAVERAGE5_VERTICES        = FSAVERAGE5_VERTS_PER_HEMI * 2\n\nROI56_TO_HCP: Dict[str, List[Tuple[str, str]]] = {\n    \"V1\": [(\"V1\",\"both\")], \"V2\": [(\"V2\",\"both\")], \"V3\": [(\"V3\",\"both\")], \"V4\": [(\"V4\",\"both\")],\n    \"V3A\": [(\"V3A\",\"both\")], \"V3B\": [(\"V3B\",\"both\")], \"LO1\": [(\"LO1\",\"both\")], \"LO2\": [(\"LO2\",\"both\")],\n    \"MT\": [(\"MT\",\"both\")], \"MST\": [(\"MST\",\"both\")], \"V7\": [(\"V7\",\"both\")], \"IPS1\": [(\"IPS1\",\"both\")],\n    \"FFA-1\": [(\"FFC\",\"both\")], \"FFA-2\": [(\"FFC\",\"both\")], \"PPA\": [(\"PIT\",\"both\")],\n    \"RSC\": [(\"POS1\",\"both\"),(\"7m\",\"both\")], \"OFA\": [(\"FFC\",\"both\")], \"EBA\": [(\"FST\",\"both\")],\n    \"IPS2\": [(\"IPS2\",\"both\")], \"IPS3\": [(\"IPS3\",\"both\")], \"IPS4\": [(\"IPS4\",\"both\")], \"IPS5\": [(\"IPS5\",\"both\")],\n    \"SPL1\": [(\"SPL1\",\"both\")], \"hIP1\": [(\"7AL\",\"both\")], \"hIP2\": [(\"7PC\",\"both\")], \"hIP3\": [(\"7Am\",\"both\")],\n    \"dlPFC\": [(\"9-46d\",\"both\"),(\"46\",\"both\")], \"vlPFC\": [(\"47l\",\"both\")], \"OFC\": [(\"11l\",\"both\")],\n    \"ACC\": [(\"a24\",\"both\"),(\"p24\",\"both\")], \"mPFC\": [(\"9m\",\"both\")], \"FP1\": [(\"10d\",\"both\")], \"FP2\": [(\"10d\",\"both\")],\n    \"IFG\": [(\"44\",\"both\"),(\"45a\",\"both\")], \"IFGorb\": [(\"47l\",\"both\")],\n    \"STG\": [(\"STGa\",\"both\"),(\"STGr\",\"both\")], \"STS\": [(\"STSda\",\"both\")], \"MTG\": [(\"TE1a\",\"both\")],\n    \"AG\": [(\"PFm\",\"both\"),(\"PGs\",\"both\")], \"PCC\": [(\"PCC\",\"both\")],\n    \"mPFC_dmn\": [(\"9m\",\"both\"),(\"10r\",\"both\")],\n    \"LP_L\": [(\"PFm\",\"left\"),(\"PGs\",\"left\")], \"LP_R\": [(\"PFm\",\"right\"),(\"PGs\",\"right\")],\n    \"HPC_L\": [(\"Entorhinal\",\"left\")], \"HPC_R\": [(\"Entorhinal\",\"right\")],\n    \"AI\": [(\"Ig\",\"both\"),(\"FOP4\",\"both\")], \"dACC\": [(\"a24\",\"both\")],\n    \"sgACC\": [(\"s32\",\"both\")], \"vmPFC\": [(\"25\",\"both\")],\n    \"Amygdala_L\": [], \"Amygdala_R\": [], \"Caudate_L\": [], \"Caudate_R\": [],\n    \"Putamen_L\": [], \"Putamen_R\": [], \"Thalamus\": [],\n}\n\n@lru_cache(maxsize=1)\ndef _hcp_label_vertices(mesh: str = \"fsaverage5\") -> Dict[str, np.ndarray]:\n    import mne\n    if mesh != \"fsaverage5\":\n        raise ValueError(\"Only fsaverage5 is supported\")\n    max_v = FSAVERAGE5_VERTS_PER_HEMI\n    subjects_dir = Path(mne.datasets.sample.data_path()) / \"subjects\"\n    mne.datasets.fetch_hcp_mmp_parcellation(subjects_dir=subjects_dir, accept=True, verbose=False)\n    out: Dict[str, List[np.ndarray]] = {}\n    for hemi_code, offset in ((\"lh\", 0), (\"rh\", max_v)):\n        labels = mne.read_labels_from_annot(\n            \"fsaverage\", \"HCPMMP1\", hemi=hemi_code, subjects_dir=subjects_dir\n        )\n        for lab in labels:\n            name = lab.name[2:].replace(\"_ROI\",\"\").replace(\"-lh\",\"\").replace(\"-rh\",\"\")\n            verts = np.asarray(lab.vertices, dtype=np.int64)\n            verts = verts[verts < max_v] + offset\n            if verts.size:\n                out.setdefault(name, []).append(verts)\n    return {k: np.concatenate(v) for k, v in out.items()}\n\ndef get_hcp_roi_indices(rois, *, hemi=\"both\", mesh=\"fsaverage5\") -> np.ndarray:\n    labels = _hcp_label_vertices(mesh)\n    names = [rois] if isinstance(rois, str) else list(rois)\n    selected = []\n    for roi in names:\n        if roi.endswith(\"*\"):     selected.extend(k for k in labels if k.startswith(roi[:-1]))\n        elif roi.startswith(\"*\"): selected.extend(k for k in labels if k.endswith(roi[1:]))\n        elif roi in labels:       selected.append(roi)\n        else: raise ValueError(f\"ROI {roi!r} not found in HCP-MMP labels\")\n    idx_parts = []\n    for name in selected:\n        verts = labels[name]\n        if hemi == \"left\":    idx_parts.append(verts[verts < FSAVERAGE5_VERTS_PER_HEMI])\n        elif hemi == \"right\": idx_parts.append(verts[verts >= FSAVERAGE5_VERTS_PER_HEMI])\n        else:                 idx_parts.append(verts)\n    return np.concatenate(idx_parts)\n\ndef roi_dict_to_fsaverage5(roi_values: Mapping[str, float]) -> Tuple[np.ndarray, List[str]]:\n    acc    = np.zeros(FSAVERAGE5_VERTICES, dtype=np.float64)\n    counts = np.zeros(FSAVERAGE5_VERTICES, dtype=np.float64)\n    skipped = []\n    for roi_name, value in roi_values.items():\n        targets = ROI56_TO_HCP.get(roi_name, [(roi_name, \"both\")])\n        if not targets:\n            skipped.append(roi_name); continue\n        painted = False\n        for hcp_name, hemi in targets:\n            try:\n                idx = get_hcp_roi_indices(hcp_name, hemi=hemi)\n            except ValueError:\n                continue\n            acc[idx] += float(value); counts[idx] += 1.0; painted = True\n        if not painted:\n            skipped.append(roi_name)\n    mask = counts > 0\n    acc[mask] /= counts[mask]\n    return acc.astype(np.float32), skipped\n\ndef plot_brain(\n    roi_map:   Mapping[str, float],\n    *,\n    views:     Sequence[str] = (\"left\", \"right\", \"dorsal\"),\n    cmap:      str           = \"RdBu_r\",\n    vmax:      float | None  = None,\n    threshold: float         = 0.02,\n    title:     str | None    = None,\n):\n    \\\"\\\"\\\"Paint roi_map on fsaverage5 and plot with Nilearn.\n    views: any subset of \\\"left\\\", \\\"right\\\", \\\"dorsal\\\", \\\"ventral\\\".\n    MNE HCP-MMP1 parcellation (~50 MB) downloads on first call.\n    \\\"\\\"\\\"\n    import matplotlib.pyplot as plt\n    from nilearn.datasets import fetch_surf_fsaverage\n    from nilearn.plotting  import plot_surf_stat_map\n\n    vertex_map, skipped = roi_dict_to_fsaverage5(roi_map)\n    if skipped:\n        print(f\"  [brain plotter] skipped (no HCP mapping): {skipped}\")\n\n    v = np.asarray(vertex_map, dtype=np.float32)\n    if vmax is None:\n        vmax = float(np.percentile(np.abs(v), 99)) or 1.0\n\n    fsa = fetch_surf_fsaverage(mesh=\"fsaverage5\")\n    left  = v[:FSAVERAGE5_VERTS_PER_HEMI]\n    right = v[FSAVERAGE5_VERTS_PER_HEMI:]\n\n    VIEW_SPEC = {\n        \"left\":    (\"left\",  \"lateral\", \"infl_left\",  \"sulc_left\"),\n        \"right\":   (\"right\", \"lateral\", \"infl_right\", \"sulc_right\"),\n        \"dorsal\":  (\"left\",  \"dorsal\",  \"infl_left\",  \"sulc_left\"),\n        \"ventral\": (\"left\",  \"ventral\", \"infl_left\",  \"sulc_left\"),\n    }\n    n = len(views)\n    fig, axes = plt.subplots(1, n, figsize=(4.2*n, 3.8), subplot_kw={\"projection\": \"3d\"})\n    if n == 1:\n        axes = [axes]\n    for ax, view in zip(axes, views):\n        hemi, nv, infl_key, sulc_key = VIEW_SPEC.get(view, VIEW_SPEC[\"left\"])\n        stat = left if hemi == \"left\" else right\n        plot_surf_stat_map(\n            stat_map=stat, surf_mesh=fsa[infl_key], bg_map=fsa[sulc_key],\n            view=nv, axes=ax, cmap=cmap, vmin=-vmax, vmax=vmax,\n            threshold=threshold, colorbar=False, symmetric_cbar=True,\n        )\n        ax.set_title(view, fontsize=9)\n    sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=-vmax, vmax=vmax))\n    sm.set_array([])\n    fig.colorbar(sm, ax=axes, shrink=0.55, label=\"Predicted activation (a.u.)\")\n    if title:\n        fig.suptitle(title, fontsize=11)\n    plt.tight_layout()\n    plt.show()\n    return fig\n\nprint(\"Brain plotter ready.\")\nprint(\"  Usage: plot_brain(roi_map, title='My stimulus')\")\nprint(\"  MNE HCP-MMP1 parcellation will download (~50 MB) on first call.\")\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "brain-plotter-usage",
+   "metadata": {},
+   "outputs": [],
+   "source": "# ── Plot predictions on the brain ─────────────────────────────────────────────\n# Run any inference cell above first (Option A, B, or C), then run this cell.\n\n_map = (\n    roi_map       if 'roi_map'       in dir() else\n    roi_map_audio if 'roi_map_audio' in dir() else\n    roi_map_text  if 'roi_map_text'  in dir() else\n    None\n)\n\nif _map is None:\n    print(\"Run an inference cell first (Option A, B, or C) to produce a roi_map.\")\nelse:\n    # 4-view: left/right lateral + dorsal + ventral\n    plot_brain(\n        _map,\n        views=(\"left\", \"right\", \"dorsal\", \"ventral\"),\n        cmap=\"RdBu_r\",\n        title=\"Predicted brain activation (fsaverage5, HCP-MMP1)\",\n    )\n\n# ---- Compare two stimuli side-by-side ----------------------------------------\n# fig1 = plot_brain(roi_map_audio, title=\"Audio stimulus\")\n# fig2 = plot_brain(roi_map_text,  title=\"Text stimulus\")\n\n# ---- Custom views (e.g. medial-only) -----------------------------------------\n# plot_brain(_map, views=(\"dorsal\", \"ventral\"), cmap=\"hot\", vmax=0.5)\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Option A: pre-cached text examples (CPU, instant, no encoder needed) ─────\n",
+    "# Uses the examples_cache.npz bundled in the zip, or downloaded from HF.\n",
+    "# Skipped automatically if the file is unavailable.\n",
+    "\n",
+    "if examples_path:\n",
+    "    cache = np.load(examples_path, allow_pickle=True)\n",
+    "    sentences  = [s.decode() if isinstance(s, bytes) else str(s) for s in cache['sentences']]\n",
+    "    embeddings = cache['embeddings'].astype(np.float32)  # (N, 2560)\n",
+    "    print(f'Loaded {len(sentences)} cached examples')\n",
+    "\n",
+    "    # ── pick a sentence to visualise ──\n",
+    "    idx = 0  # change index or replace sentence below\n",
+    "    sentence = sentences[idx]\n",
+    "    roi_map = predict_from_features(embeddings[idx], model, IN_DIM)\n",
+    "\n",
+    "    print(f'\\nInput: \"{sentence}\"')\n",
+    "    print('Top 10 ROIs:')\n",
+    "    for roi, val in sorted(roi_map.items(), key=lambda x: -x[1])[:10]:\n",
+    "        print(f'  {roi:<16} {val:+.4f}')\n",
+    "    plot_rois(roi_map, title=sentence)\n",
+    "else:\n",
+    "    print('examples_cache.npz not found — skip to Option B (audio) or Option C (live text).')"
+   ],
+   "id": "cached-examples"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Option B: Audio inference with Whisper v4 (GPU recommended) ──────────────\n",
+    "# Upload a .wav file to Colab, or set AUDIO_PATH to a URL.\n",
+    "# Whisper-large-v3 downloads automatically (~3 GB, cached after first run).\n",
+    "\n",
+    "AUDIO_PATH = 'your_audio.wav'  # <-- replace with your file\n",
+    "\n",
+    "# Uncomment to download a sample clip:\n",
+    "# import urllib.request\n",
+    "# urllib.request.urlretrieve('https://upload.wikimedia.org/wikipedia/commons/2/22/Beethoven_Moonlight_Sonata_First_Movement.ogg', 'sample.ogg')\n",
+    "# AUDIO_PATH = 'sample.ogg'\n",
+    "\n",
+    "import librosa\n",
+    "from transformers import WhisperProcessor, WhisperModel\n",
+    "\n",
+    "print('Loading Whisper-large-v3 (downloads ~3 GB on first run)...')\n",
+    "processor = WhisperProcessor.from_pretrained('openai/whisper-large-v3')\n",
+    "whisper_enc = WhisperModel.from_pretrained('openai/whisper-large-v3')\n",
+    "whisper_enc.eval()\n",
+    "print('Loaded.')\n",
+    "\n",
+    "audio, sr = librosa.load(AUDIO_PATH, sr=16000, mono=True)\n",
+    "inputs = processor(audio, sampling_rate=16000, return_tensors='pt')\n",
+    "with torch.no_grad():\n",
+    "    enc_out = whisper_enc.encoder(inputs.input_features)\n",
+    "audio_emb = enc_out.last_hidden_state.mean(dim=1).squeeze(0).cpu().numpy()  # (1280,)\n",
+    "print(f'Audio embedding: {audio_emb.shape}')\n",
+    "\n",
+    "roi_map_audio = predict_from_features(audio_emb, model, IN_DIM)\n",
+    "print('\\nTop 10 ROIs (audio):')\n",
+    "for roi, val in sorted(roi_map_audio.items(), key=lambda x: -x[1])[:10]:\n",
+    "    print(f'  {roi:<16} {val:+.4f}')\n",
+    "plot_rois(roi_map_audio, title=f'Audio: {AUDIO_PATH}')"
+   ],
+   "id": "audio-inference"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Option C: Custom text inference with Qwen3 (GPU recommended, ~8 GB) ──────\n",
+    "import torch.nn.functional as F\n",
+    "from transformers import AutoModel, AutoTokenizer\n",
+    "\n",
+    "YOUR_TEXT = 'listening to a symphony building to its climax'\n",
+    "\n",
+    "print('Loading Qwen3-Embedding-4B (downloads ~8 GB on first run)...')\n",
+    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
+    "tok  = AutoTokenizer.from_pretrained('Qwen/Qwen3-Embedding-4B', padding_side='left')\n",
+    "qwen = AutoModel.from_pretrained(\n",
+    "    'Qwen/Qwen3-Embedding-4B',\n",
+    "    torch_dtype=torch.bfloat16 if device != 'cpu' else torch.float32\n",
+    ").to(device).eval()\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    enc = tok([YOUR_TEXT], return_tensors='pt', padding=True, truncation=True, max_length=512).to(device)\n",
+    "    h   = qwen(**enc).last_hidden_state[:, -1].float()\n",
+    "    emb = F.normalize(h, p=2, dim=1).cpu().numpy()[0].astype(np.float32)  # (2560,)\n",
+    "\n",
+    "del qwen; torch.cuda.empty_cache() if device == 'cuda' else None\n",
+    "\n",
+    "roi_map_text = predict_from_features(emb, model, IN_DIM)\n",
+    "print(f'\\nInput: \"{YOUR_TEXT}\"')\n",
+    "print('Top 10 ROIs:')\n",
+    "for roi, val in sorted(roi_map_text.items(), key=lambda x: -x[1])[:10]:\n",
+    "    print(f'  {roi:<16} {val:+.4f}')\n",
+    "plot_rois(roi_map_text, title=YOUR_TEXT)"
+   ],
+   "id": "custom-text"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ── Network-level summary ─────────────────────────────────────────────────────\n",
+    "NETWORKS = {\n",
+    "    'Visual':      ['V1','V2','V3','V4','V3A','V3B','LO1','LO2','MT','MST','V7','IPS1','FFA-1','FFA-2','PPA','RSC','OFA','EBA'],\n",
+    "    'Parietal':    ['IPS2','IPS3','IPS4','IPS5','SPL1','hIP1','hIP2','hIP3'],\n",
+    "    'Frontal':     ['dlPFC','vlPFC','OFC','ACC','mPFC','FP1','FP2'],\n",
+    "    'Language':    ['IFG','IFGorb','STG','STS','MTG','AG'],\n",
+    "    'DefaultMode': ['PCC','mPFC_dmn','LP_L','LP_R','HPC_L','HPC_R'],\n",
+    "    'Salience':    ['AI','dACC','sgACC','vmPFC','Amygdala_L','Amygdala_R'],\n",
+    "    'Subcortical': ['Caudate_L','Caudate_R','Putamen_L','Putamen_R','Thalamus'],\n",
+    "}\n",
+    "\n",
+    "# swap roi_map for whichever you ran above\n",
+    "active_map = roi_map if 'roi_map' in dir() else (roi_map_audio if 'roi_map_audio' in dir() else roi_map_text)\n",
+    "\n",
+    "nets = {net: float(np.mean([active_map[r] for r in rois if r in active_map]))\n",
+    "        for net, rois in NETWORKS.items()}\n",
+    "\n",
+    "print('Network activations:')\n",
+    "for net, val in sorted(nets.items(), key=lambda x: -x[1]):\n",
+    "    bar = '\\u2588' * max(0, int((val + 0.3) * 18))\n",
+    "    print(f'  {net:<14} {val:+.4f}  {bar}')"
+   ],
+   "id": "network-summary"
+  }
+ ]
+}

text2roi_combined_v4.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da0587ee45c54b564d2482f180eaa64e16f1a5e41b78f14f706fc60fa94b6607
+size 17961027

text2roi_qwen3_v8.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb8bb6fd2c99e32f3326c4a2a9a5b4e301d8a07ff31b23ba232cdbccae3e4f63
+size 12718105

text2roi_whisper_v4.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4cbfb2490c10c7e184d5463e8056c98076a7f8ba21bd2df7a4b8bfac6b64ca4
+size 7475253