| import argparse |
| import json |
| import os |
| import sys |
| import time |
| from pathlib import Path |
|
|
| import h5py |
| import torch |
| import torch.nn.functional as F |
|
|
| HERE = Path(__file__).resolve().parent |
| ROOT = HERE.parents[2] |
| sys.path.insert(0, str(Path(os.environ.get('TUNE_DIR', ROOT / 'experiments/miscellaneous/tune')))) |
|
|
| import patch_packets as pp |
| from encoders import ENCODERS |
| from prompts import DATASETS, TEMPLATES, class_phrases, generic, tag |
|
|
| ARM = 'short' |
| CRITERION = 'filtered-class' |
| KEEP = pp.KEEP_PATCHES |
| TOP1_ROOT = Path(os.environ.get('TOP1_ROOT', ROOT / 'data/packets/patch/top1')) |
| RUNS = {'native': ('native-261010', 'native-261005', 'native-build'), 'multiscale': ('multiscale-261010', 'multiscale-261005', 'multiscale-build')} |
|
|
|
|
| def top1_packet(dataset, enc, scale): |
| name = f'{tag(dataset, enc, scale, ARM, CRITERION)}.pt' |
| for run in RUNS['native' if scale == 'native' else 'multiscale']: |
| path = TOP1_ROOT / run / 'packets' / name |
| if path.exists(): |
| return path |
| raise FileNotFoundError(f'{name} not found under {TOP1_ROOT}') |
|
|
|
|
| def build_cell(dataset, enc_name, scale, enc, templates, TN, out, limit, filter_info=None): |
| path = out / f'{tag(dataset, enc_name, scale, ARM, CRITERION)}--patches{"-smoke" if limit else ""}.pt' |
| if path.exists(): |
| print('skip (exists)', path.name, flush=True) |
| return |
| spec = DATASETS[dataset] |
| canon_file = top1_packet(dataset, enc_name, scale) |
| canon = torch.load(canon_file, map_location='cpu', weights_only=False) |
| stems = list(canon['stems']) |
| W = torch.stack([pp.concept_embedding(enc, p, templates) for p in class_phrases(dataset, ARM)]) |
| if W.size(0) != int(canon['n_classes']): |
| raise ValueError(f'{dataset}: bank has {W.size(0)} classes, packet {canon["n_classes"]}') |
| count = limit or len(stems) |
| feats, scores, margin, index, coords, n_rows, n_all = [], [], [], [], [], [], [] |
| start = time.time() |
| for i, stem in enumerate(stems[:count]): |
| with h5py.File(pp.slide_path(spec, enc_name, scale, stem)) as h: |
| x = enc.image(torch.tensor(h['features'][:]).float()) |
| xy = torch.tensor(h['coords'][:]).long() |
| q = (x @ TN[0]) - (x @ TN[1]) |
| kept = pp.margin_order(q, min(KEEP, len(q))) |
| s = x @ W.T |
| rank = kept[torch.sort(-s.max(1).values[kept], stable=True).indices] |
| pad = KEEP - rank.numel() |
| feats.append(F.pad(x[rank], (0, 0, 0, pad))) |
| scores.append(F.pad(s[rank], (0, 0, 0, pad))) |
| margin.append(F.pad(q[rank], (0, pad))) |
| index.append(F.pad(rank.int(), (0, pad), value=-1)) |
| coords.append(F.pad(xy[rank], (0, 0, 0, pad), value=-1)) |
| n_rows.append(rank.numel()) |
| n_all.append(len(q)) |
| if (i + 1) % 100 == 0: |
| print(f'{dataset} {enc_name} {scale}: {i + 1}/{count} slides, {time.time() - start:.0f} s', flush=True) |
| feats = torch.stack(feats) |
| gap = float((feats[:, 0].float() - canon['z'][:count]).abs().max()) |
| if gap > 2e-3 and filter_info is None: |
| raise ValueError(f'{dataset} {enc_name} {scale}: rank-1 patch differs from the top-1 packet z by {gap}') |
| blob = {'stems': stems[:count], 'feats': feats, 'class_scores': torch.stack(scores), 'tumour_margin': torch.stack(margin), |
| 'patch_index': torch.stack(index), 'coords': torch.stack(coords), |
| 'count': torch.tensor(n_rows, dtype=torch.long), 'slide_patches': torch.tensor(n_all, dtype=torch.long), |
| 'provenance': {'dataset': dataset, 'encoder': enc_name, 'scale': scale, 'arm': ARM, 'criterion': CRITERION, 'rows': KEEP, |
| 'ranking': 'the 100 patches with the largest tumour-minus-contrast margin, ordered by best class score (rank 1 first); any top-k is the first k rows', |
| 'feats': 'encoder image vectors, unit length from the encoder, float32, zero padded', |
| 'class_scores': 'unit patch vector times each class text embedding, before any temperature', |
| 'padding': 'rows beyond count are zero (index and coords -1)', 'rank1_check_gap': gap, |
| 'filter': filter_info or 'generic tumour and contrast phrases (data/prompts/generic.json)', |
| 'top1_packet': canon_file.name, 'created': time.strftime('%Y-%m-%d %H:%M:%S %z')}} |
| tmp = path.with_suffix('.tmp') |
| torch.save(blob, tmp) |
| tmp.replace(path) |
| print(f'wrote {path.name} (rank-1 gap {gap:.1e}, {time.time() - start:.0f} s)', flush=True) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument('--encoder', required=True, choices=list(ENCODERS)) |
| ap.add_argument('--datasets', nargs='+', required=True, choices=list(DATASETS)) |
| ap.add_argument('--scales', nargs='+', default=['native', '1024px', '2048px'], choices=['native', '1024px', '2048px']) |
| ap.add_argument('--out-dir', required=True) |
| ap.add_argument('--limit', type=int, default=0) |
| ap.add_argument('--threads', type=int, default=4) |
| ap.add_argument('--filter-prompts', default=None, help='json with tumour and contrast phrases per dataset (data/prompts/detailed-pilot.json); default the generic phrases for every dataset') |
| ap.add_argument('--dry-run', action='store_true', help='print the phrases and the files that would be written, load nothing') |
| a = ap.parse_args() |
| torch.set_num_threads(a.threads) |
| out = Path(a.out_dir) |
| out.mkdir(parents=True, exist_ok=True) |
| prompts = json.load(open(a.filter_prompts))['datasets'] if a.filter_prompts else None |
| if a.dry_run: |
| for dataset in a.datasets: |
| tumour, contrast = phrases(prompts, dataset) |
| print(dataset, 'tumour', len(tumour), tumour, 'contrast', len(contrast), contrast) |
| for scale in a.scales: |
| print(' would write', out / f'{tag(dataset, a.encoder, scale, ARM, CRITERION)}--patches.pt') |
| return |
| enc = ENCODERS[a.encoder]() |
| templates = TEMPLATES[a.encoder] |
| embed = lambda tumour, contrast: torch.stack([pp.concept_embedding(enc, tumour, templates), pp.concept_embedding(enc, contrast, templates)]) |
| for dataset in a.datasets: |
| tumour, contrast = phrases(prompts, dataset) |
| TN = embed(tumour, contrast) |
| info = {'phrases': a.filter_prompts, 'sha256': prompt_hash(a.filter_prompts), 'tumour': tumour, 'contrast': contrast} if prompts else None |
| for scale in a.scales: |
| try: |
| build_cell(dataset, a.encoder, scale, enc, templates, TN, out, a.limit, info) |
| except FileNotFoundError as e: |
| print(f'skip {dataset} {a.encoder} {scale}: {e}', flush=True) |
|
|
|
|
| |
| def phrases(prompts, dataset): |
| if prompts is None: |
| return generic() |
| entry = prompts[dataset] |
| return [p['text'] for p in entry['tumour']], [p['text'] for p in entry['contrast']] |
|
|
|
|
| def prompt_hash(path): |
| import hashlib |
| return hashlib.sha256(Path(path).read_bytes()).hexdigest() if path else None |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
