renderers 0.1.8.dev57__tar.gz → 0.1.8.dev61__tar.gz

{renderers-0.1.8.dev57 → renderers-0.1.8.dev61}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.8.dev57
+Version: 0.1.8.dev61
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE

{renderers-0.1.8.dev57 → renderers-0.1.8.dev61}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.8.dev57'
-__version_tuple__ = version_tuple = (0, 1, 8, 'dev57')
+__version__ = version = '0.1.8.dev61'
+__version_tuple__ = version_tuple = (0, 1, 8, 'dev61')
 
 __commit_id__ = commit_id = None

{renderers-0.1.8.dev57 → renderers-0.1.8.dev61}/renderers/base.py

@@ -1594,6 +1594,7 @@ def build_training_sample(
     role_to_mask: Callable[[Message], bool] | None = None,
     tools: list[ToolSpec] | None = None,
     content_sft_roles: "set[str] | frozenset[str] | None" = None,
+    ensure_final_stop: bool = False,
 ) -> RenderedTrainingSample:
     """Build a :class:`RenderedTrainingSample` for supervised training.
 
@@ -1649,6 +1650,17 @@ def build_training_sample(
     or hand-coded renderers that haven't been wired up yet) ignore
     ``content_sft_roles`` silently — falling back to the original
     ``role_to_mask`` + ``sampled_mask`` behaviour.
+
+    ``ensure_final_stop`` appends the renderer's canonical stop token
+    when the sample ends with an assistant message that the template
+    leaves unterminated. Some templates close an assistant turn only
+    via the *next* message's role marker (e.g. GLM's ``<|user|>`` /
+    ``<|observation|>``), so a final assistant message renders with no
+    stop token at all. No-op when the template already closes the turn
+    in-message (ChatML ``<|im_end|>``, Llama ``<|eot_id|>``); where it
+    fires, the output intentionally diverges from ``apply_chat_template``.
+    Ignored for renderers without ``sampled_mask`` (``DefaultRenderer``) —
+    the close of an opaque template can't be located reliably.
     """
     rendered = renderer.render(messages, tools=tools)
     has_sampled_info = len(rendered.sampled_mask) == len(rendered.token_ids)
@@ -1689,6 +1701,25 @@ def build_training_sample(
         else:
             loss_mask.append(role_to_mask(msg))
 
+    token_ids = list(rendered.token_ids)
+    # Requires sampled_mask (opaque templates hide the assistant close)
+    # and a final assistant message the role filter trains.
+    if (
+        ensure_final_stop
+        and has_sampled_info
+        and messages[-1].get("role") == "assistant"
+        and (role_to_mask is None or role_to_mask(messages[-1]))
+    ):
+        stop_ids = set(renderer.get_stop_token_ids())
+        last_trainable = next(
+            (k for k in range(len(loss_mask) - 1, -1, -1) if loss_mask[k]), None
+        )
+        if last_trainable is None or token_ids[last_trainable] not in stop_ids:
+            token_ids.append(renderer.get_stop_token_ids()[0])
+            # loss_mask=True marks the token as trainable — the appended
+            # stop is a training target, like any sampled token.
+            loss_mask.append(True)
+
     # Surface the multimodal payload for VLM renderers. ``None`` for text
     # renderers and for text-only samples (empty media) so downstream
     # ``multi_modal_data is not None`` is a reliable "has media" check.
@@ -1696,12 +1727,12 @@ def build_training_sample(
     if mm is not None and mm.is_empty():
         mm = None
     mm_token_type_ids = (
-        _build_mm_token_type_ids(mm.mm_placeholders, len(rendered.token_ids))
+        _build_mm_token_type_ids(mm.mm_placeholders, len(token_ids))
         if mm is not None and mm.mm_placeholders
         else None
     )
     return RenderedTrainingSample(
-        token_ids=rendered.token_ids,
+        token_ids=token_ids,
         loss_mask=loss_mask,
         multi_modal_data=mm,
         mm_token_type_ids=mm_token_type_ids,
@@ -1975,6 +2006,7 @@ def build_trajectory_step(
         "completion_mask": [True] * len(completion_ids),
         "completion_logprobs": [0.0] * len(completion_ids),
         "routed_experts": None,
+        "kept_tokens": None,
     }
     if (
         full_rendered.multi_modal_data is not None

{renderers-0.1.8.dev57 → renderers-0.1.8.dev61}/renderers/client.py

@@ -32,6 +32,7 @@ from renderers.base import (
 
 _request_logger = logging.getLogger("renderers.client")
 ROUTED_EXPERTS_DATA_PREFIX = b'"routed_experts":{"data":"'
+KEPT_TOKENS_IDS_PREFIX = b'"kept_tokens":{"ids":"'
 
 
 class OverlongPromptError(Exception):
@@ -121,23 +122,31 @@ async def _maybe_offload(renderer: Renderer | RendererPool, fn):
     return fn()
 
 
-def strip_routed_experts_data(raw: bytes) -> tuple[bytes, memoryview | None]:
-    data_start = raw.find(ROUTED_EXPERTS_DATA_PREFIX)
+def _strip_base64_field(raw: bytes, prefix: bytes) -> tuple[bytes, memoryview | None]:
+    """Splice a large base64 string field out of raw JSON bytes.
+
+    Avoids json-decoding megabytes of base64; the returned memoryview
+    references ``raw`` and is re-inserted into the parsed payload.
+    """
+    data_start = raw.find(prefix)
     if data_start < 0:
         return raw, None
 
-    data_start += len(ROUTED_EXPERTS_DATA_PREFIX)
+    data_start += len(prefix)
     data_end = raw.index(b'"', data_start)
-    routed_data = memoryview(raw)[data_start:data_end]
+    data = memoryview(raw)[data_start:data_end]
     stripped = raw[:data_start] + raw[data_end:]
-    return stripped, routed_data
+    return stripped, data
 
 
 def parse_generate_response(raw: bytes) -> dict[str, Any]:
-    stripped, routed_data = strip_routed_experts_data(raw)
+    stripped, routed_data = _strip_base64_field(raw, ROUTED_EXPERTS_DATA_PREFIX)
+    stripped, kept_ids_data = _strip_base64_field(stripped, KEPT_TOKENS_IDS_PREFIX)
     payload: dict[str, Any] = json.loads(stripped)
     if routed_data is not None:
         payload["choices"][0]["routed_experts"]["data"] = routed_data
+    if kept_ids_data is not None:
+        payload["choices"][0]["kept_tokens"]["ids"] = kept_ids_data
     return payload
 
 
@@ -293,6 +302,7 @@ async def generate(
     completion_logprobs = [float(c.get("logprob") or 0.0) for c in content_lp or []]
 
     routed_experts = choice.get("routed_experts")
+    kept_tokens = choice.get("kept_tokens")
 
     # /inference/v1/generate returns finish_reason in {"stop","length",...} —
     # never "tool_calls" (a chat-completions concept). Promote stop→tool_calls
@@ -319,6 +329,7 @@ async def generate(
         "tool_calls": parsed.tool_calls,
         "finish_reason": finish_reason,
         "routed_experts": routed_experts,
+        "kept_tokens": kept_tokens,
         # The mm sidecar consumed on the request side, surfaced back so
         # callers can persist it on the trajectory step for downstream
         # multi-turn bridging and training-sample construction.

{renderers-0.1.8.dev57 → renderers-0.1.8.dev61}/tests/test_build_helpers.py

@@ -64,6 +64,34 @@ def test_build_training_sample_has_trainable_tokens(model_name, tokenizer, rende
     assert len(mask) == len(ids)
 
 
+def test_build_training_sample_ensures_final_stop(model_name, tokenizer, renderer):
+    """The final assistant turn ends at a trainable renderer stop token.
+
+    Templates whose assistant close is part of the message (ChatML, Llama)
+    already satisfy this, so the sample stays byte-identical; templates
+    that terminate turns with the next message's role marker (GLM) get the
+    canonical stop appended as the training target.
+    """
+    if not renderer.render([{"role": "user", "content": "x"}]).sampled_mask:
+        return  # DefaultRenderer: no sampled_mask, role-only masking
+    msgs = [
+        {"role": "user", "content": "Hi"},
+        {"role": "assistant", "content": "Hello!"},
+    ]
+    sample = build_training_sample(renderer, msgs, ensure_final_stop=True)
+    stop_ids = set(renderer.get_stop_token_ids())
+    last_trainable = max(k for k, m in enumerate(sample.loss_mask) if m)
+    assert sample.token_ids[last_trainable] in stop_ids
+
+    baseline = build_training_sample(renderer, msgs)
+    if (
+        baseline.token_ids[max(k for k, m in enumerate(baseline.loss_mask) if m)]
+        in stop_ids
+    ):
+        # In-message close: ensure_final_stop must not change the bytes.
+        assert sample.token_ids == baseline.token_ids
+
+
 def test_build_trajectory_step_reconstructs_full(model_name, tokenizer, renderer):
     """prompt_ids + completion_ids must equal the full rendered sequence."""
     prompt = [