Upload oss-jev-train for hf jobs uv run

configs/jobs-a10g-noul-aug.yaml

@@ -0,0 +1,33 @@
+# Noul augment continue-from-10k (v0.1.4). Distinct Hub id — never
+# overwrite main / decision-10k. Recipe: 10k fix baseline + negation
+# consistency + randomized yes/no codes. Binary head off unless dry-run
+# shows raw logits still stuck.
+model_id: gyanbhambhani/oss-jev-qwen05-decision-10k
+mode: one_token
+max_length: 1024
+batch_size: 2
+learning_rate: 1.0e-5
+# Short continue: ~0.5 epoch on expanded noul (~2x noul rows)
+max_steps: 2000
+max_train_rows: null
+seed: 42
+fp16: false
+bf16: true
+logging_steps: 50
+save_total_limit: 2
+report_to: none
+# Keep 10k fix recipe levers
+use_soft_ce: true
+balance_noul: true
+constrained_codes: true
+noul_n_frac: 0.50
+noul_hard_ce: false
+noul_loss_weight: 1.0
+noul_n_sample_weight: 1.0
+noul_logit_bias_n: 0.0
+# v0.1.4 attacks
+noul_random_codes: true
+noul_negation_pairs: true
+noul_consistency_weight: 1.0
+noul_binary_head: false
+noul_binary_head_weight: 1.0

configs/smoke-noul-aug.yaml

@@ -0,0 +1,26 @@
+# Local / tiny smoke for Noul augments (CPU or short Job).
+model_id: gyanbhambhani/oss-jev-qwen05-decision-10k
+mode: one_token
+max_length: 512
+batch_size: 1
+learning_rate: 1.0e-5
+max_steps: 4
+max_train_rows: 64
+seed: 42
+fp16: false
+bf16: false
+logging_steps: 1
+save_total_limit: 1
+report_to: none
+use_soft_ce: true
+balance_noul: true
+constrained_codes: true
+noul_n_frac: 0.50
+noul_hard_ce: false
+noul_loss_weight: 1.0
+noul_n_sample_weight: 1.0
+noul_logit_bias_n: 0.0
+noul_random_codes: true
+noul_negation_pairs: true
+noul_consistency_weight: 1.0
+noul_binary_head: false

oss_jev_train/__init__.py

@@ -1,6 +1,6 @@
 """OSS Jev one-token / decision-head training (HF Jobs ready)."""
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"
 SCHEMA_VERSION = "oss-jev-distill-v1"
 # Default smoke base; prefer manifest.base_tokenizer_hint for real runs.
 DEFAULT_MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"

oss_jev_train/code_loss.py

@@ -3,6 +3,9 @@
 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) and optional binary
+head CE on last-token hidden.
 """
 
 from __future__ import annotations
@@ -13,6 +16,13 @@ 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,
@@ -28,7 +38,6 @@ def code_token_loss(
     ``logits``: [B, T, V]; ``labels``: [B, T] with -100 mask (gold at
     the answer index). HF shift: predict token t from logits[:, t-1].
     """
-    # Predict position t from logits at t-1.
     shift_logits = logits[:, :-1, :].contiguous()
     shift_labels = labels[:, 1:].contiguous()
     batch = shift_logits.size(0)
@@ -36,11 +45,9 @@ def code_token_loss(
     weights: list[torch.Tensor] = []
 
     for b in range(batch):
-        pos = (shift_labels[b] != -100).nonzero(as_tuple=True)[0]
-        if len(pos) == 0:
+        p = _answer_pos(shift_labels[b])
+        if p is None:
             continue
-        # One supervised answer token per row.
-        p = int(pos[0].item())
         k = int(n_codes[b].item())
         if k < 1:
             continue
@@ -52,7 +59,6 @@ def code_token_loss(
             log_p = F.log_softmax(code_logits, dim=-1)
             loss_b = -(target * log_p).sum()
         else:
-            # Hard label = index of gold among codes (one-hot soft).
             gold_idx = int(soft_labels[b, :k].argmax().item())
             loss_b = F.cross_entropy(
                 code_logits.unsqueeze(0),
@@ -77,6 +83,49 @@ def code_token_loss(
     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()
+
+
 class CodeTokenTrainer:
     """Lazy wrapper — real subclass built on first instantiate.
 
@@ -105,11 +154,17 @@ def _build_trainer_class() -> type:
             *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,
             **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)
 
         def _get_train_sampler(self, train_dataset: Any = None):
             if self._custom_train_sampler is not None:
@@ -130,9 +185,15 @@ def _build_trainer_class() -> type:
             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)
             inputs.pop("label_id", None)
             inputs.pop("has_soft", None)
-            inputs.pop("is_noul", None)
+            is_noul = inputs.pop("is_noul", None)
 
             labels = inputs.get("labels")
             outputs = model(**inputs)
@@ -145,6 +206,86 @@ def _build_trainer_class() -> type:
                 use_soft=self.use_soft_ce,
                 sample_weight=sample_weight,
             )
+
+            # Negation consistency + CE on ¬Q (dual forward).
+            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
+
+            # Optional dedicated binary head on last non-pad hidden.
+            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:
+                    # Re-forward with hidden states if model omitted them.
+                    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"]
+                    # Last non-pad index per row.
+                    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)
+                    # Target: 1 if gold is yes-code else 0.
+                    gold = soft_labels.argmax(dim=-1)
+                    target = (gold == yes_idx.clamp_min(0)).long()
+                    # Only noul rows.
+                    mask = is_noul > 0
+                    if mask.any():
+                        bce = F.cross_entropy(
+                            logits2[mask], target[mask]
+                        )
+                        loss = (
+                            loss + self.binary_head_weight * bce
+                        )
+
             return (loss, outputs) if return_outputs else loss
 
     _TRAINER_CLS = _CodeTokenTrainer

oss_jev_train/dataset.py

@@ -58,6 +58,13 @@ def assert_single_token_codes(
                 )
 
 
+def _noul_is_yes_gold(ex: DecisionExample) -> bool:
+    from .noul_augment import _yes_no_codes
+
+    yes_c, _ = _yes_no_codes(ex)
+    return ex.gold_code == yes_c
+
+
 def noul_balance_weights(
     examples: list[DecisionExample],
     *,
@@ -68,16 +75,17 @@ def noul_balance_weights(
     v0.1.1 equal Y/N mass *upweighted Y* (train is already ~65% N) and
     eval stayed all-Y. v0.1.2 defaults to heavy N oversampling (~80% N
     mass among noul ≈ 4:1 N:Y). Non-noul rows keep weight 1.0.
+    Works with randomized yes/no codes (not only literal Y/N).
     """
     n_y = sum(
         1
         for ex in examples
-        if ex.primitive == "noul" and ex.gold_code == "Y"
+        if ex.primitive == "noul" and _noul_is_yes_gold(ex)
     )
     n_n = sum(
         1
         for ex in examples
-        if ex.primitive == "noul" and ex.gold_code == "N"
+        if ex.primitive == "noul" and not _noul_is_yes_gold(ex)
     )
     n_y = max(n_y, 1)
     n_n = max(n_n, 1)
@@ -90,7 +98,7 @@ def noul_balance_weights(
     for ex in examples:
         if ex.primitive != "noul":
             out.append(1.0)
-        elif ex.gold_code == "Y":
+        elif _noul_is_yes_gold(ex):
             out.append(float(w_y))
         else:
             out.append(float(w_n))
@@ -137,6 +145,7 @@ class OneTokenDataset(Dataset):
         noul_hard_ce: bool = True,
         noul_loss_weight: float = 2.0,
         noul_n_sample_weight: float = 2.0,
+        noul_consistency: bool = False,
     ) -> None:
         self.examples = examples
         self.tokenizer = tokenizer
@@ -147,6 +156,8 @@ class OneTokenDataset(Dataset):
         self.noul_hard_ce = bool(noul_hard_ce)
         self.noul_loss_weight = float(noul_loss_weight)
         self.noul_n_sample_weight = float(noul_n_sample_weight)
+        # Dual-forward consistency on Q and ¬Q (same item).
+        self.noul_consistency = bool(noul_consistency)
         if tokenizer.pad_token_id is None:
             tokenizer.pad_token = tokenizer.eos_token
         # Cache code → token id (verified single-token upstream).
@@ -161,13 +172,19 @@ class OneTokenDataset(Dataset):
     def __len__(self) -> int:
         return len(self.examples)
 
-    def __getitem__(self, idx: int) -> dict[str, Any]:
+    def _encode_supervised(self, ex: "DecisionExample") -> dict[str, Any]:
         import torch
 
-        ex = self.examples[idx]
         prompt = format_prompt(ex)
-        # Append gold code; loss only on that final answer token.
+        # Prompt must end so gold is its own token (see prompts.Answer:\n).
         full = prompt + ex.gold_code
+        gold_ids = self.tokenizer.encode(
+            ex.gold_code, add_special_tokens=False
+        )
+        if len(gold_ids) != 1:
+            raise ValueError(
+                f"{ex.id}: gold {ex.gold_code!r} → {gold_ids}"
+            )
         enc = self.tokenizer(
             full,
             truncation=True,
@@ -179,11 +196,15 @@ class OneTokenDataset(Dataset):
         attention = enc["attention_mask"].squeeze(0)
         labels = input_ids.clone()
         labels[attention == 0] = -100
-        # Mask everything before the last non-pad token (the gold code).
         nonzero = (attention == 1).nonzero(as_tuple=True)[0]
         if len(nonzero) == 0:
             raise ValueError(f"empty encoding for {ex.id}")
         last = int(nonzero[-1].item())
+        if int(input_ids[last].item()) != int(gold_ids[0]):
+            raise ValueError(
+                f"{ex.id}: last token {int(input_ids[last])} != "
+                f"gold id {gold_ids[0]} (prompt/code glue bug)"
+            )
         labels[:last] = -100
 
         n = len(ex.codes)
@@ -193,8 +214,6 @@ class OneTokenDataset(Dataset):
         for i, code in enumerate(ex.codes):
             code_token_ids[i] = self._code_id[code]
 
-        # Noul: prefer hard one-hot (teacher soft still puts ~0.13 on Y
-        # for N-gold; that softens the N gradient under Y base prior).
         use_soft_row = self.use_soft and not (
             ex.primitive == "noul" and self.noul_hard_ce
         )
@@ -208,15 +227,19 @@ class OneTokenDataset(Dataset):
             soft_t[ex.label_id] = 1.0
             has_soft = 0
 
-        # Up-weight Noul overall; within Noul up-weight N (not Y).
+        from .noul_augment import _yes_no_codes, noul_yes_index
+
         if ex.primitive == "noul":
+            yes_c, no_c = _yes_no_codes(ex)
             base = self.noul_loss_weight
-            if ex.gold_code == "N":
+            if ex.gold_code == no_c:
                 sample_weight = base * self.noul_n_sample_weight
             else:
                 sample_weight = base
+            yes_idx = int(noul_yes_index(ex))
         else:
             sample_weight = 1.0
+            yes_idx = -1
 
         return {
             "input_ids": input_ids,
@@ -229,8 +252,43 @@ class OneTokenDataset(Dataset):
             "has_soft": has_soft,
             "sample_weight": float(sample_weight),
             "is_noul": 1 if ex.primitive == "noul" else 0,
+            "yes_idx": yes_idx,
         }
 
+    def __getitem__(self, idx: int) -> dict[str, Any]:
+        import torch
+
+        from .noul_augment import make_negated_noul
+
+        ex = self.examples[idx]
+        item = self._encode_supervised(ex)
+
+        # Consistency: attach ¬Q tensors on non-negated noul rows only
+        # (twins already in the expanded set skip dual-forward).
+        already_neg = bool((ex.meta or {}).get("noul_negated"))
+        if (
+            self.noul_consistency
+            and ex.primitive == "noul"
+            and not already_neg
+        ):
+            twin = make_negated_noul(ex)
+            neg = self._encode_supervised(twin)
+            item["neg_input_ids"] = neg["input_ids"]
+            item["neg_attention_mask"] = neg["attention_mask"]
+            item["neg_labels"] = neg["labels"]
+            item["neg_soft_labels"] = neg["soft_labels"]
+            item["has_neg"] = 1
+        else:
+            # Pad-shaped placeholders so default collator stacks.
+            z = item["input_ids"]
+            item["neg_input_ids"] = torch.zeros_like(z)
+            item["neg_attention_mask"] = torch.zeros_like(z)
+            item["neg_labels"] = torch.full_like(z, -100)
+            item["neg_soft_labels"] = torch.zeros_like(item["soft_labels"])
+            item["has_neg"] = 0
+
+        return item
+
 
 class ClassificationDataset(Dataset):
     """Optional ablation: linear head over last hidden state."""

oss_jev_train/export_ckpt.py

@@ -20,6 +20,10 @@ def write_checkpoint_sidecar(
     noul_logit_bias_n: float | None = None,
     noul_n_frac: float | None = None,
     noul_hard_ce: bool | None = None,
+    noul_random_codes: bool | None = None,
+    noul_negation_pairs: bool | None = None,
+    noul_consistency_weight: float | None = None,
+    noul_binary_head: bool | None = None,
 ) -> Path:
     """Write ``decision_head.json`` next to HF weights.
 
@@ -65,6 +69,16 @@ def write_checkpoint_sidecar(
         meta["noul_n_frac"] = float(noul_n_frac)
     if noul_hard_ce is not None:
         meta["noul_hard_ce"] = bool(noul_hard_ce)
+    if noul_random_codes is not None:
+        meta["noul_random_codes"] = bool(noul_random_codes)
+    if noul_negation_pairs is not None:
+        meta["noul_negation_pairs"] = bool(noul_negation_pairs)
+    if noul_consistency_weight is not None:
+        meta["noul_consistency_weight"] = float(
+            noul_consistency_weight
+        )
+    if noul_binary_head is not None:
+        meta["noul_binary_head"] = bool(noul_binary_head)
     path = ckpt_dir / "decision_head.json"
     path.write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
 

oss_jev_train/noul_augment.py

@@ -0,0 +1,184 @@
+"""Noul train augments: negation twins + randomized answer codes.
+
+Attack 1 — negation: for Q with P(yes)=p, build ¬Q with teacher 1-p and
+flipped gold. Optional consistency: (P(yes|Q)+P(yes|¬Q)-1)^2 → 0.
+
+Attack 2 — random codes: per-example single-token yes/no codes from a
+letter pool (not Y/N) so CE cannot ride the base Y-prior.
+"""
+
+from __future__ import annotations
+
+import copy
+import random
+import re
+from typing import Any
+
+from .schema import DecisionExample
+
+# Letters that are single tokens on Qwen2.5; exclude Y/N (prior) and O/I
+# (digit-like confusion). Verified at assert_single_token_codes time.
+NOUL_CODE_POOL = tuple("ABCDEFGHJKLMNPQRSTUVWXZ")
+
+
+def negate_instructions(instructions: Any) -> Any:
+    """Wrap instructions so the yes-answer means the opposite claim."""
+    if isinstance(instructions, str):
+        text = instructions.strip()
+        if re.match(r"(?i)^is the opposite true of:", text):
+            return text
+        return f"Is the opposite true of: {text}"
+    return {
+        "negated": True,
+        "original": instructions,
+        "ask": "Answer yes only if the original claim is false.",
+    }
+
+
+def _yes_no_codes(ex: DecisionExample) -> tuple[str, str]:
+    """Return (yes_code, no_code) from code_to_key / canonical Y,N."""
+    yes_c = no_c = None
+    for c in ex.codes:
+        key = str(ex.code_to_key.get(c, "")).lower()
+        if key in ("true", "yes", "y"):
+            yes_c = c
+        elif key in ("false", "no", "n"):
+            no_c = c
+    if yes_c is None or no_c is None:
+        if set(ex.codes) == {"Y", "N"}:
+            return "Y", "N"
+        if len(ex.codes) == 2:
+            return ex.codes[0], ex.codes[1]
+        raise ValueError(f"{ex.id}: cannot resolve yes/no codes")
+    return yes_c, no_c
+
+
+def make_negated_noul(ex: DecisionExample) -> DecisionExample:
+    """Logical ¬Q: flipped gold + teacher; same answer codes as Q."""
+    if ex.primitive != "noul":
+        raise ValueError(f"{ex.id}: negate only for noul")
+    yes_c, no_c = _yes_no_codes(ex)
+    twin = copy.deepcopy(ex)
+    twin.id = f"{ex.id}::neg"
+    twin.instructions = negate_instructions(ex.instructions)
+    twin.prompt = None
+    # Flip gold meaning.
+    twin.gold_code = no_c if ex.gold_code == yes_c else yes_c
+    teacher = dict(twin.teacher or {})
+    p_yes = None
+    if "noul" in teacher:
+        p_yes = 1.0 - float(teacher["noul"])
+        teacher["noul"] = p_yes
+    probs = teacher.get("probabilities")
+    if p_yes is None and isinstance(probs, dict) and probs:
+        for k, v in probs.items():
+            kl = str(k).lower()
+            if kl in ("true", "yes", "y") or k == yes_c:
+                p_yes = 1.0 - float(v)
+                break
+    if p_yes is not None:
+        teacher["noul"] = float(p_yes)
+        teacher["probabilities"] = {
+            "true": float(p_yes),
+            "false": 1.0 - float(p_yes),
+            yes_c: float(p_yes),
+            no_c: 1.0 - float(p_yes),
+        }
+    twin.teacher = teacher
+    twin.meta = dict(twin.meta or {})
+    twin.meta["noul_negated"] = True
+    twin.meta["noul_pair_id"] = ex.meta.get("noul_pair_id") or ex.id
+    # Flip criteria true/false text if present.
+    if isinstance(twin.criteria, dict):
+        crit = dict(twin.criteria)
+        if "true" in crit or "false" in crit:
+            t, f = crit.get("true"), crit.get("false")
+            if t is not None:
+                crit["false"] = t
+            if f is not None:
+                crit["true"] = f
+            twin.criteria = crit
+    twin.validate()
+    return twin
+
+
+def randomize_noul_codes(
+    ex: DecisionExample,
+    rng: random.Random,
+    *,
+    pool: tuple[str, ...] = NOUL_CODE_POOL,
+) -> DecisionExample:
+    """Replace Y/N with a random single-token code pair (yes, no)."""
+    if ex.primitive != "noul":
+        return ex
+    yes_c, no_c = _yes_no_codes(ex)
+    pick = rng.sample(list(pool), 2)
+    new_yes, new_no = pick[0], pick[1]
+    out = copy.deepcopy(ex)
+    out.codes = [new_yes, new_no]
+    out.code_to_key = {new_yes: "true", new_no: "false"}
+    out.gold_code = new_yes if ex.gold_code == yes_c else new_no
+    out.prompt = None
+    # Remap teacher probs keyed by Y/N or true/false onto new codes.
+    teacher = dict(out.teacher or {})
+    probs = teacher.get("probabilities")
+    if isinstance(probs, dict) and probs:
+        p_yes = None
+        for k, v in probs.items():
+            kl = str(k).lower()
+            if kl in ("true", "yes", "y") or k == yes_c:
+                p_yes = float(v)
+                break
+        if p_yes is None and "noul" in teacher:
+            p_yes = float(teacher["noul"])
+        if p_yes is not None:
+            teacher["probabilities"] = {
+                "true": p_yes,
+                "false": 1.0 - p_yes,
+                new_yes: p_yes,
+                new_no: 1.0 - p_yes,
+            }
+    out.teacher = teacher
+    out.meta = dict(out.meta or {})
+    out.meta["noul_random_codes"] = True
+    out.meta["noul_yes_code"] = new_yes
+    out.meta["noul_no_code"] = new_no
+    out.meta["noul_pair_id"] = out.meta.get("noul_pair_id") or ex.id
+    out.validate()
+    return out
+
+
+def apply_noul_augments(
+    examples: list[DecisionExample],
+    *,
+    random_codes: bool = False,
+    negation_pairs: bool = False,
+    seed: int = 42,
+) -> list[DecisionExample]:
+    """Return possibly expanded/remapped train list.
+
+    Order: randomize codes on originals first (shared codes for any twin),
+    then optionally append negated twins.
+    """
+    rng = random.Random(int(seed))
+    out: list[DecisionExample] = []
+    twins: list[DecisionExample] = []
+    for ex in examples:
+        row = ex
+        if ex.primitive == "noul":
+            row = copy.deepcopy(ex)
+            row.meta = dict(row.meta or {})
+            row.meta["noul_pair_id"] = ex.id
+            if random_codes:
+                row = randomize_noul_codes(row, rng)
+            if negation_pairs:
+                twins.append(make_negated_noul(row))
+        out.append(row)
+    if negation_pairs:
+        out.extend(twins)
+    return out
+
+
+def noul_yes_index(ex: DecisionExample) -> int:
+    yes_c, _ = _yes_no_codes(ex)
+    return ex.codes.index(yes_c)

oss_jev_train/prompts.py

@@ -28,13 +28,30 @@ def _criteria_block(ex: DecisionExample) -> str:
         if isinstance(criteria, dict):
             true_desc = str(criteria.get("true", true_desc))
             false_desc = str(criteria.get("false", false_desc))
-        lines.append(f"Y: yes — {true_desc}")
-        lines.append(f"N: no — {false_desc}")
+        # Use actual codes (Y/N or randomized train pair).
+        for code in ex.codes:
+            key = str(ex.code_to_key.get(code, "")).lower()
+            if key in ("true", "yes", "y") or (
+                set(ex.codes) == {"Y", "N"} and code == "Y"
+            ):
+                lines.append(f"{code}: yes — {true_desc}")
+            else:
+                lines.append(f"{code}: no — {false_desc}")
+        yes_c = next(
+            (
+                c
+                for c in ex.codes
+                if str(ex.code_to_key.get(c, "")).lower()
+                in ("true", "yes", "y")
+                or (set(ex.codes) == {"Y", "N"} and c == "Y")
+            ),
+            ex.codes[0],
+        )
+        no_c = next((c for c in ex.codes if c != yes_c), ex.codes[-1])
         # Counter base-model yes-bias / all-Y collapse on eval.
-        # v0.1.2: forbid defaulting to Y (v0.1.1 caution was too soft).
         lines.append(
-            "Default to N. Answer Y only with clear affirmative "
-            "evidence in the state; do not guess Y."
+            f"Default to {no_c}. Answer {yes_c} only with clear "
+            f"affirmative evidence in the state; do not guess {yes_c}."
         )
         return "\n".join(lines)
     if ex.primitive == "choice" and isinstance(criteria, dict):
@@ -74,7 +91,10 @@ def format_prompt(ex: DecisionExample) -> str:
         "### Answer",
         "Reply with exactly one code character.",
         f"Codes: {legend}",
-        "Answer:",
+        # Trailing newline: Qwen merges `Answer:N` into `:N` (not code
+        # token 45). `Answer:\n` + code keeps Y/N/letters single tokens
+        # and matches infer next-token position.
+        "Answer:\n",
     ]
     return "\n".join(p for p in parts if p is not None)
 
@@ -87,7 +107,11 @@ def soft_targets(ex: DecisionExample) -> list[float] | None:
             p_yes = float(ex.teacher["noul"])
             out = []
             for c in ex.codes:
-                out.append(p_yes if c == "Y" else 1.0 - p_yes)
+                key = str(ex.code_to_key.get(c, "")).lower()
+                is_yes = key in ("true", "yes", "y") or (
+                    set(ex.codes) == {"Y", "N"} and c == "Y"
+                )
+                out.append(p_yes if is_yes else 1.0 - p_yes)
             return out
         return None
     out: list[float] = []

oss_jev_train/schema.py

@@ -45,8 +45,12 @@ class DecisionExample:
             raise ValueError(
                 f"{self.id}: gold_code {self.gold_code!r} not in codes"
             )
-        if self.primitive == "noul" and set(self.codes) != {"Y", "N"}:
-            raise ValueError(f"{self.id}: noul codes must be Y,N")
+        if self.primitive == "noul":
+            if len(self.codes) != 2 or self.codes[0] == self.codes[1]:
+                raise ValueError(
+                    f"{self.id}: noul needs exactly 2 distinct codes"
+                )
+            # Canonical Y/N or train-time random single-token pair.
         if self.primitive == "choice" and len(self.codes) > 26:
             raise ValueError(f"{self.id}: choice cap is 26 codes")
         if self.primitive == "score" and not (2 <= len(self.codes) <= 10):

oss_jev_train/train.py

@@ -27,6 +27,7 @@ from .dataset import (
     make_noul_balanced_sampler,
 )
 from .export_ckpt import write_checkpoint_sidecar
+from .noul_augment import apply_noul_augments
 
 
 def _env(name: str, default: str | None = None) -> str | None:
@@ -236,6 +237,33 @@ def build_argparser() -> argparse.ArgumentParser:
         default=None,
         help="Subsample train JSONL to this many rows (seed from cfg)",
     )
+    p.add_argument(
+        "--noul_random_codes",
+        action="store_true",
+        help="Per-example random yes/no codes (not Y/N)",
+    )
+    p.add_argument(
+        "--noul_negation_pairs",
+        action="store_true",
+        help="Append negated noul twins (flipped gold/teacher)",
+    )
+    p.add_argument(
+        "--noul_consistency_weight",
+        type=float,
+        default=None,
+        help="Weight for (P(yes|Q)+P(yes|¬Q)-1)^2 (0=off)",
+    )
+    p.add_argument(
+        "--noul_binary_head",
+        action="store_true",
+        help="Extra linear head on last hidden for noul (ablation)",
+    )
+    p.add_argument(
+        "--noul_binary_head_weight",
+        type=float,
+        default=None,
+        help="Weight for binary-head CE (default 1.0 if head on)",
+    )
     return p
 
 
@@ -287,6 +315,12 @@ def merge_config(args: argparse.Namespace) -> dict[str, Any]:
         "noul_hard_ce": True,
         "noul_logit_bias_n": 2.5,
         "max_train_rows": None,
+        # v0.1.4 Noul augments (off by default; 10k scale recipe unchanged).
+        "noul_random_codes": False,
+        "noul_negation_pairs": False,
+        "noul_consistency_weight": 0.0,
+        "noul_binary_head": False,
+        "noul_binary_head_weight": 1.0,
     }
     if args.config:
         with open(args.config, encoding="utf-8") as f:
@@ -333,6 +367,20 @@ def merge_config(args: argparse.Namespace) -> dict[str, Any]:
         cfg["noul_hard_ce"] = False
     if args.noul_logit_bias_n is not None:
         cfg["noul_logit_bias_n"] = float(args.noul_logit_bias_n)
+    if args.noul_random_codes:
+        cfg["noul_random_codes"] = True
+    if args.noul_negation_pairs:
+        cfg["noul_negation_pairs"] = True
+    if args.noul_consistency_weight is not None:
+        cfg["noul_consistency_weight"] = float(
+            args.noul_consistency_weight
+        )
+    if args.noul_binary_head:
+        cfg["noul_binary_head"] = True
+    if args.noul_binary_head_weight is not None:
+        cfg["noul_binary_head_weight"] = float(
+            args.noul_binary_head_weight
+        )
     env_model = _env("OSS_JEV_MODEL_ID")
     if env_model and args.model_id is None and not (
         args.config and cfg.get("model_id")
@@ -362,18 +410,45 @@ def check_manifest(paths: dict[str, Path]) -> dict[str, Any] | None:
     return manifest
 
 
+def prepare_train_examples(
+    examples: list,
+    cfg: dict[str, Any],
+) -> list:
+    """Subsample then apply Noul augments (random codes / negation)."""
+    examples = subsample_examples(
+        examples,
+        cfg.get("max_train_rows"),
+        int(cfg.get("seed", 42)),
+    )
+    return apply_noul_augments(
+        examples,
+        random_codes=bool(cfg.get("noul_random_codes", False)),
+        negation_pairs=bool(cfg.get("noul_negation_pairs", False)),
+        seed=int(cfg.get("seed", 42)),
+    )
+
+
 def run_dry(paths: dict[str, Path], cfg: dict[str, Any]) -> int:
     from transformers import AutoTokenizer
 
     examples = load_jsonl(paths["train"])
     n_full = len(examples)
-    examples = subsample_examples(
-        examples,
-        cfg.get("max_train_rows"),
-        int(cfg.get("seed", 42)),
+    examples = prepare_train_examples(examples, cfg)
+    n_noul = sum(1 for e in examples if e.primitive == "noul")
+    n_neg = sum(
+        1
+        for e in examples
+        if (e.meta or {}).get("noul_negated")
+    )
+    n_rand = sum(
+        1
+        for e in examples
+        if (e.meta or {}).get("noul_random_codes")
     )
     check_manifest(paths)
-    tok = AutoTokenizer.from_pretrained(cfg["model_id"], trust_remote_code=True)
+    tok = AutoTokenizer.from_pretrained(
+        cfg["model_id"], trust_remote_code=True
+    )
     assert_single_token_codes(examples, tok)
     print(
         json.dumps(
@@ -385,6 +460,9 @@ def run_dry(paths: dict[str, Path], cfg: dict[str, Any]) -> int:
                 "mode": cfg["mode"],
                 "n_train": len(examples),
                 "n_train_full": n_full,
+                "n_noul": n_noul,
+                "n_noul_negated": n_neg,
+                "n_noul_random_codes": n_rand,
                 "max_train_rows": cfg.get("max_train_rows"),
                 "train_path": str(paths["train"]),
                 "output_dir": str(paths["output_dir"]),
@@ -401,6 +479,18 @@ def run_dry(paths: dict[str, Path], cfg: dict[str, Any]) -> int:
                 "noul_logit_bias_n": float(
                     cfg.get("noul_logit_bias_n", 2.5)
                 ),
+                "noul_random_codes": bool(
+                    cfg.get("noul_random_codes", False)
+                ),
+                "noul_negation_pairs": bool(
+                    cfg.get("noul_negation_pairs", False)
+                ),
+                "noul_consistency_weight": float(
+                    cfg.get("noul_consistency_weight", 0.0)
+                ),
+                "noul_binary_head": bool(
+                    cfg.get("noul_binary_head", False)
+                ),
             },
             indent=2,
         )
@@ -422,20 +512,20 @@ def train_one_token(
     check_manifest(paths)
     examples = load_jsonl(paths["train"])
     n_full = len(examples)
-    examples = subsample_examples(
-        examples,
-        cfg.get("max_train_rows"),
-        int(cfg.get("seed", 42)),
-    )
+    examples = prepare_train_examples(examples, cfg)
     print(
         f"train rows={len(examples)} (full={n_full} "
-        f"max_train_rows={cfg.get('max_train_rows')})",
+        f"max_train_rows={cfg.get('max_train_rows')} "
+        f"noul_random={cfg.get('noul_random_codes')} "
+        f"noul_neg={cfg.get('noul_negation_pairs')})",
         flush=True,
     )
     eval_examples = (
         load_jsonl(paths["eval"]) if paths["eval"].is_file() else None
     )
-    tok = AutoTokenizer.from_pretrained(cfg["model_id"], trust_remote_code=True)
+    tok = AutoTokenizer.from_pretrained(
+        cfg["model_id"], trust_remote_code=True
+    )
     if tok.pad_token is None:
         tok.pad_token = tok.eos_token
     assert_single_token_codes(examples, tok)
@@ -448,11 +538,15 @@ def train_one_token(
     noul_lw = float(cfg.get("noul_loss_weight", 2.0))
     noul_nw = float(cfg.get("noul_n_sample_weight", 2.0))
     noul_bias = float(cfg.get("noul_logit_bias_n", 2.5))
+    cons_w = float(cfg.get("noul_consistency_weight", 0.0))
+    use_bin = bool(cfg.get("noul_binary_head", False))
+    bin_w = float(cfg.get("noul_binary_head_weight", 1.0))
     print(
         f"one_token soft_ce={use_soft} constrained_codes={constrained} "
         f"balance_noul={balance} noul_n_frac={noul_n_frac} "
         f"noul_hard_ce={noul_hard} noul_loss_w={noul_lw} "
-        f"noul_n_w={noul_nw} noul_logit_bias_n={noul_bias}",
+        f"noul_n_w={noul_nw} noul_logit_bias_n={noul_bias} "
+        f"cons_w={cons_w} binary_head={use_bin}",
         flush=True,
     )
 
@@ -461,12 +555,20 @@ def train_one_token(
         trust_remote_code=True,
         torch_dtype=torch.float32 if device == "cpu" else "auto",
     )
+    binary_head = None
+    if use_bin:
+        import torch.nn as nn
+
+        binary_head = nn.Linear(model.config.hidden_size, 2)
+        model.add_module("noul_binary_head", binary_head)
+        model.config.output_hidden_states = True
     ds_kw = dict(
         max_length=int(cfg["max_length"]),
         use_soft=use_soft,
         noul_hard_ce=noul_hard,
         noul_loss_weight=noul_lw,
         noul_n_sample_weight=noul_nw,
+        noul_consistency=cons_w > 0,
     )
     train_ds = OneTokenDataset(examples, tok, **ds_kw)
     eval_ds = (
@@ -517,6 +619,9 @@ def train_one_token(
         trainer = CodeTokenTrainer(
             use_soft_ce=use_soft,
             train_sampler=train_sampler,
+            consistency_weight=cons_w,
+            binary_head=binary_head,
+            binary_head_weight=bin_w if use_bin else 0.0,
             **trainer_kwargs,
         )
     else:
@@ -546,6 +651,12 @@ def train_one_token(
                     "label_id",
                     "has_soft",
                     "is_noul",
+                    "yes_idx",
+                    "has_neg",
+                    "neg_input_ids",
+                    "neg_attention_mask",
+                    "neg_labels",
+                    "neg_soft_labels",
                 ):
                     inputs.pop(k, None)
                 return super().compute_loss(
@@ -568,6 +679,12 @@ def train_one_token(
         noul_logit_bias_n=noul_bias,
         noul_n_frac=noul_n_frac,
         noul_hard_ce=noul_hard,
+        noul_random_codes=bool(cfg.get("noul_random_codes", False)),
+        noul_negation_pairs=bool(
+            cfg.get("noul_negation_pairs", False)
+        ),
+        noul_consistency_weight=cons_w,
+        noul_binary_head=use_bin,
     )
     if cfg.get("push_to_hub") and cfg.get("hub_model_id"):
         trainer.push_to_hub()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oss-jev-train"
-version = "0.1.2"
+version = "0.1.4"
 description = "Qwen one-token decision-head train for OSS Jev distill (HF Jobs image)"
 readme = "README.md"
 requires-python = ">=3.10"