| """Constrained CE over answer codes (matches serving softmax). |
| |
| Full-vocab next-token CE left relative Y/N logits dominated by the |
| base prior (eval collapse: all Noul → Y). Scoring only code tokens |
| aligns train with infer. |
| |
| Also: Noul consistency (P(yes|Q)+P(yes|¬Q)→1), optional binary |
| head CE on last-token hidden, and Score ordinal EMD (levels ordered). |
| """ |
|
|
| from __future__ import annotations |
|
|
| from typing import Any |
|
|
| import torch |
| import torch.nn.functional as F |
|
|
|
|
| def _answer_pos(shift_labels: torch.Tensor) -> int | None: |
| pos = (shift_labels != -100).nonzero(as_tuple=True)[0] |
| if len(pos) == 0: |
| return None |
| return int(pos[0].item()) |
|
|
|
|
| def code_token_loss( |
| logits: torch.Tensor, |
| labels: torch.Tensor, |
| code_token_ids: torch.Tensor, |
| n_codes: torch.Tensor, |
| soft_labels: torch.Tensor, |
| *, |
| use_soft: bool, |
| sample_weight: torch.Tensor | None = None, |
| force_soft_mask: torch.Tensor | None = None, |
| ) -> torch.Tensor: |
| """Softmax CE / soft-KL over allowed code ids at the answer position. |
| |
| ``logits``: [B, T, V]; ``labels``: [B, T] with -100 mask (gold at |
| the answer index). HF shift: predict token t from logits[:, t-1]. |
| Soft path is KL(teacher‖student) up to H(teacher). |
| ``force_soft_mask``: per-row override to soft-KL (Score rows). |
| """ |
| shift_logits = logits[:, :-1, :].contiguous() |
| shift_labels = labels[:, 1:].contiguous() |
| batch = shift_logits.size(0) |
| losses: list[torch.Tensor] = [] |
| weights: list[torch.Tensor] = [] |
|
|
| for b in range(batch): |
| p = _answer_pos(shift_labels[b]) |
| if p is None: |
| continue |
| k = int(n_codes[b].item()) |
| if k < 1: |
| continue |
| ids = code_token_ids[b, :k].long() |
| code_logits = shift_logits[b, p, ids] |
| row_soft = use_soft |
| if force_soft_mask is not None and int(force_soft_mask[b].item()) > 0: |
| row_soft = True |
| if row_soft: |
| target = soft_labels[b, :k].float() |
| target = target / target.sum().clamp_min(1e-8) |
| log_p = F.log_softmax(code_logits, dim=-1) |
| loss_b = -(target * log_p).sum() |
| else: |
| gold_idx = int(soft_labels[b, :k].argmax().item()) |
| loss_b = F.cross_entropy( |
| code_logits.unsqueeze(0), |
| torch.tensor( |
| [gold_idx], |
| device=code_logits.device, |
| dtype=torch.long, |
| ), |
| ) |
| losses.append(loss_b) |
| if sample_weight is not None: |
| weights.append(sample_weight[b].float()) |
| else: |
| weights.append( |
| torch.ones((), device=code_logits.device) |
| ) |
|
|
| if not losses: |
| return logits.sum() * 0.0 |
| stacked = torch.stack(losses) |
| w = torch.stack(weights) |
| return (stacked * w).sum() / w.sum().clamp_min(1e-8) |
|
|
|
|
| def ordinal_emd_loss( |
| logits: torch.Tensor, |
| labels: torch.Tensor, |
| code_token_ids: torch.Tensor, |
| n_codes: torch.Tensor, |
| soft_labels: torch.Tensor, |
| is_score: torch.Tensor, |
| *, |
| sample_weight: torch.Tensor | None = None, |
| ) -> torch.Tensor: |
| """1D Earth-mover distance on ordered Score levels. |
| |
| Penalizes mass 3 levels off more than 1: W1 = Σ|CDF_p − CDF_t|. |
| Only rows with ``is_score>0`` contribute. |
| """ |
| shift_logits = logits[:, :-1, :].contiguous() |
| shift_labels = labels[:, 1:].contiguous() |
| batch = shift_logits.size(0) |
| losses: list[torch.Tensor] = [] |
| weights: list[torch.Tensor] = [] |
|
|
| for b in range(batch): |
| if int(is_score[b].item()) <= 0: |
| continue |
| p = _answer_pos(shift_labels[b]) |
| if p is None: |
| continue |
| k = int(n_codes[b].item()) |
| if k < 2: |
| continue |
| ids = code_token_ids[b, :k].long() |
| code_logits = shift_logits[b, p, ids] |
| pred = F.softmax(code_logits.float(), dim=-1) |
| target = soft_labels[b, :k].float() |
| target = target / target.sum().clamp_min(1e-8) |
| |
| levels = torch.arange( |
| k, device=code_logits.device, dtype=pred.dtype |
| ) |
| gold = float((target * levels).sum().item()) |
| mae = (pred * (levels - gold).abs()).sum() |
| emd = (pred.cumsum(0) - target.cumsum(0)).abs().sum() |
| losses.append(emd + mae) |
| if sample_weight is not None: |
| weights.append(sample_weight[b].float()) |
| else: |
| weights.append( |
| torch.ones((), device=code_logits.device) |
| ) |
|
|
| if not losses: |
| return logits.sum() * 0.0 |
| stacked = torch.stack(losses) |
| w = torch.stack(weights) |
| return (stacked * w).sum() / w.sum().clamp_min(1e-8) |
|
|
|
|
| def code_yes_probs( |
| logits: torch.Tensor, |
| labels: torch.Tensor, |
| code_token_ids: torch.Tensor, |
| n_codes: torch.Tensor, |
| yes_idx: torch.Tensor, |
| ) -> torch.Tensor: |
| """P(yes) from constrained softmax; -1 where not applicable.""" |
| shift_logits = logits[:, :-1, :].contiguous() |
| shift_labels = labels[:, 1:].contiguous() |
| batch = shift_logits.size(0) |
| out = torch.full( |
| (batch,), -1.0, device=logits.device, dtype=logits.dtype |
| ) |
| for b in range(batch): |
| yi = int(yes_idx[b].item()) if yes_idx is not None else -1 |
| if yi < 0: |
| continue |
| p = _answer_pos(shift_labels[b]) |
| if p is None: |
| continue |
| k = int(n_codes[b].item()) |
| if k < 2 or yi >= k: |
| continue |
| ids = code_token_ids[b, :k].long() |
| probs = F.softmax(shift_logits[b, p, ids].float(), dim=-1) |
| out[b] = probs[yi] |
| return out |
|
|
|
|
| def consistency_loss( |
| p_yes_q: torch.Tensor, |
| p_yes_neg: torch.Tensor, |
| has_neg: torch.Tensor, |
| ) -> torch.Tensor: |
| """(P(yes|Q) + P(yes|¬Q) − 1)^2 on rows with a negation twin.""" |
| mask = (has_neg > 0) & (p_yes_q >= 0) & (p_yes_neg >= 0) |
| if not mask.any(): |
| return p_yes_q.sum() * 0.0 |
| diff = p_yes_q[mask] + p_yes_neg[mask] - 1.0 |
| return (diff * diff).mean() |
|
|
|
|
| def trace_token_loss( |
| logits: torch.Tensor, |
| trace_labels: torch.Tensor, |
| ) -> torch.Tensor: |
| """Full-vocab CE on rationale tokens (Path A L_trace). |
| |
| ``trace_labels``: [B, T] with -100 mask; only rationale positions |
| supervised. HF shift: predict token t from logits[:, t-1]. |
| """ |
| shift_logits = logits[:, :-1, :].contiguous() |
| shift_labels = trace_labels[:, 1:].contiguous() |
| if (shift_labels != -100).sum() == 0: |
| return logits.sum() * 0.0 |
| return F.cross_entropy( |
| shift_logits.view(-1, shift_logits.size(-1)), |
| shift_labels.view(-1), |
| ignore_index=-100, |
| ) |
|
|
|
|
| class CodeTokenTrainer: |
| """Lazy wrapper — real subclass built on first instantiate. |
| |
| Avoids importing transformers at module import time (unit tests). |
| """ |
|
|
| def __new__(cls, *args: Any, **kwargs: Any): |
| return _build_trainer_class()(*args, **kwargs) |
|
|
|
|
| _TRAINER_CLS: type | None = None |
|
|
|
|
| def _build_trainer_class() -> type: |
| global _TRAINER_CLS |
| if _TRAINER_CLS is not None: |
| return _TRAINER_CLS |
|
|
| from transformers import Trainer |
|
|
| class _CodeTokenTrainer(Trainer): |
| """Trainer that CE-supervises only the allowed answer codes.""" |
|
|
| def __init__( |
| self, |
| *args: Any, |
| use_soft_ce: bool = False, |
| train_sampler: Any | None = None, |
| consistency_weight: float = 0.0, |
| binary_head: Any | None = None, |
| binary_head_weight: float = 0.0, |
| binary_head_balanced: bool = False, |
| score_ordinal_weight: float = 0.0, |
| trace_loss_weight: float = 0.0, |
| **kwargs: Any, |
| ) -> None: |
| self._custom_train_sampler = train_sampler |
| super().__init__(*args, **kwargs) |
| self.use_soft_ce = bool(use_soft_ce) |
| self.consistency_weight = float(consistency_weight) |
| self.binary_head = binary_head |
| self.binary_head_weight = float(binary_head_weight) |
| self.binary_head_balanced = bool(binary_head_balanced) |
| self.score_ordinal_weight = float(score_ordinal_weight) |
| self.trace_loss_weight = float(trace_loss_weight) |
|
|
| def _get_train_sampler(self, train_dataset: Any = None): |
| if self._custom_train_sampler is not None: |
| return self._custom_train_sampler |
| try: |
| return super()._get_train_sampler(train_dataset) |
| except TypeError: |
| return super()._get_train_sampler() |
|
|
| def compute_loss( |
| self, |
| model: Any, |
| inputs: dict[str, Any], |
| return_outputs: bool = False, |
| num_items_in_batch: int | None = None, |
| ): |
| code_token_ids = inputs.pop("code_token_ids") |
| n_codes = inputs.pop("n_codes") |
| soft_labels = inputs.pop("soft_labels") |
| sample_weight = inputs.pop("sample_weight", None) |
| yes_idx = inputs.pop("yes_idx", None) |
| has_neg = inputs.pop("has_neg", None) |
| neg_input_ids = inputs.pop("neg_input_ids", None) |
| neg_attention = inputs.pop("neg_attention_mask", None) |
| neg_labels = inputs.pop("neg_labels", None) |
| neg_soft = inputs.pop("neg_soft_labels", None) |
| trace_labels = inputs.pop("trace_labels", None) |
| inputs.pop("label_id", None) |
| inputs.pop("has_soft", None) |
| is_noul = inputs.pop("is_noul", None) |
| is_score = inputs.pop("is_score", None) |
| force_soft = inputs.pop("force_soft", None) |
| inputs.pop("has_trace", None) |
|
|
| labels = inputs.get("labels") |
| outputs = model(**inputs) |
| loss = code_token_loss( |
| outputs.logits, |
| labels, |
| code_token_ids, |
| n_codes, |
| soft_labels, |
| use_soft=self.use_soft_ce, |
| sample_weight=sample_weight, |
| force_soft_mask=force_soft, |
| ) |
|
|
| |
| if ( |
| self.trace_loss_weight > 0 |
| and trace_labels is not None |
| ): |
| t_loss = trace_token_loss( |
| outputs.logits, trace_labels |
| ) |
| loss = loss + self.trace_loss_weight * t_loss |
|
|
| |
| if ( |
| self.score_ordinal_weight > 0 |
| and is_score is not None |
| and (is_score > 0).any() |
| ): |
| ord_loss = ordinal_emd_loss( |
| outputs.logits, |
| labels, |
| code_token_ids, |
| n_codes, |
| soft_labels, |
| is_score, |
| sample_weight=sample_weight, |
| ) |
| loss = loss + self.score_ordinal_weight * ord_loss |
|
|
| |
| if ( |
| self.consistency_weight > 0 |
| and neg_input_ids is not None |
| and has_neg is not None |
| and (has_neg > 0).any() |
| ): |
| neg_out = model( |
| input_ids=neg_input_ids, |
| attention_mask=neg_attention, |
| ) |
| loss = loss + code_token_loss( |
| neg_out.logits, |
| neg_labels, |
| code_token_ids, |
| n_codes, |
| neg_soft if neg_soft is not None else soft_labels, |
| use_soft=self.use_soft_ce, |
| sample_weight=sample_weight, |
| ) |
| if yes_idx is not None: |
| p_q = code_yes_probs( |
| outputs.logits, |
| labels, |
| code_token_ids, |
| n_codes, |
| yes_idx, |
| ) |
| p_n = code_yes_probs( |
| neg_out.logits, |
| neg_labels, |
| code_token_ids, |
| n_codes, |
| yes_idx, |
| ) |
| cons = consistency_loss(p_q, p_n, has_neg) |
| loss = loss + self.consistency_weight * cons |
|
|
| |
| if ( |
| self.binary_head is not None |
| and self.binary_head_weight > 0 |
| and is_noul is not None |
| and yes_idx is not None |
| ): |
| hidden = outputs.hidden_states |
| if hidden is None: |
| |
| outputs2 = model( |
| **{ |
| k: v |
| for k, v in inputs.items() |
| if k |
| in ("input_ids", "attention_mask") |
| }, |
| output_hidden_states=True, |
| ) |
| hidden = outputs2.hidden_states |
| if hidden is not None: |
| h = hidden[-1] |
| attn = inputs["attention_mask"] |
| |
| lengths = attn.long().sum(dim=1) - 1 |
| b_idx = torch.arange(h.size(0), device=h.device) |
| pooled = h[b_idx, lengths.clamp_min(0)] |
| logits2 = self.binary_head(pooled) |
| |
| gold = soft_labels.argmax(dim=-1) |
| target = (gold == yes_idx.clamp_min(0)).long() |
| |
| mask = is_noul > 0 |
| if mask.any(): |
| logits_m = logits2[mask] |
| target_m = target[mask] |
| weight = None |
| if self.binary_head_balanced: |
| |
| |
| |
| n0 = (target_m == 0).sum().clamp_min(1) |
| n1 = (target_m == 1).sum().clamp_min(1) |
| tot = (n0 + n1).to(logits_m.dtype) |
| weight = torch.stack( |
| [ |
| tot / (2.0 * n0.to(logits_m.dtype)), |
| tot / (2.0 * n1.to(logits_m.dtype)), |
| ] |
| ) |
| bce = F.cross_entropy( |
| logits_m, target_m, weight=weight |
| ) |
| loss = ( |
| loss + self.binary_head_weight * bce |
| ) |
|
|
| return (loss, outputs) if return_outputs else loss |
|
|
| _TRAINER_CLS = _CodeTokenTrainer |
| return _TRAINER_CLS |
|
|
