| import argparse |
| import ast |
| import os |
| import sys |
| from pathlib import Path |
|
|
| import json |
|
|
| import torch |
|
|
| 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, TEXT_ENCODERS |
| from prompts import DATASETS, TEMPLATES, class_phrases |
|
|
| ARM = 'short' |
|
|
|
|
| def check_against_set(W, dataset, enc_name, sets_dir): |
| files = sorted(Path(sets_dir).glob(f'{dataset}--{enc_name}--*--patches.pt')) |
| if not files: |
| return None |
| b = torch.load(files[0], map_location='cpu', weights_only=False, mmap=True) |
| n = min(64, b['feats'].size(0)) |
| feats = b['feats'][:n].float() |
| mask = torch.arange(feats.size(1))[None, :] < b['count'][:n, None] |
| pred = feats @ W.T |
| return float((pred - b['class_scores'][:n].float()).abs()[mask].max()) |
|
|
|
|
| def builder_phrases(path): |
| |
| values = {} |
| for node in ast.parse(Path(path).read_text()).body: |
| if isinstance(node, ast.Assign) and getattr(node.targets[0], 'id', None) in ('CLASS_ORDER', 'CLASS_PROMPTS'): |
| values[node.targets[0].id] = ast.literal_eval(node.value) |
| return [values['CLASS_PROMPTS'][c] for c in values['CLASS_ORDER']] |
|
|
|
|
| def check_against_packet(W, packet_path): |
| d = torch.load(packet_path, map_location='cpu', weights_only=False) |
| return float((d['z'].float() @ W.T - d['g'].float()).abs().max()) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description='Saves the class text embedding matrix W per dataset and encoder, checked against the stored class scores of the patch sets.') |
| ap.add_argument('--encoder', required=True, choices=list(TEXT_ENCODERS)) |
| ap.add_argument('--datasets', nargs='+', default=list(DATASETS), choices=list(DATASETS)) |
| ap.add_argument('--out-dir', default=str(ROOT / 'data/packets/text')) |
| ap.add_argument('--sets-dir', default=str(ROOT / 'data/packets/patch/sets')) |
| ap.add_argument('--arm', default=ARM, help='prompt arm, short for the patch encoders') |
| ap.add_argument('--phrases-from-builder', nargs='*', default=[], metavar='DATASET=BUILDER.py', help='slide encoders only: take the class phrases of a dataset from the CLASS_PROMPTS of the builder script that made its packet') |
| ap.add_argument('--scales-file', default=None, help='slide encoders only: scales.json that names the packet to check against') |
| ap.add_argument('--max-gap', type=float, default=1e-2, help='slide encoders only: write a file only when the gap to the packet scores is at most this') |
| ap.add_argument('--threads', type=int, default=4) |
| a = ap.parse_args() |
| torch.set_num_threads(a.threads) |
| out = Path(a.out_dir) |
| out.mkdir(parents=True, exist_ok=True) |
| if a.encoder in ENCODERS: |
| enc = ENCODERS[a.encoder]() |
| templates = TEMPLATES[a.encoder] |
| else: |
| enc = TEXT_ENCODERS[a.encoder]() |
| templates = json.load(open(ROOT / 'data/templates' / f'{a.encoder}.json'))['templates'] |
| for dataset in a.datasets: |
| source = dict(x.split('=', 1) for x in a.phrases_from_builder).get(dataset) |
| phrases = builder_phrases(source) if source else class_phrases(dataset, a.arm) |
| if a.encoder not in ENCODERS: |
| W = enc.class_matrix(phrases, templates) |
| packet = ROOT / json.load(open(a.scales_file))[dataset][a.encoder]['packet'] |
| gap = check_against_packet(W, packet) |
| print(f'{dataset} {a.encoder} arm {a.arm}: W {tuple(W.shape)} max gap to packet g {gap:.2e}', flush=True) |
| if gap > a.max_gap: |
| print(f'{dataset}: gap above {a.max_gap}, no file written', flush=True) |
| continue |
| torch.save({'W': W, 'temperature': float(enc.temperature), 'dataset': dataset, 'encoder': a.encoder, 'arm': a.arm if not source else 'builder', |
| 'phrases_source': source, 'class_phrases': phrases, 'templates': templates, 'packet': str(packet.name), 'max_gap_to_packet_g': gap}, |
| out / f'{dataset}--{a.encoder}.pt') |
| continue |
| W = torch.stack([pp.concept_embedding(enc, p, templates) for p in phrases]).float() |
| gap = check_against_set(W, dataset, a.encoder, a.sets_dir) |
| blob = {'W': W, 'temperature': float(enc.temperature), 'dataset': dataset, 'encoder': a.encoder, 'arm': a.arm, |
| 'n_templates': len(templates), 'class_phrases': phrases, 'max_gap_to_set_class_scores': gap} |
| torch.save(blob, out / f'{dataset}--{a.encoder}.pt') |
| print(f'{dataset} {a.encoder}: W {tuple(W.shape)} temperature {blob["temperature"]:.3f} max gap to stored class scores {gap}', flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
