Datasets:
Download src/rolloutengine/closure_scoring.py from open-athena/Structure-Closure-BFCL-v6: direct link, hf CLI and curl.
- Browser
- Download file 6.39 kB
-
https://huggingface.co/datasets/open-athena/Structure-Closure-BFCL-v6/resolve/main/src/rolloutengine/closure_scoring.py
- Command line
-
hf download hf://datasets/open-athena/Structure-Closure-BFCL-v6/src/rolloutengine/closure_scoring.py
-
curl -L -o closure_scoring.py https://huggingface.co/datasets/open-athena/Structure-Closure-BFCL-v6/resolve/main/src/rolloutengine/closure_scoring.py
6.39 kB
| # Copyright The Marin Authors | |
| # SPDX-License-Identifier: Apache-2.0 | |
| """Content-preserving scoring for explicitly required structure completion.""" | |
| import json | |
| from dataclasses import dataclass | |
| from enum import StrEnum | |
| from rolloutengine.structure_closure import ( | |
| ClosureState, | |
| PrefixStatus, | |
| delimited_json_closure_state, | |
| json_closure_state, | |
| paired_marker_closure_state, | |
| required_code_fence_state, | |
| ) | |
| from rolloutengine.tool_protocol import JSON_WHITESPACE, THINK_CLOSE, THINK_OPEN, TOOL_CLOSE, TOOL_OPEN | |
| SNOWBALL_TURN_END_MARKERS = ("<|eot_id|>", "<|end_of_text|>") | |
| CLOSURE_REGION_SCORER = "closure_region_v1" | |
| def closure_response_content(text: str, *, stop_reason: str) -> str: | |
| """Remove one terminal Snowball control marker from a normally stopped turn. | |
| Interior markers, repeated terminal markers, and truncated generations remain | |
| subject to structural validation. Tool and reasoning closers are content. | |
| """ | |
| if stop_reason == "stop": | |
| for marker in SNOWBALL_TURN_END_MARKERS: | |
| if text.endswith(marker): | |
| return text[: -len(marker)] | |
| return text | |
| class ClosureFormat(StrEnum): | |
| """Supported wire formats; tool and reasoning use Hermes and Snowball markers.""" | |
| JSON = "json" | |
| TOOL = "tool" | |
| REASONING = "reasoning" | |
| CODE_FENCE = "code_fence" | |
| class ContinuationOutcome(StrEnum): | |
| REFERENCE_COMPLETED = "reference_completed" | |
| REFERENCE_PREFIX_CLOSED_EARLY = "reference_prefix_closed_early" | |
| OTHER_CONTENT_CHANGE = "other_content_change" | |
| UNCLOSED_OR_INVALID = "unclosed_or_invalid" | |
| class ClosureScore: | |
| syntax_complete: bool | |
| content_preserved: bool | |
| success: bool | |
| class ClosureRegionScore: | |
| syntax_complete: bool | |
| content_preserved: bool | |
| success: bool | |
| trailing_content: bool | |
| whole_response_success: bool | |
| def closure_state(text: str, structure_format: ClosureFormat) -> ClosureState: | |
| if structure_format == ClosureFormat.JSON: | |
| return json_closure_state(text) | |
| if structure_format == ClosureFormat.TOOL: | |
| return delimited_json_closure_state(text, opener=TOOL_OPEN, closer=TOOL_CLOSE) | |
| if structure_format == ClosureFormat.REASONING: | |
| return paired_marker_closure_state(text, opener=THINK_OPEN, closer=THINK_CLOSE) | |
| if structure_format == ClosureFormat.CODE_FENCE: | |
| return required_code_fence_state(text) | |
| raise ValueError(f"Unsupported closure format: {structure_format}") | |
| def _json_content(text: str, structure_format: ClosureFormat) -> str: | |
| if structure_format == ClosureFormat.TOOL: | |
| text = text[len(TOOL_OPEN) :].rstrip(JSON_WHITESPACE)[: -len(TOOL_CLOSE)] | |
| # Canonical serialization ignores object order and whitespace, but preserves | |
| # distinctions such as true versus 1 that Python container equality loses. | |
| return json.dumps(json.loads(text), sort_keys=True, ensure_ascii=True, allow_nan=False) | |
| def score_closure(text: str, expected: str, structure_format: ClosureFormat) -> ClosureScore: | |
| """Check syntax and known content; never infer what unfinished content meant. | |
| JSON permits key-order and whitespace changes. Numeric spellings canonicalize | |
| through Python's JSON decoder; booleans remain distinct from numbers. Opaque | |
| reasoning and fence content must match except for trailing whitespace. | |
| """ | |
| complete = closure_state(text, structure_format).status == PrefixStatus.COMPLETE | |
| if not complete: | |
| return ClosureScore(False, False, False) | |
| if structure_format in (ClosureFormat.JSON, ClosureFormat.TOOL): | |
| reference = _json_content(expected, structure_format) | |
| try: | |
| candidate = _json_content(text, structure_format) | |
| except ValueError: | |
| # A syntactically valid exponent can overflow the JSON decoder's | |
| # float representation. It cannot preserve a finite reference value. | |
| return ClosureScore(True, False, False) | |
| preserved = candidate == reference | |
| else: | |
| preserved = text.rstrip(JSON_WHITESPACE) == expected.rstrip(JSON_WHITESPACE) | |
| return ClosureScore(True, preserved, preserved) | |
| def score_closure_region(text: str, expected: str, structure_format: ClosureFormat) -> ClosureRegionScore: | |
| """Score the first outer structure; report output after its boundary separately. | |
| Text includes the supplied structure prefix and generated continuation. | |
| Never skip illegal leading syntax to search for a later valid structure. | |
| Expected content still rejects premature completion of continue controls. | |
| """ | |
| state = closure_state(text, structure_format) | |
| if state.completion_offset is None: | |
| return ClosureRegionScore(False, False, False, False, False) | |
| score = score_closure(text[: state.completion_offset], expected, structure_format) | |
| trailing = bool(text[state.completion_offset :].strip(JSON_WHITESPACE)) | |
| return ClosureRegionScore( | |
| score.syntax_complete, score.content_preserved, score.success, trailing, score.success and not trailing | |
| ) | |
| def continuation_outcome(text: str, expected: str, structure_format: ClosureFormat) -> ContinuationOutcome: | |
| """Identify closing-only truncation of a known reference, without inferring intent. | |
| Early closure requires an exact strict reference prefix followed only by a verified | |
| syntactic repair. Other content changes include ambiguous truncations with | |
| spelling or whitespace changes; this is a conservative diagnostic, not a | |
| complete detector of semantic premature closure. Trailing output is ignored. | |
| """ | |
| state = closure_state(text, structure_format) | |
| if state.completion_offset is None: | |
| return ContinuationOutcome.UNCLOSED_OR_INVALID | |
| region = text[: state.completion_offset] | |
| score = score_closure(region, expected, structure_format) | |
| if score.content_preserved: | |
| return ContinuationOutcome.REFERENCE_COMPLETED | |
| boundary = 0 | |
| for actual, reference in zip(region, expected, strict=False): | |
| if actual != reference: | |
| break | |
| boundary += 1 | |
| shared = region[:boundary] | |
| suffix = closure_state(shared, structure_format).closing_suffix | |
| if suffix is not None and shared + suffix == region: | |
| return ContinuationOutcome.REFERENCE_PREFIX_CLOSED_EARLY | |
| return ContinuationOutcome.OTHER_CONTENT_CHANGE | |