Replace v1 autojev runtime with LemonDecider v2 package

configuration_autojev.py

@@ -1,32 +0,0 @@
-"""Configuration for a Qwen backbone with a dynamic-option decision head."""
-import math
-from transformers.models.qwen3_5.configuration_qwen3_5 import Qwen3_5Config
-
-
-class AutoJevConfig(Qwen3_5Config):
-    model_type = "autojev_decision"
-
-    def __init__(self, codes=None, token_ids=None, max_options=255, temperature=1.0,
-                 base_model="Qwen/Qwen3.8-27B", initialization_step=0,
-                 max_input_length=8192, **kwargs):
-        super().__init__(**kwargs)
-        if max_options != 255:
-            raise ValueError("This artifact uses exactly 255 option positions")
-        if not math.isfinite(temperature) or temperature <= 0:
-            raise ValueError("temperature must be positive and finite")
-        self.max_options = max_options
-        self.codes = list(codes or [])
-        self.token_ids = list(token_ids or [])
-        if self.codes or self.token_ids:
-            if len(self.codes) != max_options or len(set(self.codes)) != max_options:
-                raise ValueError("Expected 255 unique answer codes")
-            if len(self.token_ids) != max_options or len(set(self.token_ids)) != max_options:
-                raise ValueError("Expected 255 unique answer token IDs")
-            if any(type(i) is not int or not 0 <= i < self.text_config.vocab_size for i in self.token_ids):
-                raise ValueError("Answer token IDs outside base vocabulary")
-        self.temperature = float(temperature)
-        self.base_model = base_model
-        self.initialization_step = initialization_step
-        self.max_input_length = int(max_input_length)
-        if self.max_input_length < 1:
-            raise ValueError("max_input_length must be positive")

modeling_autojev.py

@@ -1,86 +0,0 @@
-"""AutoJev-style full-weight decision model. No autoregressive generation head.
-
-The checkpoint's backbone is copied byte-for-byte from Qwen, while readout rows
-are selected from its original LM head. T is used in postprocessing, not CE loss.
-"""
-from dataclasses import dataclass
-import torch
-import torch.nn.functional as F
-from transformers.utils import ModelOutput
-from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5Model, Qwen3_5PreTrainedModel
-from .configuration_autojev import AutoJevConfig
-
-
-@dataclass
-class AutoJevOutput(ModelOutput):
-    loss: torch.Tensor | None = None
-    logits: torch.Tensor | None = None
-
-
-class AutoJevForDecisionClassification(Qwen3_5PreTrainedModel):
-    config_class = AutoJevConfig
-    base_model_prefix = "backbone"
-
-    def __init__(self, config):
-        super().__init__(config)
-        self.backbone = Qwen3_5Model(config)
-        self.readout = torch.nn.Linear(config.text_config.hidden_size, config.max_options, bias=False)
-        self.post_init()
-
-    def get_input_embeddings(self):
-        return self.backbone.get_input_embeddings()
-
-    def set_input_embeddings(self, value):
-        self.backbone.set_input_embeddings(value)
-
-    def forward(self, input_ids=None, attention_mask=None, option_counts=None,
-                labels=None, return_dict=True, **kwargs):
-        if input_ids is None or input_ids.ndim != 2 or input_ids.shape[1] == 0:
-            raise ValueError("input_ids must be a nonempty [batch, length] tensor")
-        if input_ids.shape[1] > self.config.max_input_length:
-            raise ValueError("Input exceeds max_input_length; truncation is not allowed")
-        if attention_mask is None:
-            attention_mask = torch.ones_like(input_ids)
-        if attention_mask.shape != input_ids.shape or not bool((attention_mask[:, -1] == 1).all()):
-            raise ValueError("Left padding required: last prompt position must be valid")
-        if option_counts is None:
-            raise ValueError("option_counts is required for each input")
-        counts = torch.as_tensor(option_counts, device=input_ids.device)
-        if counts.dtype == torch.bool or counts.is_floating_point() or counts.shape != (input_ids.shape[0],):
-            raise ValueError("option_counts must contain one integer per row")
-        if not bool(((counts >= 1) & (counts <= self.config.max_options)).all()):
-            raise ValueError("Each question must contain 1..255 options")
-        if kwargs.pop("use_cache", False) or kwargs.get("past_key_values") is not None:
-            raise ValueError("Decision forward does not accept KV-cache decoding")
-        output = self.backbone(input_ids=input_ids, attention_mask=attention_mask,
-                               use_cache=False, return_dict=True, **kwargs)
-        # Qwen3_5Model.last_hidden_state is AFTER language_model.norm (RMSNorm).
-        hidden = output.last_hidden_state[:, -1, :]
-        logits = self.readout(hidden).float()
-        invalid = torch.arange(self.config.max_options, device=logits.device)[None] >= counts[:, None]
-        logits = logits.masked_fill(invalid, -1e9)
-        loss = None
-        if labels is not None:
-            labels = labels.to(logits.device)
-            if labels.shape == (len(counts),):
-                if labels.is_floating_point() or labels.dtype == torch.bool or not bool(((labels >= 0) & (labels < counts)).all()):
-                    raise ValueError("Hard targets must be valid option indices")
-                loss = F.cross_entropy(logits, labels.long())
-            elif labels.shape == logits.shape:
-                target = labels.float()
-                if not bool(torch.isfinite(target).all()) or bool((target < 0).any()):
-                    raise ValueError("Invalid soft targets")
-                if not torch.allclose(target.sum(-1), torch.ones(len(counts), device=target.device), atol=1e-6, rtol=0):
-                    raise ValueError("Soft targets must sum to one")
-                if bool((target.masked_select(invalid) != 0).any()):
-                    raise ValueError("Soft targets assign mass to invalid options")
-                loss = -(target * F.log_softmax(logits, dim=-1)).sum(-1).mean()
-            else:
-                raise ValueError("labels must be [batch] or [batch,255]")
-        if not return_dict:
-            return (loss, logits) if loss is not None else (logits,)
-        return AutoJevOutput(loss=loss, logits=logits)
-
-
-AutoJevConfig.register_for_auto_class()
-AutoJevForDecisionClassification.register_for_auto_class("AutoModel")

sft_receipt.json

@@ -1,18 +0,0 @@
-{
-  "step": 24,
-  "dev_accuracy_t1": 0.7735191583633423,
-  "best_step": 3,
-  "best_dev_accuracy_t1": 0.7804877758026123,
-  "lr": 2.2827515498423204e-07,
-  "examples_seen": 6144,
-  "temperature_fit": {
-    "method": "NLL scan on dev 574 under fork _known() semantics, T grid [0.30,5.00]x0.05 (from cached T=1 probs)",
-    "best_T": 0.6,
-    "dev_nll_at_T": 0.56265,
-    "dev_brier_at_T": 0.28261,
-    "dev_nll_at_1": 0.6016,
-    "dev_brier_at_1": 0.29885,
-    "bound": false,
-    "reason": "best_T=0.60 != serving T=1.0; NOT applied — public-set re-eval required before adoption (dev acc unchanged at T*, argmax-invariant except noul boundary)"
-  }
-}