File size: 6,197 Bytes
8f79f59 | 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 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 | from collections import Counter
from dataclasses import dataclass
from functools import lru_cache
import gzip
import json
from pathlib import Path
import random
from omegaconf import OmegaConf
from rich import print
from tqdm import tqdm
from refined_v4.data import atomic_json, signature
from . import data, envs
@dataclass
class Config:
root: str = str(data.ROOT)
tokenizer_samples: int = 256
sampler_draws: int = 16000
def rows(path: Path):
with gzip.open(path, 'rt') as stream:
for line in stream:
yield json.loads(line)
def audit(config: Config):
root = Path(config.root)
sources, source_audit = data.base_sources(data.Config(root=str(root)))
styles = json.loads((root / 'styles.json').read_text())['styles']
results = dict(revision=data.REVISION, source_exclusions=len(source_audit['exclusions']), stages={})
for stage, budget in (('', 16777216), ('pilot-2m', 2097152)):
folder = root / stage
task_results = {}
for task in data.TASKS:
manifest = json.loads((folder / 'data' / task / 'manifest.json').read_text())
groups = {}
folds = {}
for split in data.SPLITS:
path = folder / manifest['splits'][split]['path']
assert signature(path) == manifest['splits'][split]['sha256'], (task, split, 'checksum')
folds[split] = list(rows(path))
groups[split] = {row['group'] for row in folds[split]}
assert len(groups[split]) == len(folds[split]), (task, split, 'duplicate source')
for index, left in enumerate(data.SPLITS):
for right in data.SPLITS[index + 1:]:
assert groups[left].isdisjoint(groups[right]), (task, left, right, 'leakage')
by_id = {source['source_id']: source for source in sources[task]['sft']}
@lru_cache(maxsize=200000)
def expected(identity: str, style_id: int):
source = by_id[identity]
assert source['group'] in groups['sft'], (task, identity, 'non-SFT source')
style = data.DEFAULT_STYLE if style_id == -1 else styles[style_id]
row = data.make_row(task, source, style, style_id, include_hints=False)
return envs.render(row), dict(source_id=identity, group=row['group'],
reference_sha256=data.digest(row['reference']), difficulty=source['difficulty'], style_id=style_id)
sft = json.loads((folder / 'sft' / task / 'manifest.json').read_text())
path = folder / sft['path']
assert signature(path) == sft['sha256'], (task, 'SFT checksum')
rng = random.Random(f'audit/{stage}/{task}')
samples = set(rng.sample(range(sft['documents']), min(config.tokenizer_samples, sft['documents'])))
budget_tokens = 0
documents = 0
examples = 0
bands = Counter()
for index, document in enumerate(tqdm(rows(path), total=sft['documents'],
desc=f'Audit {stage or "full"}/{task}', colour='cyan', mininterval=10)):
declared = document['examples']
assert 2 <= len(declared) <= 4
assert len({row['group'] for row in declared}) == len(declared)
rendered = [expected(row['source_id'], row['style_id']) for row in declared]
assert declared == [value[1] for value in rendered], (task, index, 'metadata')
assert document['text'] == '\n\n'.join(value[0] for value in rendered), (task, index, 'source mismatch')
assert 0 < document['budget_tokens'] <= document['tokens'] <= 1024
if index in samples or index == sft['documents'] - 1:
assert len(envs.ENC.encode_ordinary(document['text'])) == document['tokens']
if index == 0:
demos = folds['rl'][0]['demonstrations']
assert [row['group'] for row in declared[:2]] == [row['group'] for row in demos]
if index < sft['documents'] - 1:
assert document['budget_tokens'] == document['tokens']
budget_tokens += document['budget_tokens']
documents += 1
examples += len(declared)
bands.update(row['difficulty'] for row in declared)
assert budget_tokens == sft['training_token_budget'] == budget
assert documents == sft['documents'] and examples == sft['examples']
assert dict(bands) == sft['difficulty_counts']
pool = envs.Pool(folds['rl'])
hints = Counter(pool.sample(rng).hint_level for _ in range(config.sampler_draws))
expected_count = config.sampler_draws / 16
assert all(abs(hints[level] - expected_count) < max(10, expected_count * .2) for level in range(1, 17))
panel = envs.fixed_panel(folds['test'], 64, 2718)
assert Counter(level for row, level in panel) == {level: 4 for level in range(1, 17)}
for row, level in panel:
item = envs.make_episode(row, level)
assert envs.reward(item, item.completion) == 1.
task_results[task] = dict(tokens=budget_tokens, documents=documents, examples=examples,
source_reconstruction='Every SFT document exactly matches its immutable source and declared style',
tokenized_documents=len(samples | {sft['documents'] - 1}),
split_counts={split: len(values) for split, values in folds.items()},
source_splits_disjoint=True, difficulty_counts=dict(bands),
sampled_hint_counts=dict(hints), fixed_panel_gold_passes=64,
sft_sha256=sft['sha256'])
print(f'[green]{stage or "full"}/{task}: {budget_tokens:,} tokens; every document reconstructed[/green]')
results['stages'][stage or 'full'] = task_results
atomic_json(root / 'report-cache/data-audit.json', results)
return results
if __name__ == '__main__':
audit(OmegaConf.to_object(OmegaConf.merge(OmegaConf.structured(Config), OmegaConf.from_cli())))
|