Sync local changes: CLIP scores, NSD image lookup, multi-trial DynaDiff, phi_c columns, P75 col, label captions, entrypoint pre-warm

entrypoint.sh

@@ -103,6 +103,35 @@ if [ ! -d "$COCO_THUMBS" ]; then
 fi
 IMAGE_DIR_ARG=(--image-dir "$COCO_THUMBS")
 
+# ── Pre-warm DynaDiff before Bokeh starts ────────────────────────────────────
+# torch.load holds the GIL for extended periods; doing this synchronously before
+# Bokeh launches ensures Tornado's event loop isn't starved when users connect.
+if [ -f "$DYNADIFF_CKPT" ] && [ -f "$FMRI_H5" ]; then
+    echo "Pre-warming DynaDiff (this may take a few minutes on cold start)..."
+    python3 - <<PYEOF
+import sys, time, os
+sys.path.insert(0, '/app')
+sys.path.insert(0, '/app/dynadiff')
+sys.path.insert(0, '/app/dynadiff/diffusers/src')
+os.chdir('/app')
+from scripts.dynadiff_loader import get_loader
+loader = get_loader(
+    dynadiff_dir='/app/dynadiff',
+    checkpoint=os.environ.get('DYNADIFF_CKPT', '$DYNADIFF_CKPT'),
+    h5_path='$FMRI_H5',
+)
+while True:
+    status, err = loader.status
+    if status == 'ok':
+        print('DynaDiff pre-warm complete.')
+        break
+    elif status == 'error':
+        print(f'DynaDiff pre-warm failed: {err}')
+        break
+    time.sleep(5)
+PYEOF
+fi
+
 # ── Determine websocket origin ────────────────────────────────────────────────
 SPACE_HOST="${SPACE_HOST:-localhost}"
 

scripts/add_clip_embeddings.py

@@ -0,0 +1,224 @@
+"""
+Post-hoc CLIP text-alignment enrichment for explorer_data.pt files.
+
+Loads an existing explorer_data.pt, computes per-feature CLIP text alignment
+scores (via MEI images), and saves them back into the same file under:
+    'clip_text_scores'      : Tensor (n_features, n_vocab) float16
+    'clip_text_vocab'       : list[str]
+    'clip_feature_embeds'   : Tensor (n_features, clip_proj_dim) float16
+                              mean CLIP image embedding of each feature's top MEIs
+
+This script does NOT need to re-run DINOv3 or the SAE — it only needs the
+existing explorer_data.pt (for image paths and top-MEI indices) and CLIP.
+
+Usage
+-----
+    python add_clip_embeddings.py \
+        --data ../explorer_data_d32000_k160.pt \
+        --vocab-file ../vocab/imagenet_labels.txt \
+        --n-top-images 4 \
+        --batch-size 32
+
+    # Or use the built-in default vocabulary (ImageNet-1K labels + COCO categories):
+    python add_clip_embeddings.py \
+        --data ../explorer_data_d32000_k160.pt
+
+The enriched file is saved to --output-path (defaults to overwriting --data
+with a backup copy at <data>.bak).
+"""
+
+import argparse
+import os
+import shutil
+
+import torch
+import torch.nn.functional as F
+from PIL import Image
+
+# Allow running from scripts/ directory or project root
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+from clip_utils import load_clip, compute_text_embeddings, compute_mei_text_alignment
+
+
+# ---------------------------------------------------------------------------
+# Default vocabulary
+# ---------------------------------------------------------------------------
+
+DEFAULT_VOCAB = [
+    # COCO categories
+    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train",
+    "truck", "boat", "traffic light", "fire hydrant", "stop sign",
+    "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
+    "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag",
+    "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
+    "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket",
+    "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana",
+    "apple", "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza",
+    "donut", "cake", "chair", "couch", "potted plant", "bed", "dining table",
+    "toilet", "tv", "laptop", "mouse", "remote", "keyboard", "cell phone",
+    "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock",
+    "vase", "scissors", "teddy bear", "hair drier", "toothbrush",
+    # Texture / scene descriptors
+    "grass", "sky", "water", "sand", "snow", "wood", "stone", "metal",
+    "fabric", "fur", "feathers", "leaves", "clouds", "fire", "shadow",
+    "stripes", "spots", "checkerboard pattern", "geometric pattern",
+    # Orientation / structure cues (for patch features)
+    "horizontal lines", "vertical lines", "diagonal lines", "curved lines",
+    "edges", "corners", "grid", "dots", "concentric circles",
+    # Color / illumination
+    "red object", "blue object", "green object", "yellow object",
+    "black and white", "bright highlight", "dark shadow", "gradient",
+    # Scene types
+    "indoor scene", "outdoor scene", "urban street", "nature landscape",
+    "ocean", "mountain", "forest", "desert", "city buildings", "crowd",
+]
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(description="Add CLIP text alignment to explorer_data.pt")
+    parser.add_argument("--data", type=str, required=True,
+                        help="Path to explorer_data.pt")
+    parser.add_argument("--output-path", type=str, default=None,
+                        help="Output path (default: overwrite --data, keeping .bak)")
+    parser.add_argument("--vocab-file", type=str, default=None,
+                        help="Plain-text file with one concept per line.  "
+                             "Default: built-in COCO+texture vocabulary.")
+    parser.add_argument("--clip-model", type=str, default="openai/clip-vit-large-patch14",
+                        help="HuggingFace CLIP model ID")
+    parser.add_argument("--n-top-images", type=int, default=4,
+                        help="Number of MEIs to average per feature for CLIP alignment")
+    parser.add_argument("--batch-size", type=int, default=32,
+                        help="Batch size for CLIP image encoding")
+    parser.add_argument("--no-backup", action="store_true",
+                        help="Skip creating a .bak copy before overwriting")
+    parser.add_argument("--image-dir", type=str, default=None,
+                        help="Primary image directory for resolving bare filenames")
+    parser.add_argument("--extra-image-dir", type=str, action="append", default=[],
+                        help="Additional image directory (repeatable)")
+    args = parser.parse_args()
+
+    image_bases = [b for b in ([args.image_dir] + args.extra_image_dir) if b]
+
+    def resolve_path(p):
+        if os.path.isabs(p) or not image_bases:
+            return p
+        for base in image_bases:
+            full = os.path.join(base, p)
+            if os.path.exists(full):
+                return full
+        return os.path.join(image_bases[0], p)  # fallback
+
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print(f"Device: {device}")
+
+    # --- Load explorer data ---
+    print(f"Loading explorer data from {args.data}...")
+    data = torch.load(args.data, map_location='cpu', weights_only=False)
+    image_paths = [resolve_path(p) for p in data['image_paths']]
+    d_model = data['d_model']
+    top_img_idx = data['top_img_idx']       # (n_features, n_top)
+    n_top_stored = top_img_idx.shape[1]
+    print(f"  d_model={d_model}, n_images={data['n_images']}, "
+          f"top-{n_top_stored} images stored")
+
+    # --- Load vocabulary ---
+    if args.vocab_file:
+        with open(args.vocab_file) as f:
+            vocab = [line.strip() for line in f if line.strip()]
+        print(f"Loaded {len(vocab)} concepts from {args.vocab_file}")
+    else:
+        vocab = DEFAULT_VOCAB
+        print(f"Using default vocabulary ({len(vocab)} concepts)")
+
+    # --- Load CLIP ---
+    clip_model, clip_processor = load_clip(device, model_name=args.clip_model)
+
+    # --- Precompute text embeddings ---
+    print("Encoding text vocabulary with CLIP...")
+    text_embeds = compute_text_embeddings(vocab, clip_model, clip_processor, device)
+    print(f"  text_embeds: {text_embeds.shape}")
+
+    # --- Collect MEI image paths per feature ---
+    print("Collecting MEI image paths per feature...")
+    n_use = min(args.n_top_images, n_top_stored)
+    feature_mei_paths = []
+    for feat in range(d_model):
+        paths = []
+        for j in range(n_use):
+            idx = top_img_idx[feat, j].item()
+            if idx >= 0:
+                paths.append(image_paths[idx])
+        feature_mei_paths.append(paths)
+
+    # --- Compute per-feature CLIP image embeddings (mean of MEIs) ---
+    print(f"Computing CLIP image embeddings for {d_model} features "
+          f"(averaging {n_use} MEIs each)...")
+
+    clip_proj_dim = clip_model.config.projection_dim
+    feature_img_embeds = torch.zeros(d_model, clip_proj_dim, dtype=torch.float32)
+    dead_count = 0
+
+    for feat_start in range(0, d_model, args.batch_size):
+        feat_end = min(feat_start + args.batch_size, d_model)
+        for feat in range(feat_start, feat_end):
+            paths = feature_mei_paths[feat]
+            if not paths:
+                dead_count += 1
+                continue
+            imgs = []
+            for p in paths:
+                try:
+                    imgs.append(Image.open(p).convert("RGB"))
+                except Exception:
+                    continue
+            if not imgs:
+                dead_count += 1
+                continue
+            inputs = clip_processor(images=imgs, return_tensors="pt")
+            pixel_values = inputs['pixel_values'].to(device)
+            with torch.inference_mode():
+                # Use vision_model + visual_projection directly to avoid
+                # version differences in get_image_features() return type.
+                vision_out = clip_model.vision_model(pixel_values=pixel_values)
+                embeds = clip_model.visual_projection(vision_out.pooler_output)
+                embeds = F.normalize(embeds, dim=-1)
+                mean_embed = embeds.mean(dim=0)
+                mean_embed = F.normalize(mean_embed, dim=-1)
+            feature_img_embeds[feat] = mean_embed.cpu().float()
+
+        if (feat_start // args.batch_size + 1) % 100 == 0:
+            print(f"  [{feat_end}/{d_model}] features encoded", flush=True)
+
+    print(f"  Done. Dead/missing features skipped: {dead_count}")
+
+    # --- Compute alignment matrix ---
+    print("Computing text alignment matrix...")
+    # (n_features, clip_proj_dim) @ (clip_proj_dim, n_vocab) = (n_features, n_vocab)
+    clip_text_scores = feature_img_embeds @ text_embeds.T   # float32
+    print(f"  clip_text_scores: {clip_text_scores.shape}")
+
+    # --- Save into explorer_data.pt ---
+    output_path = args.output_path or args.data
+    if output_path == args.data and not args.no_backup:
+        bak_path = args.data + ".bak"
+        print(f"Creating backup at {bak_path}...")
+        shutil.copy2(args.data, bak_path)
+
+    data['clip_text_scores']    = clip_text_scores.half()              # float16 to save space
+    data['clip_feature_embeds'] = feature_img_embeds.half()            # float16
+    data['clip_text_vocab']     = vocab
+
+    print(f"Saving enriched explorer data to {output_path}...")
+    torch.save(data, output_path)
+    size_mb = os.path.getsize(output_path) / 1e6
+    print(f"Saved ({size_mb:.1f} MB)")
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

scripts/dynadiff_loader.py

@@ -80,6 +80,7 @@ class DynaDiffLoader:
         self._cfg     = None
         self._beta_std = None
         self._subject_sample_indices = None
+        self._nsd_to_sample = {}
         self._status  = 'loading'   # 'loading' | 'ok' | 'error'
         self._error   = ''
         self._lock    = threading.Lock()
@@ -102,6 +103,15 @@ class DynaDiffLoader:
             idx = self._subject_sample_indices
         return len(idx) if idx is not None else None
 
+    def sample_idxs_for_nsd_img(self, nsd_img_idx):
+        """Return the list of sample_idx values that correspond to a given NSD image index.
+
+        Returns an empty list if the image has no trials for this subject or the
+        mapping is not yet built (model still loading).
+        """
+        with self._lock:
+            return list(self._nsd_to_sample.get(int(nsd_img_idx), []))
+
     def start(self):
         """Start background model loading thread."""
         t = threading.Thread(target=self._load, daemon=True)
@@ -216,15 +226,23 @@ class DynaDiffLoader:
             # Subject sample index mapping
             log.info(f'[DynaDiff] Building sample index for subject {self.subject_idx} ...')
             with h5py.File(self.h5_path, 'r') as hf:
-                all_subj = np.array(hf['subject_idx'][:], dtype=np.int64)
+                all_subj  = np.array(hf['subject_idx'][:], dtype=np.int64)
+                all_imgidx = np.array(hf['image_idx'][:],  dtype=np.int64)
             sample_indices = np.where(all_subj == self.subject_idx)[0].astype(np.int64)
             log.info(f'[DynaDiff] {len(sample_indices)} samples for subject {self.subject_idx}')
 
+            # Build reverse map: NSD image index → list of sample_idx values
+            nsd_to_sample: dict[int, list[int]] = {}
+            for sample_idx_val, h5_row in enumerate(sample_indices):
+                nsd_img = int(all_imgidx[h5_row])
+                nsd_to_sample.setdefault(nsd_img, []).append(sample_idx_val)
+
             with self._lock:
                 self._model   = model
                 self._cfg     = cfg
                 self._beta_std = beta_std
                 self._subject_sample_indices = sample_indices
+                self._nsd_to_sample = nsd_to_sample
                 self._status  = 'ok'
             log.info('[DynaDiff] Ready.')
 

scripts/explorer_app.py

@@ -430,10 +430,10 @@ def _load_brain_dataset_dict(path, label, thumb_dir):
         'feature_p75_val':   bd.get('feature_p75_val', torch.zeros(d_model)),
         'umap_coords':       bd['umap_coords'].numpy() if 'umap_coords' in bd else nan2,
         'dict_umap_coords':  bd['dict_umap_coords'].numpy() if 'dict_umap_coords' in bd else nan2,
-        'clip_scores':       None,
-        'clip_vocab':        None,
-        'clip_embeds':       None,
-        'clip_scores_f32':   None,
+        'clip_scores':       bd.get('clip_text_scores', None),
+        'clip_vocab':        bd.get('clip_text_vocab', None),
+        'clip_embeds':       bd.get('clip_feature_embeds', None),
+        'clip_scores_f32':   bd['clip_text_scores'].float() if 'clip_text_scores' in bd else None,
         'inference_cache':   OrderedDict(),
         'names_file':        stem + '_feature_names.json',
         'auto_interp_file':  stem + '_auto_interp.json',
@@ -633,6 +633,9 @@ def _reconstruct_z_from_heatmaps(img_idx, ds):
         idx = ds.get(idx_key)  # (d_sae, n_slots) int tensor
         if hm is None or idx is None:
             continue
+        # Normalise: flatten 4-D (d_sae, n_slots, H, W) → 3-D (d_sae, n_slots, H*W)
+        if hm.ndim == 4:
+            hm = hm.reshape(hm.shape[0], hm.shape[1], -1)
         if z is None:
             d_sae, _, n_patches_sq = hm.shape
             z = np.zeros((n_patches_sq, d_sae), dtype=np.float32)
@@ -704,6 +707,20 @@ ALPHA_JET = create_alpha_cmap('jet')
 THUMB = args.thumb_size
 
 
+def _parse_img_label(value):
+    """Parse an image label into an integer index.
+
+    Accepts bare integers ('42') or name-prefixed labels ('nsd_00042',
+    'COCO_val2014_000000123456') by extracting the trailing integer after
+    the last underscore.  Raises ValueError on failure.
+    """
+    val = value.strip()
+    try:
+        return int(val)
+    except ValueError:
+        return int(val.rsplit('_', 1)[-1])
+
+
 def _resolve_img_path(stored_path):
     """Resolve a stored image path, searching image dirs first. Returns None on failure."""
     if os.path.isabs(stored_path) and os.path.exists(stored_path):
@@ -952,33 +969,42 @@ def _dynadiff_request(sample_idx, steerings, seed):
     return _dd_loader.reconstruct(sample_idx, steerings, seed)
 
 
-def _make_steering_html(resp, concept_name):
-    """Build HTML showing GT | Baseline | Steered side by side."""
-    parts = []
-    for label, key in [('Ground Truth', 'gt_img'),
-                        ('Baseline (λ=0)', 'baseline_img'),
-                        (f'Steered', 'steered_img')]:
-        b64 = resp.get(key)
-        if b64 is None:
-            img_html = ('<div style="width:200px;height:200px;background:#eee;'
-                        'display:flex;align-items:center;justify-content:center;'
-                        'color:#999;font-size:12px">N/A</div>')
-        else:
-            img_html = (f'<img src="data:image/png;base64,{b64}" '
-                        'style="width:200px;height:200px;object-fit:contain;'
-                        'border:1px solid #ddd;border-radius:4px"/>')
-        parts.append(
-            f'<div style="text-align:center;margin:0 6px">'
-            f'{img_html}'
-            f'<div style="font-size:11px;color:#555;margin-top:3px">{label}</div>'
-            f'</div>'
-        )
-    imgs_html = '<div style="display:flex;align-items:flex-end">' + ''.join(parts) + '</div>'
-    return (
+def _make_steering_html(resps, concept_name):
+    """Build HTML showing GT | Baseline | Steered for one or more trials.
+
+    resps: list of (trial_label, resp_dict) pairs.
+    """
+    header = (
         f'<h3 style="margin:4px 0 6px 0;color:#333;border-bottom:2px solid #e0e0e0;'
         f'padding-bottom:4px">DynaDiff Steering — {concept_name}</h3>'
-        + imgs_html
     )
+    rows_html = ''
+    for trial_label, resp in resps:
+        parts = []
+        for label, key in [('GT', 'gt_img'),
+                            ('Baseline', 'baseline_img'),
+                            ('Steered', 'steered_img')]:
+            b64 = resp.get(key)
+            if b64 is None:
+                img_html = ('<div style="width:160px;height:160px;background:#eee;'
+                            'display:flex;align-items:center;justify-content:center;'
+                            'color:#999;font-size:12px">N/A</div>')
+            else:
+                img_html = (f'<img src="data:image/png;base64,{b64}" '
+                            'style="width:160px;height:160px;object-fit:contain;'
+                            'border:1px solid #ddd;border-radius:4px"/>')
+            parts.append(
+                f'<div style="text-align:center;margin:0 4px">'
+                f'{img_html}'
+                f'<div style="font-size:11px;color:#555;margin-top:3px">{label}</div>'
+                f'</div>'
+            )
+        trial_head = (f'<div style="font-size:11px;font-weight:bold;color:#777;'
+                      f'margin:6px 0 3px 4px">{trial_label}</div>')
+        rows_html += (trial_head
+                      + '<div style="display:flex;align-items:flex-end;margin-bottom:8px">'
+                      + ''.join(parts) + '</div>')
+    return header + rows_html
 
 
 def make_image_grid_html(images_info, title, cols=9):
@@ -1391,10 +1417,14 @@ def _build_dynadiff_panel():
     dd_feat_remove_btn.on_click(_on_remove_feat)
     dd_feat_clear_btn.on_click(_on_clear_feats)
 
-    def _reconstruct_thread(sample_idx, steerings, seed, feat_name, doc):
+    def _reconstruct_thread(sample_idxs, steerings, seed, feat_name, doc):
         try:
-            resp = _dynadiff_request(sample_idx, steerings, seed)
-            html = _make_steering_html(resp, feat_name)
+            resps = []
+            for i, sidx in enumerate(sample_idxs):
+                trial_label = f'Trial {i+1} (sample {sidx})'
+                resp = _dynadiff_request(sidx, steerings, seed)
+                resps.append((trial_label, resp))
+            html = _make_steering_html(resps, feat_name)
             def _apply(html=html):
                 dd_output.text  = html
                 dd_status.text  = ''
@@ -1422,13 +1452,25 @@ def _build_dynadiff_panel():
         if not steerings:
             dd_status.text = '<span style="color:#c00">No phi data for selected features.</span>'
             return
+        _raw = dd_sample_input.value.strip()
         try:
-            sample_idx = int(dd_sample_input.value)
+            _parsed = _parse_img_label(_raw)
         except ValueError:
             dd_status.text = '<span style="color:#c00">Invalid sample index.</span>'
             return
+        # If input looks like an NSD image label (contains '_'), treat _parsed as
+        # an NSD image index and run all trials for that image.
+        if '_' in _raw:
+            sample_idxs = _dd_loader.sample_idxs_for_nsd_img(_parsed)
+            if not sample_idxs:
+                dd_status.text = (
+                    f'<span style="color:#c00">NSD image {_parsed} has no trials '
+                    f'for this subject.</span>')
+                return
+        else:
+            sample_idxs = [_parsed]
         _n = _dd_loader.n_samples
-        if _n is not None and not (0 <= sample_idx < _n):
+        if _n is not None and any(not (0 <= s < _n) for s in sample_idxs):
             dd_status.text = f'<span style="color:#c00">sample_idx must be 0–{_n-1}.</span>'
             return
         try:
@@ -1438,11 +1480,13 @@ def _build_dynadiff_panel():
         names = list(dd_source.data['name'])
         feat_name = ' + '.join(names) if names else 'unknown'
         dd_btn.disabled = True
-        dd_status.text  = '<i style="color:#888">Running DynaDiff reconstruction…</i>'
+        n_trials = len(sample_idxs)
+        dd_status.text  = (f'<i style="color:#888">Running DynaDiff reconstruction '
+                           f'({n_trials} trial{"s" if n_trials > 1 else ""})…</i>')
         doc = curdoc()
         threading.Thread(
             target=_reconstruct_thread,
-            args=(sample_idx, steerings, seed, feat_name, doc),
+            args=(sample_idxs, steerings, seed, feat_name, doc),
             daemon=True,
         ).start()
 
@@ -1587,14 +1631,15 @@ def update_feature_display(feature_idx):
                 else:
                     hmap = None
 
+                img_label = os.path.splitext(os.path.basename(image_paths[img_i]))[0]
                 if hmap is None:
                     plain = load_image(img_i).resize((THUMB, THUMB), Image.BILINEAR)
                     act_val = float(act_tensor[feat, ranking_idx].item())
-                    caption = f"act={act_val:.4f}  img {img_i}"
+                    caption = f"act={act_val:.4f}  {img_label}"
                     return (plain, caption)
                 max_act, mean_act_val = _patch_stats(hmap.flatten())
                 img_out = render_zoomed_overlay(img_i, hmap, size=THUMB, center=center)
-                caption = f"img {img_i}"
+                caption = img_label
                 return (img_out, caption)
             except Exception as e:
                 ph = Image.new("RGB", (THUMB, THUMB), "gray")
@@ -1817,11 +1862,13 @@ feature_list_source = ColumnDataSource(data=dict(
     name=[_display_name(int(i)) for i in _init_order],
 ))
 
-_phi_col = (
-    [TableColumn(field="phi_c_val", title="φ_c", width=65,
-                 formatter=NumberFormatter(format="0.0000"))]
-    if HAS_PHI else []
-)
+def _phi_col():
+    """Return phi_c column definition list (single element) if phi data is loaded, else []."""
+    if not HAS_PHI:
+        return []
+    return [TableColumn(field="phi_c_val", title="φ_c", width=65,
+                        formatter=NumberFormatter(format="0.0000"))]
+
 feature_table = DataTable(
     source=feature_list_source,
     columns=[
@@ -1830,9 +1877,7 @@ feature_table = DataTable(
                     formatter=NumberFormatter(format="0,0")),
         TableColumn(field="mean_act", title="Mean Act", width=80,
                     formatter=NumberFormatter(format="0.0000")),
-        TableColumn(field="p75_val", title="P75", width=70,
-                    formatter=NumberFormatter(format="0.0000")),
-    ] + _phi_col + [
+    ] + _phi_col() + [
         TableColumn(field="name", title="Name", width=200),
     ],
     width=500, height=500, sortable=True, index_position=None,
@@ -2170,20 +2215,20 @@ load_patch_btn = Button(label="Load Image", width=90, button_type="primary")
 clear_patch_btn = Button(label="Clear", width=60)
 
 patch_feat_source = ColumnDataSource(data=dict(
-    feature_idx=[], patch_act=[], frequency=[], mean_act=[],
+    feature_idx=[], patch_act=[], frequency=[], mean_act=[], phi_c_val=[],
 ))
 patch_feat_table = DataTable(
     source=patch_feat_source,
     columns=[
-        TableColumn(field="feature_idx", title="Feature",  width=65),
+        TableColumn(field="feature_idx", title="Feature",   width=65),
         TableColumn(field="patch_act",   title="Patch Act", width=85,
                     formatter=NumberFormatter(format="0.0000")),
         TableColumn(field="frequency",   title="Freq",      width=65,
                     formatter=NumberFormatter(format="0,0")),
         TableColumn(field="mean_act",    title="Mean Act",  width=80,
                     formatter=NumberFormatter(format="0.0000")),
-    ],
-    width=310, height=350, index_position=None, sortable=False, visible=False,
+    ] + _phi_col(),
+    width=310 + (65 if HAS_PHI else 0), height=350, index_position=None, sortable=False, visible=False,
 )
 patch_info_div = Div(
     text="<i>Load an image, then click patches to find top features.</i>",
@@ -2203,7 +2248,7 @@ def _pil_to_bokeh_rgba(pil_img, size):
 
 def _do_load_patch_image():
     try:
-        img_idx = int(patch_img_input.value)
+        img_idx = _parse_img_label(patch_img_input.value)
     except ValueError:
         patch_info_div.text = "<b style='color:red'>Invalid image index</b>"
         return
@@ -2292,7 +2337,7 @@ def _on_patch_select(attr, old, new):
     if _S.patch_img is None:
         return
     if not new:
-        patch_feat_source.data = dict(feature_idx=[], patch_act=[], frequency=[], mean_act=[])
+        patch_feat_source.data = dict(feature_idx=[], patch_act=[], frequency=[], mean_act=[], phi_c_val=[])
         patch_info_div.text = "<i>Selection cleared.</i>"
         return
 
@@ -2302,7 +2347,10 @@ def _on_patch_select(attr, old, new):
     patch_indices = [r * patch_grid + c for r, c in zip(rows, cols)]
 
     feats, acts, freqs, means = _get_top_features_for_patches(patch_indices)
-    patch_feat_source.data = dict(feature_idx=feats, patch_act=acts, frequency=freqs, mean_act=means)
+    patch_feat_source.data = dict(
+        feature_idx=feats, patch_act=acts, frequency=freqs, mean_act=means,
+        phi_c_val=_phi_c_vals(feats),
+    )
     patch_info_div.text = (
         f"{len(new)} patch(es) selected → {len(feats)} feature(s) found. "
         f"Click a row below to explore the feature."
@@ -2347,7 +2395,7 @@ def _build_clip_panel():
     clip_top_k_input = TextInput(title="Top-K results:", value="20", width=70)
 
     result_source = ColumnDataSource(data=dict(
-        feature_idx=[], clip_score=[], frequency=[], mean_act=[], name=[],
+        feature_idx=[], clip_score=[], frequency=[], mean_act=[], phi_c_val=[], name=[],
     ))
     clip_result_table = DataTable(
         source=result_source,
@@ -2359,9 +2407,10 @@ def _build_clip_panel():
                         formatter=NumberFormatter(format="0,0")),
             TableColumn(field="mean_act",    title="Mean Act",   width=80,
                         formatter=NumberFormatter(format="0.0000")),
+        ] + _phi_col() + [
             TableColumn(field="name",        title="Name",       width=160),
         ],
-        width=470, height=300, index_position=None, sortable=False,
+        width=470 + (65 if HAS_PHI else 0), height=300, index_position=None, sortable=False,
     )
 
     def _do_search():
@@ -2402,6 +2451,7 @@ def _build_clip_panel():
             clip_score=[float(scores_vec[i]) for i in top_indices],
             frequency=[int(feature_frequency[i].item()) for i in top_indices],
             mean_act=[float(feature_mean_act[i].item()) for i in top_indices],
+            phi_c_val=_phi_c_vals(top_indices),
             name=[_display_name(int(i)) for i in top_indices],
         )
         result_div.text = (