| from bisect import bisect_left, bisect_right |
| from dataclasses import dataclass |
| from pathlib import Path |
| import re |
|
|
| import numpy as np |
| import torch |
|
|
| from refined_v4.train import TokenCorpus |
| from refined_v4.train_policy import Example, replay as ordinary_replay |
| from refined_v4.study import write |
| from .envs import ENC |
|
|
|
|
| @dataclass |
| class WeightedExample(Example): |
| weights: list[float] |
|
|
|
|
| def context_examples(corpus, start: int, count: int, weighted: bool): |
| if not 0 <= start < corpus.tokens or start + count > corpus.tokens or count < 1: |
| raise ValueError('SFT slice exceeds the declared budget') |
| result = [] |
| remaining = count |
| index = bisect_right(corpus.ends, start) |
| while remaining: |
| beginning = corpus.ends[index - 1] if index else 0 |
| offset = start - beginning |
| size = min(remaining, corpus.ends[index] - start) |
| sequence = corpus.documents[index][:offset + size + 1].astype(np.int64).tolist() |
| mask = [0] * (offset + 1) + [1] * size |
| if weighted: |
| result.append(WeightedExample(sequence, mask, corpus.weights[index][:len(sequence)].tolist())) |
| else: |
| result.append(Example(sequence, mask)) |
| start += size |
| remaining -= size |
| index += 1 |
| return result |
|
|
|
|
| class ContextCorpus(TokenCorpus): |
| def take(self, start: int, count: int): |
| return context_examples(self, start, count, False) |
|
|
|
|
| def answer_weights(ids: list[int], factor: float): |
| text = ENC.decode(ids[:-1] if ids[-1] == ENC.eot_token else ids) |
| sizes = [len(ENC.decode_single_token_bytes(token)) for token in ids] |
| ends = np.cumsum(sizes).tolist() |
| starts = [0] + ends[:-1] |
| weights = np.ones(len(ids), dtype=np.float32) |
| for match in re.finditer(r'(?m)^(?:Answer: |So, the answer is )[^\n]+', text): |
| line = match.group() |
| answer = line.rsplit(' = ', 1)[-1] if ' = ' in line else line.removeprefix('Answer: ') |
| if re.fullmatch(r'[+-]?\d+(?:[./]\d+)?', answer.strip()) is None: |
| continue |
| start = len(text[:match.end() - len(answer)].encode()) |
| end = len(text[:match.end()].encode()) |
| weights[bisect_right(ends, start):bisect_left(starts, end)] = factor |
| return weights |
|
|
|
|
| def assistant_roles(ids: list[int]): |
| text = ENC.decode(ids[:-1] if ids[-1] == ENC.eot_token else ids) |
| ends = np.cumsum([len(ENC.decode_single_token_bytes(token)) for token in ids]).tolist() |
| starts = [0] + ends[:-1] |
| questions = [match.start() for match in re.finditer(r'(?m)^Question:', text)] |
| roles = np.zeros(len(ids), dtype=bool) |
| for match in re.finditer(r'(?m)^(?:Reasoning:|Answer:)', text): |
| following = bisect_right(questions, match.start()) |
| end = questions[following] if following < len(questions) else len(text) |
| first_byte = len(text[:match.start()].encode()) |
| last_byte = len(text[:end].encode()) |
| roles[bisect_right(ends, first_byte):bisect_left(starts, last_byte)] = True |
| if ids[-1] == ENC.eot_token: |
| roles[-1] = True |
| return roles |
|
|
|
|
| class AnswerCorpus(TokenCorpus): |
| answer_weight: float = 32. |
| report_path: str = '' |
| preserve_context: bool = False |
| question_weight: float = 1. |
|
|
| def __init__(self, path: Path, budget: int): |
| super().__init__(path, budget) |
| self.weights = [] |
| answer_tokens = 0 |
| question_tokens = 0 |
| previous = 0 |
| for ids, end in zip(self.documents, self.ends, strict=True): |
| count = end - previous |
| previous = end |
| tokens = ids.tolist() |
| roles = assistant_roles(tokens) |
| question_tokens += int((~roles[1:count + 1]).sum()) |
| weights = answer_weights(tokens, self.answer_weight) * np.where(roles, 1., self.question_weight) |
| answer_tokens += int((answer_weights(tokens, 2.)[1:count + 1] > 1).sum()) |
| weights *= count / float(weights[1:count + 1].sum()) |
| self.weights.append(weights) |
| if self.report_path: |
| write(Path(self.report_path), dict(prediction_tokens=budget, answer_tokens=answer_tokens, |
| question_tokens=question_tokens, question_weight=self.question_weight, |
| answer_weight=self.answer_weight, objective='Every prediction remains supervised; weight Question and final numeric answer tokens explicitly, normalized to mean one per document.')) |
|
|
| def take(self, start: int, count: int): |
| if self.preserve_context: |
| return context_examples(self, start, count, True) |
| if not 0 <= start < self.tokens or start + count > self.tokens or count < 1: |
| raise ValueError('SFT slice exceeds the declared budget') |
| result = [] |
| remaining = count |
| index = bisect_right(self.ends, start) |
| while remaining: |
| beginning = self.ends[index - 1] if index else 0 |
| offset = start - beginning |
| size = min(remaining, self.ends[index] - start) |
| sequence = self.documents[index][offset:offset + size + 1].astype(np.int64).tolist() |
| weights = self.weights[index][offset:offset + size + 1].tolist() |
| result.append(WeightedExample(sequence, [0] + [1] * size, weights)) |
| start += size |
| remaining -= size |
| index += 1 |
| return result |
|
|
|
|
| def replay(model, examples: list[Example], amp: bool = False): |
| probabilities, count = ordinary_replay(model, examples, amp) |
| if not count: |
| return probabilities,count |
| result = [] |
| for row, values in zip(examples, probabilities, strict=True): |
| if isinstance(row, WeightedExample): |
| weights = [row.weights[index] for index in range(1, len(row.sequence)) if row.mask[index]] |
| values = values * torch.tensor(weights, device=values.device) |
| result.append(values) |
| return result, count |
|
|
