| """Reasoning-step segmentation and exact character -> token alignment. |
| |
| A response is partitioned into contiguous segments that cover every character: |
| segment 0..T-1 : reasoning steps (any preamble before "Step 1:" is merged into the first step) |
| segment T : the terminal segment (the "Final answer:" line and anything after it) |
| Steps are delimited by "Step k:" markers (as in skill_dynamics.scoring.segment). When a |
| response has no markers, paragraphs separated by blank lines are used instead and |
| `marker_found` is False, so the fallback rate can be monitored. |
| """ |
|
|
| import re |
| from dataclasses import dataclass, field |
|
|
| |
| |
| _OPEN = r"^[ \t]*(?:[-+>][ \t]*)?(?:#{1,6}[ \t]*)?(?:\*{1,2}|_{1,2})?[ \t]*" |
| _EMPH = r"[ \t]*(?:\*{1,2}|_{1,2})?[ \t]*" |
| STEP_RE = re.compile(r"(?im)" + _OPEN + r"Step[ \t]+(\d+)" + _EMPH + r"[:.](?:[ \t]*(?:\*{1,2}|_{1,2}))?") |
| FINAL_PREFIX = _OPEN + r"(?:Step[ \t]+\d+" + _EMPH + r"[:.]" + _EMPH + r")?Final answer" + _EMPH + r":" |
| FINAL_RE = re.compile(r"(?im)" + FINAL_PREFIX) |
|
|
|
|
| @dataclass |
| class Segmentation: |
| text: str |
| steps: list = field(default_factory=list) |
| final_start: int = 0 |
| marker_found: bool = True |
| content_start: int = 0 |
| content_token: int = 0 |
|
|
| @property |
| def num_steps(self): |
| return len(self.steps) |
|
|
| def step_texts(self): |
| return [self.text[a:b] for a, b in self.steps] |
|
|
| def bounds(self): |
| """Segment boundaries: steps then the terminal segment, covering the whole text.""" |
| return [*self.steps, (self.final_start, len(self.text))] |
|
|
|
|
| def segment(text): |
| final = None |
| for match in FINAL_RE.finditer(text): |
| final = match |
| stop = final.start() if final else len(text) |
| body = text[:stop] |
| marks = [m for m in STEP_RE.finditer(body)] |
| starts = [] |
| for m in marks: |
| if not starts or m.start() > starts[-1]: |
| starts.append(m.start()) |
| marker_found = bool(starts) |
| if not marker_found: |
| |
| starts = [len(body[:m.start()].rstrip(" \t")) for m in re.finditer(r"(?s)\S.*?(?=\n[ \t]*\n|\Z)", body)] |
| |
| bounds = [] |
| for i, start in enumerate(starts): |
| end = starts[i + 1] if i + 1 < len(starts) else stop |
| if body[start:end].strip(): |
| bounds.append([start, end]) |
| content_start = bounds[0][0] if bounds else 0 |
| if bounds: |
| bounds[0][0] = 0 |
| bounds[-1][1] = stop |
| return Segmentation(text=text, steps=[tuple(b) for b in bounds], final_start=stop if bounds else 0, |
| marker_found=marker_found, content_start=content_start) |
|
|
|
|
| def _byte_decoder(): |
| |
| bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1)) |
| cs = bs[:] |
| n = 0 |
| for b in range(256): |
| if b not in bs: |
| bs.append(b) |
| cs.append(256 + n) |
| n += 1 |
| return {chr(c): b for b, c in zip(bs, cs)} |
|
|
|
|
| _BYTE_DECODER = _byte_decoder() |
|
|
|
|
| def token_char_offsets(tokenizer, ids): |
| """Character offset of each token boundary in decode(ids, skip_special_tokens=True, |
| clean_up_tokenization_spaces=False). Returns (text, offsets) with len(offsets) == len(ids)+1.""" |
| text = tokenizer.decode(ids, skip_special_tokens=True, clean_up_tokenization_spaces=False) |
| special = set(getattr(tokenizer, "all_special_ids", []) or []) |
| pieces = tokenizer.convert_ids_to_tokens(list(ids)) |
| try: |
| byte_lens = [] |
| for tid, piece in zip(ids, pieces): |
| if tid in special or piece is None: |
| byte_lens.append(0) |
| else: |
| byte_lens.append(len(bytes(_BYTE_DECODER[ch] for ch in piece))) |
| data = text.encode("utf-8") |
| if sum(byte_lens) != len(data): |
| raise ValueError("byte-level reconstruction mismatch") |
| |
| |
| char_at_byte = [0] * (len(data) + 1) |
| pos = 0 |
| for ci, ch in enumerate(text): |
| width = len(ch.encode("utf-8")) |
| for k in range(width): |
| char_at_byte[pos + k] = ci if k == 0 else ci + 1 |
| pos += width |
| char_at_byte[len(data)] = len(text) |
| offsets, acc = [0], 0 |
| for length in byte_lens: |
| acc += length |
| offsets.append(char_at_byte[acc]) |
| return text, offsets |
| except (KeyError, ValueError): |
| offsets = [len(tokenizer.decode(ids[:i], skip_special_tokens=True, clean_up_tokenization_spaces=False)) |
| for i in range(len(ids) + 1)] |
| return text, offsets |
|
|
|
|
| def char_spans_to_token_spans(offsets, char_spans): |
| """Map contiguous character spans to contiguous token spans [t0, t1). A token belongs to the |
| span containing its first character; spans that receive no token are returned empty.""" |
| import bisect |
| n_tokens = len(offsets) - 1 |
| starts = [offsets[i] for i in range(n_tokens)] |
| out = [] |
| for a, b in char_spans: |
| t0 = bisect.bisect_left(starts, a) |
| t1 = bisect.bisect_left(starts, b) |
| out.append((t0, t1)) |
| return out |
|
|
|
|
| def response_segments(tokenizer, ids): |
| """Segmentation of a generated response plus token spans for every segment (steps + terminal). |
| Tokens are assigned in order, so spans tile [0, len(ids)) exactly. Also returns the token index |
| where reasoning content starts (first step marker), used by the spectral features.""" |
| text, offsets = token_char_offsets(tokenizer, ids) |
| seg = segment(text) |
| spans = char_spans_to_token_spans(offsets, seg.bounds()) |
| if spans: |
| spans[-1] = (spans[-1][0], len(ids)) |
| spans = [(spans[i][0], spans[i + 1][0]) for i in range(len(spans) - 1)] + [spans[-1]] |
| if spans[0][0] != 0: |
| spans[0] = (0, spans[0][1]) |
| content_tok = char_spans_to_token_spans(offsets, [(seg.content_start, seg.content_start)])[0][0] |
| if seg.num_steps: |
| content_tok = min(content_tok, max(spans[0][1] - 1, 0)) |
| seg.content_token = content_tok |
| return seg, spans |
|
|
