| from collections import defaultdict |
| from dataclasses import dataclass |
| import gzip |
| import json |
| from pathlib import Path |
| import random |
|
|
| from omegaconf import OmegaConf |
| from rich import print |
| import torch |
| from tqdm import tqdm |
|
|
| from tiny_rl.sampling import load_model |
| from refined_v4.study import read, write |
| from .data import ROOT, small_final_calculation |
| from .envs import ENC, make_episode |
|
|
|
|
| @dataclass |
| class Config: |
| root: str = str(ROOT / 'pilot-2m') |
| model: str = '8m' |
| per_band: int = 16 |
| batch: int = 4 |
| threads: int = 2 |
| device: str = 'cpu' |
| shots: int = 2 |
| checkpoint: str = '' |
| comparison: str = '' |
| task: str = '' |
| label: str = 'default' |
| small_final_only: bool = False |
| split: str = '' |
| difficulty: str = '' |
| output: str = '' |
|
|
|
|
| def rows(path: Path): |
| with gzip.open(path, 'rt') as stream: |
| return [json.loads(line) for line in stream] |
|
|
|
|
| @torch.inference_mode() |
| def probe(config: Config): |
| torch.set_num_threads(config.threads) |
| base = next(row['checkpoint'] for row in read(ROOT / 'pilot-2m/plan.json')['models'] if row['name'] == config.model) |
| selections = [] |
| pilot = Path(config.root) |
| if config.split not in ('', 'sft', 'dev'): |
| raise ValueError('Answer probes use only SFT or development sources') |
| tasks = (config.task,) if config.task else ('arithmetic', 'arithmetic_simple') |
| for task in tasks: |
| demonstrations = rows(pilot / 'data' / task / 'rl.jsonl.gz')[0]['demonstrations'] |
| demo_groups = {row['group'] for row in demonstrations} |
| for split in ([config.split] if config.split else ('sft', 'dev')): |
| bands = defaultdict(list) |
| for row in rows(pilot / 'data' / task / (split + '.jsonl.gz')): |
| if config.small_final_only and not small_final_calculation(dict(steps=row['provenance']['equations'])): |
| continue |
| if row['group'] not in demo_groups: |
| bands[row['provenance']['difficulty']].append(row) |
| for band, values in bands.items(): |
| if config.difficulty and band != config.difficulty: |
| continue |
| selected = random.Random(f'probe/{task}/{split}/{band}').sample(values, min(config.per_band, len(values))) |
| for row in selected: |
| row = dict(row, demonstrations=demonstrations[:config.shots]) |
| selections.append((task, split, band, make_episode(row, 1))) |
| checkpoints = [('base', None, base)] |
| for task in tasks: |
| p = pilot / 'runs' / config.model / task / 'sft.pt' |
| if p.exists(): |
| checkpoints.append(('conditioned-relative', task, str(p))) |
| for optimizer in ('adamw', 'relative'): |
| p = ROOT / 'iterations/optim-v1/runs' / ('native-' + optimizer) / config.model / task / 'sft.pt' |
| if p.exists(): |
| checkpoints.append(('native-' + optimizer, task, str(p))) |
| if config.checkpoint: |
| checkpoints = [(config.label, config.task or None, config.checkpoint)] |
| if config.comparison: |
| checkpoints.append(('matched-unweighted', config.task or None, config.comparison)) |
| records = [] |
| for recipe, selected_task, checkpoint in checkpoints: |
| model, metadata = load_model(checkpoint, config.device) |
| request = Path(checkpoint).parent / 'request.json' |
| seen = None |
| if request.exists(): |
| settings = read(request)['config'] |
| corpus = Path(settings['root']) / 'sft' / settings['task'] / 'train.jsonl.gz' |
| seen = {example['group'] for document in rows(corpus) for example in document['examples']} |
| selected = [row for row in selections if selected_task is None or row[0] == selected_task] |
| for offset in tqdm(range(0, len(selected), config.batch), desc=f'{config.model}/{recipe}', colour='cyan', mininterval=10): |
| group = selected[offset:offset + config.batch] |
| width = max(len(row[3].prompt_ids) for row in group) |
| inputs = torch.full((len(group), width), ENC.eot_token, device=config.device, dtype=torch.long) |
| for index, row in enumerate(group): |
| inputs[index, :len(row[3].prompt_ids)] = torch.tensor(row[3].prompt_ids, device=config.device) |
| hidden = model._trunk(inputs) |
| logits = model.lm_head(torch.stack([hidden[index, len(row[3].prompt_ids) - 1] for index, row in enumerate(group)]))[:, :ENC.n_vocab].float() |
| logps = logits.log_softmax(-1) |
| for index, (task, split, band, item) in enumerate(group): |
| target = item.completion_ids[0] |
| predicted = int(logits[index].argmax()) |
| top = logits[index].topk(5).indices.tolist() |
| records.append(dict(recipe=recipe, model=config.model, task=task, split=split, difficulty=band, |
| source_id=item.source_id, p_gold=float(logps[index, target].exp()), |
| seen_in_checkpoint_sft=item.group in seen if seen is not None else None, |
| gold_rank=int((logits[index] > logits[index, target]).sum()) + 1, |
| context_tokens=len(item.prompt_ids), |
| greedy=predicted == target, gold=item.completion, |
| top5=[ENC.decode([token]) for token in top], prompt=item.prompt)) |
| del model |
| groups = defaultdict(list) |
| for record in records: |
| groups[(record['recipe'], record['task'], record['split'], record['difficulty'])].append(record) |
| summary = [dict(recipe=key[0], task=key[1], split=key[2], difficulty=key[3], queries=len(values), |
| p_gold=sum(v['p_gold'] for v in values) / len(values), |
| greedy=sum(v['greedy'] for v in values) / len(values)) for key, values in groups.items()] |
| for row in summary: |
| selected = groups[(row['recipe'], row['task'], row['split'], row['difficulty'])] |
| row['seen_in_checkpoint_sft'] = sum(value['seen_in_checkpoint_sft'] is True for value in selected) |
| output = (Path(config.output) if config.output else |
| ROOT / f'report-cache/answer-probe-{config.model}-{config.label}-shots{config.shots}.json') |
| write(output, dict(summary=summary, records=records)) |
| for row in summary: |
| print(row) |
|
|
|
|
| if __name__ == '__main__': |
| probe(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config), OmegaConf.from_cli()))) |
|
|
