| from dataclasses import replace |
| import hashlib |
| import math |
| import random |
|
|
| from functional_rl import v2 |
|
|
| from . import REVISION |
|
|
| TASKS = ('gsm8k', 'partial_gsm8k', 'arithmetic', 'arithmetic_simple') |
| ENC = v2.ENC |
| WEIGHTS = dict(tiny_addsub=40, small_addsub=30, multiplication=15, two_step=15, |
| easy=40, standard=45, hard=15) |
|
|
|
|
| def header(row: dict) -> str: |
| return 'Question: ' + row['question'] + '\n' |
|
|
|
|
| def render(row: dict) -> str: |
| return header(row) + row['reference'] |
|
|
|
|
| def construct(row: dict, level: int, demonstrations: tuple[dict, ...]): |
| if type(level) is not int or not 1 <= level <= 16: |
| raise ValueError('Hint length must be an integer in [1, 16]') |
| if row['task'] not in TASKS: |
| raise ValueError('Unknown math task') |
| groups = {row['group']} |
| for demo in demonstrations: |
| if demo['task'] != row['task'] or demo['group'] in groups: |
| raise ValueError('Demonstrations must use distinct same-task source groups') |
| groups.add(demo['group']) |
| context = ''.join(render(demo).rstrip() + '\n\n' for demo in demonstrations) |
| document_header = context + header(row) |
| document = document_header + row['reference'] |
| ids = ENC.encode_ordinary(document) |
| if len(ids) > 1024: |
| raise ValueError('Math episode exceeds the model context') |
| prompt_ids, completion_ids = ids[:-level], ids[-level:] |
| prompt, completion = ENC.decode(prompt_ids), ENC.decode(completion_ids) |
| protected = 'Reasoning:' if row['task'] in ('gsm8k', 'arithmetic') else 'Answer:' |
| if (len(completion_ids) != level or not prompt.startswith(document_header + protected) |
| or prompt + completion != document or '\ufffd' in prompt + completion): |
| raise ValueError('Requested hint removes protected task context') |
| return v2.Episode(row['task'], row['source_id'], row['group'], level, |
| prompt, completion, tuple(prompt_ids), tuple(completion_ids), |
| prompt[len(document_header):], row['reference'], row['answer'], (), '', |
| version=REVISION, question=row['question'], provenance=row.get('provenance', {}), |
| demonstrations=tuple(dict(task=d['task'], source_id=d['source_id'], group=d['group'], |
| text=render(d), split='sft') for d in demonstrations)) |
|
|
|
|
| def available_hints(row: dict) -> tuple[int, ...]: |
| if 'hint_levels' in row: |
| return tuple(row['hint_levels']) |
| result = [] |
| for level in range(1, 17): |
| try: |
| construct(row, level, ()) |
| result.append(level) |
| except ValueError: |
| pass |
| return tuple(result) |
|
|
|
|
| def make_episode(row: dict, level: int): |
| return construct(row, level, tuple(row.get('demonstrations', ()))) |
|
|
|
|
| def reward(item, completion: str, judge=None) -> float: |
| return v2.reward(item, completion, judge) |
|
|
|
|
| class Pool: |
| def __init__(self, rows: list[dict]): |
| self.rows = rows |
| self.weights = dict(WEIGHTS) |
| declared = {} |
| for row in rows: |
| band = row['provenance']['difficulty'] |
| weight = row['provenance'].get('problem_sampling_weight') |
| if weight is not None: |
| if not math.isfinite(weight) or weight <= 0: |
| raise ValueError('Problem sampling weights must be positive and finite') |
| if band in declared and declared[band] != weight: |
| raise ValueError('Inconsistent sampling weights within a difficulty band') |
| declared[band] = weight |
| self.weights.update(declared) |
| self.by_hint = {level: [row for row in rows if level in available_hints(row)] |
| for level in range(1, 17)} |
| if any(not rows for rows in self.by_hint.values()): |
| raise ValueError('Every hint length needs eligible questions') |
| self.by_band = {level: {} for level in range(1, 17)} |
| for level, selected in self.by_hint.items(): |
| for row in selected: |
| self.by_band[level].setdefault(row['provenance']['difficulty'], []).append(row) |
|
|
| def sample(self, rng: random.Random): |
| level = rng.randint(1, 16) |
| bands = list(self.by_band[level]) |
| band = rng.choices(bands, [self.weights[name] for name in bands])[0] |
| return make_episode(rng.choice(self.by_band[level][band]), level) |
|
|
|
|
| def fixed_panel(rows: list[dict], queries: int, seed: int): |
| if queries < 16 or queries % 16: |
| raise ValueError('Evaluation size must be a positive multiple of 16') |
| pool = Pool(rows) |
| result, used, pairs = [], set(), set() |
| for index in range(queries): |
| level = index % 16 + 1 |
| candidates = sorted(pool.by_hint[level], key=lambda row: hashlib.sha256( |
| f'{seed}/{level}/{row["group"]}'.encode()).hexdigest()) |
| bands = sorted(pool.by_band[level]) |
| band = bands[(index // 16) % len(bands)] |
| preferred = [row for row in candidates if row['provenance']['difficulty'] == band] |
| candidates = preferred + [row for row in candidates if row['provenance']['difficulty'] != band] |
| fresh = [row for row in candidates if row['group'] not in used] |
| eligible = [row for row in candidates if (row['group'], level) not in pairs] |
| if not eligible: |
| raise ValueError('Insufficient unique source/hint evaluation pairs') |
| row = (fresh or eligible)[0] |
| used.add(row['group']) |
| pairs.add((row['group'], level)) |
| result.append((row, level)) |
| return result |
|
|
|
|
| def stratified_panel(rows: list[dict], queries: int, seed: int): |
| if queries < 16 or queries % 16: |
| raise ValueError('Evaluation size must be a positive multiple of 16') |
| pool = Pool(rows) |
| result, used, pairs = [], set(), set() |
| for index in range(queries): |
| level = index % 16 + 1 |
| bands = sorted(pool.by_band[level]) |
| band = bands[(index // 16) % len(bands)] |
| candidates = sorted(pool.by_band[level][band], key=lambda row: hashlib.sha256( |
| f'{seed}/{level}/{row["group"]}'.encode()).hexdigest()) |
| eligible = [row for row in candidates if (row['group'], level) not in pairs] |
| if not eligible: |
| raise ValueError(f'Insufficient unique {band}/hint-{level} evaluation pairs') |
| fresh = [row for row in eligible if row['group'] not in used] |
| row = (fresh or eligible)[0] |
| used.add(row['group']) |
| pairs.add((row['group'], level)) |
| result.append((row, level)) |
| return result |
|
|
