Datasets:
File size: 8,344 Bytes
9379442 | 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 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 | """Build the legacy family, add a fixed SFT holdout, or export historical arms."""
from __future__ import annotations
import argparse
import hashlib
from collections import Counter, defaultdict
from pathlib import Path
import pyarrow as pa
import pyarrow.parquet as pq
from release_utils import (ROOT, export_rows, load_json, make_manifest, member_record,
normalized_prompt, write_json, write_parquet)
SPLIT_SEED = 20260907
CATEGORIES = ['math_number_theory', 'data_structure', 'dynamic_programming', 'greedy_search',
'implementation_simulation', 'graph', 'other_algorithm']
RAW_TO_FORMAL = {x: x for x in CATEGORIES + ['no_tags']}
RAW_TO_FORMAL.update({x: 'other_algorithm' for x in
['sorting', 'string', 'bit_manipulation', 'recursion_backtracking', 'geometry', 'other_tagged']})
def formal(value):
return RAW_TO_FORMAL.get(value, 'other_algorithm') if value else 'no_tags'
def choose_validation(rows, count=100):
"""Largest-remainder source/category allocation, hash-ranked unique prompts."""
multiplicity = Counter(normalized_prompt(r['prompt']) for r in rows)
strata = defaultdict(list)
full_counts = Counter((r['dataset'], r['primary_category']) for r in rows)
for row in rows:
if multiplicity[normalized_prompt(row['prompt'])] == 1:
strata[row['dataset'], row['primary_category']].append(row)
quotas = {key: count * n // len(rows) for key, n in full_counts.items()}
remaining = count - sum(quotas.values())
order = sorted(full_counts, key=lambda key: (-(count * full_counts[key] % len(rows)), key))
for key in order[:remaining]:
quotas[key] += 1
selected = []
for key in sorted(quotas):
if len(strata[key]) < quotas[key]:
raise ValueError(f'Insufficient unique prompts for stratum {key}')
ranked = sorted(strata[key], key=lambda r: hashlib.sha256(f'{SPLIT_SEED}:{r["id"]}'.encode()).hexdigest())
selected.extend(r['id'] for r in ranked[:quotas[key]])
assert len(selected) == count
return set(selected), {'seed': SPLIT_SEED, 'rows': count,
'method': 'source/category largest remainder; SHA256(seed:id) rank; unique prompts only',
'strata': {'::'.join(k): v for k, v in sorted(quotas.items())}}
def build(source, root):
rows = pq.read_table(source / 'sft_original.parquet').to_pylist()
if len(rows) != 21879 or len({r['id'] for r in rows}) != 21879:
raise ValueError('Expected the original 21,879 distinct SFT rows')
for row in rows:
row['raw_primary_category'] = row['primary_category']
row['raw_overlap_categories'] = row['overlap_categories']
row['primary_category'] = formal(row['primary_category'])
row['overlap_categories'] = sorted({formal(x) for x in
(row['raw_overlap_categories'] or [row['raw_primary_category']])})
selected, policy = choose_validation(rows)
full_table = pa.Table.from_pylist(rows)
full_table = full_table.append_column('problem_id', full_table['id'])
full_table = full_table.append_column('response', full_table['answer'])
full_table = full_table.append_column('source_row_index', pa.array(range(len(rows)), type=pa.int32()))
for split in ['train', 'validation']:
indices = [i for i, r in enumerate(rows) if (r['id'] in selected) == (split == 'validation')]
write_parquet(root / 'data/taco_leetcode/sft' / (split + '.parquet'), full_table.take(pa.array(indices)))
categories = load_json(source / 'category_index.json')
rl_ids = {}
for split in ['train', 'validation']:
table = pq.read_table(source / ('rl_' + split + '.parquet'))
infos = table['extra_info'].to_pylist()
ids = [info['problem_id'] for info in infos]
rl_ids[split] = ids
if not set(ids) <= categories.keys():
raise ValueError('Missing original RL category index')
# Retain model names and counts, without machine-specific filesystem paths.
for info in infos:
token_counts = info.get('prompt_tokens_by_model')
if token_counts:
info['prompt_tokens_by_model'] = {Path(k).name: v for k, v in token_counts.items()}
table = table.set_column(table.schema.get_field_index('extra_info'), 'extra_info', pa.array(infos))
table = table.append_column('problem_id', pa.array(ids))
table = table.append_column('primary_category', pa.array([formal(categories[x]['primary_category']) for x in ids]))
table = table.append_column('overlap_categories', pa.array([
sorted({formal(v) for v in (categories[x]['overlap_categories'] or [categories[x]['primary_category']])})
for x in ids], type=pa.list_(pa.string())))
write_parquet(root / 'data/taco_leetcode/rl' / (split + '.parquet'), table)
recorded = load_json(source / 'memberships.json')
membership = {'version': '1.0.0', 'sft_historical': {}, 'sft_release': {}, 'rl_historical': {},
'sft_rule': 'Frozen original arms, followed by removal of the new SFT holdout for release arms.',
'rl_rule': 'Remove every intersecting overlap category; frozen seed-20260610 12,168-row samples.',
'split_seed': SPLIT_SEED, 'validation_ids': sorted(selected)}
for arm, ids in recorded['sft'].items():
removed = arm[3:] if arm.startswith('no_') else None
membership['sft_historical'][arm] = member_record(ids, removed)
membership['sft_release'][arm] = member_record([x for x in ids if x not in selected], removed)
membership['rl_historical']['full_dapo'] = member_record(rl_ids['train'])
for arm, ids in recorded['rl'].items():
membership['rl_historical'][arm] = member_record(ids, arm[3:] if arm.startswith('no_') else None)
metadata = root / 'metadata/taco_leetcode'
write_json(metadata / 'ablation_membership.json', membership, compact=True)
write_json(metadata / 'taxonomy.json', {'name': 'taco_leetcode_legacy_7', 'version': '1.0.0',
'categories': CATEGORIES, 'unlabeled_value': 'no_tags', 'raw_to_formal': RAW_TO_FORMAL,
'ablation_rule': 'Remove any row whose overlap_categories contains the selected category.'})
policy['origin'] = 'Added for this release; not the historical experiment validation set.'
policy['historical_sft_rows'] = 21879
policy['historical_rl_validation_overlap_with_original_sft_train'] = len(set(rl_ids['validation']) & {r['id'] for r in rows})
make_manifest(root, 'taco_leetcode', {'sft': policy, 'rl': 'Original 17,249 train + 100 validation'})
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--source', type=Path, help='Frozen source export directory')
parser.add_argument('--root', type=Path, default=ROOT)
parser.add_argument('--arm')
parser.add_argument('--kind', choices=['sft', 'rl'], default='sft')
parser.add_argument('--historical', action='store_true', help='Restore original SFT membership including the new holdout')
parser.add_argument('--output', type=Path)
args = parser.parse_args()
if args.arm:
if args.output is None:
parser.error('--output is required with --arm')
members = load_json(args.root / 'metadata/taco_leetcode/ablation_membership.json')
kind = 'rl_historical' if args.kind == 'rl' else 'sft_historical' if args.historical else 'sft_release'
table = pq.read_table(args.root / 'data/taco_leetcode' / args.kind / 'train.parquet')
if args.kind == 'sft' and args.historical:
table = pa.concat_tables([table, pq.read_table(args.root / 'data/taco_leetcode/sft/validation.parquet')])
table = table.set_column(table.schema.get_field_index('primary_category'), 'primary_category', table['raw_primary_category'])
table = table.set_column(table.schema.get_field_index('overlap_categories'), 'overlap_categories', table['raw_overlap_categories'])
export_rows(table, members[kind][args.arm]['problem_ids'], args.output)
elif args.source:
build(args.source, args.root)
else:
parser.error('Use --source to build or --arm NAME --output FILE to export.')
if __name__ == '__main__':
main()
|