File size: 4,818 Bytes
b4975b4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 | 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):
# Reads CLASS_ORDER and CLASS_PROMPTS from a packet builder script without running it.
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()
|