decision-jef 0.1.0__tar.gz

decision_jef-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Decision-Jef contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

decision_jef-0.1.0/PKG-INFO

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: decision-jef
+Version: 0.1.0
+Summary: Typed decisions with calibrated probabilities, in one forward pass
+License-Expression: MIT
+Project-URL: Homepage, https://huggingface.co/BarraHome/Decision-Jef-0.1
+Project-URL: Model, https://huggingface.co/BarraHome/Decision-Jef-0.1
+Project-URL: Issues, https://huggingface.co/BarraHome/Decision-Jef-0.1/discussions
+Keywords: typed-decisions,calibration,classification,routing,scoring,encoder,multilingual,nlp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.4
+Requires-Dist: transformers>=4.48
+Requires-Dist: huggingface-hub>=0.26
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+---
+license: mit
+base_model: jhu-clsp/mmBERT-base
+base_model_relation: finetune
+pipeline_tag: text-classification
+inference: false
+language:
+  - multilingual
+tags:
+  - system-one
+  - calibrated-decisions
+  - typed-decisions
+  - classification
+  - routing
+  - scoring
+  - guardrails
+  - moderation
+  - multilingual
+  - commercial-use
+---
+
+# Decision-Jef-0.1
+
+Answer several runtime-defined questions about one state, in a single forward
+pass, with calibrated probabilities over exactly the options you supply.
+
+307M parameters. **12.12 ms for four decisions in one forward pass.**
+
+The answer space is built from the request, so a value you did not offer is not
+representable — not merely unlikely. There is no classification head over a
+fixed label set.
+
+## Results
+
+Typed-decisions test set, 2,000 decisions: 600 `choice`, 600 `noul`, 800
+`score`. Same set and same split as the published competitors.
+
+| model | global | choice | noul | score |
+| --- | --- | --- | --- | --- |
+| Decision-1.0-Lex | **78.15** | **74.00** | 84.67 | **76.38** |
+| **Decision-Jef-0.1** | **77.00** | 73.67 | 84.33 | 74.00 |
+| Laya Typed Decisions | 76.60 | 73.33 | **85.67** | 72.25 |
+
+Ahead of Laya by 0.40 global and 1.75 on `score`. Behind Lex by 1.15 global,
+with `choice` and `noul` within a third of a point and the gap concentrated in
+`score`.
+
+| | value |
+| --- | --- |
+| NLL, choice / noul / score | 0.7200 / 0.4043 / 0.7316 |
+| ECE, 10 bins, calibrated | **0.060** |
+| ECE, 10 bins, uncalibrated | 0.138 |
+| mean confidence, calibrated | 0.827 |
+
+Temperature scaling per (type, cardinality) bucket ships with the model and is
+applied by default, taking ECE from 0.138 to **0.060**. It never changes an
+argmax, so accuracy is 77.00 either way. Pass `calibrated=False` to `decide()`
+for the raw distribution.
+
+Question isolation is exact: adding a question moves another question's logits
+by at most 3e-07.
+
+## Latency
+
+NVIDIA H100 NVL, bf16, median of 30 calls after warm-up. End to end: packing,
+encoder and readout.
+
+| questions in one call | median | p95 |
+| --- | --- | --- |
+| 1 | 11.73 ms | 14.09 ms |
+| 2 | 11.88 ms | 12.17 ms |
+| **4** | **12.12 ms** | 12.29 ms |
+
+**Going from one decision to four costs 0.39 ms.** The state is encoded once and
+the question branches are masked apart, so a request carrying four questions is
+not four requests. Throughput at batch 64 and 1,024 tokens is 2.66 ms per
+decision.
+
+## Usage
+
+```bash
+pip install decision-jef
+```
+
+The weights are published separately from the package. Authenticate with
+`hf auth login` if the model repository is not yet public, or point
+`from_pretrained` at a local directory holding `model.pt`.
+
+```python
+from decision_jef import Decider, Question
+
+d = Decider.from_pretrained("BarraHome/Decision-Jef-0.1")
+
+state = """from: user@acme.com
+subject: Duplicate charge on invoice #4411
+body: We were billed twice for March. Please refund the duplicate today
+or we will cancel our plan."""
+
+answers = d.decide(state, {
+    "department": Question("choice", "Which department should handle this?", {
+        "billing": "invoices, payments, refunds",
+        "technical": "bugs, outages, system errors",
+        "sales": "pricing, new contracts",
+        "other": "everything else",
+    }),
+    "urgency": Question("score", "How urgent is this request?",
+                        ["not urgent", "soon", "critical or blocking"]),
+    "churn_risk": Question("noul", "Does the user threaten to leave?", {
+        "false": "The user makes no threat to stop using the service.",
+        "true": "The user threatens to cancel, churn or leave.",
+    }),
+})
+
+for qid, a in answers.items():
+    print(qid, a.choice or a.p("true"), a.confidence, a.probabilities)
+```
+
+```
+department  billing  0.94  {'billing': 0.9383, 'technical': 0.0147, 'sales': 0.0301, 'other': 0.017}
+urgency     2        0.58  {'0': 0.156, '1': 0.2662, '2': 0.5778}    score=1.42
+churn_risk  0.87     0.87  {'false': 0.1292, 'true': 0.8708}
+```
+
+`d.to_wire(answers)` returns the same content as a JSON-ready response body.
+
+### Give every yes/no outcome a description
+
+This is a requirement, not a style note. The model scores the option text, so
+a bare yes/no gives it nothing to compare. On the example above:
+
+| question | p(true) with bare yes/no | p(true) with descriptions |
+| --- | --- | --- |
+| threatens to leave | 0.096 — wrong | **0.850** — right |
+| requests a refund | 0.309 — wrong | **0.912** — right |
+
+## The three question types
+
+| type | `criteria` | answer |
+| --- | --- | --- |
+| `choice` | ordered map of key to description, up to 255 | `choice`, `probabilities` |
+| `noul` | optional map of `false` and `true` to a description — supply it | `noul` probability |
+| `score` | ordered array of 2 to 10 level descriptions | probability-weighted `score`, `legend` |
+
+Option order is part of the question. The same options in a different order
+are a different request, and the model is sensitive to it — include a
+permutation check in any evaluation.
+
+## How it works
+
+```
+<bos> state ... <eos>                                    shared, encoded once
+[Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     question 1
+[Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     question 2
+```
+
+The query is read at `[DEC]`, after the whole option list, so the decision sees
+every option. Keys come from each `[OPT]` in the same pass, so the options are
+read together rather than scored in isolation. Each question attends to the
+state and to itself only; the state attends to neither.
+
+## Limitations
+
+- **ECE is 0.060 only with the shipped temperatures applied**, 0.138 without.
+  They are on by default; do not disable them unless you are recalibrating.
+- **`score` is the weakest type** at 74.00, 2.38 behind Lex.
+- Trained and measured on **English** typed decisions. The backbone is
+  multilingual and the tokenizer covers 256k tokens, but no non-English
+  benchmark has been run — treat multilingual use as untested.
+- The `guardrails` and `moderation` tags reflect coverage of toxicity and
+  hate-speech decisions. **Neither capability has been benchmarked.**
+- Sensitive to option order, as above.
+- Long states are truncated to the window with the questions reserved first.
+
+## License and provenance
+
+MIT, following the `jhu-clsp/mmBERT-base` backbone. No weights, gradients or
+private data from any third-party decision service are used or claimed; the
+design follows publicly documented API behaviour and public benchmark splits.

decision_jef-0.1.0/README.md

@@ -0,0 +1,178 @@
+---
+license: mit
+base_model: jhu-clsp/mmBERT-base
+base_model_relation: finetune
+pipeline_tag: text-classification
+inference: false
+language:
+  - multilingual
+tags:
+  - system-one
+  - calibrated-decisions
+  - typed-decisions
+  - classification
+  - routing
+  - scoring
+  - guardrails
+  - moderation
+  - multilingual
+  - commercial-use
+---
+
+# Decision-Jef-0.1
+
+Answer several runtime-defined questions about one state, in a single forward
+pass, with calibrated probabilities over exactly the options you supply.
+
+307M parameters. **12.12 ms for four decisions in one forward pass.**
+
+The answer space is built from the request, so a value you did not offer is not
+representable — not merely unlikely. There is no classification head over a
+fixed label set.
+
+## Results
+
+Typed-decisions test set, 2,000 decisions: 600 `choice`, 600 `noul`, 800
+`score`. Same set and same split as the published competitors.
+
+| model | global | choice | noul | score |
+| --- | --- | --- | --- | --- |
+| Decision-1.0-Lex | **78.15** | **74.00** | 84.67 | **76.38** |
+| **Decision-Jef-0.1** | **77.00** | 73.67 | 84.33 | 74.00 |
+| Laya Typed Decisions | 76.60 | 73.33 | **85.67** | 72.25 |
+
+Ahead of Laya by 0.40 global and 1.75 on `score`. Behind Lex by 1.15 global,
+with `choice` and `noul` within a third of a point and the gap concentrated in
+`score`.
+
+| | value |
+| --- | --- |
+| NLL, choice / noul / score | 0.7200 / 0.4043 / 0.7316 |
+| ECE, 10 bins, calibrated | **0.060** |
+| ECE, 10 bins, uncalibrated | 0.138 |
+| mean confidence, calibrated | 0.827 |
+
+Temperature scaling per (type, cardinality) bucket ships with the model and is
+applied by default, taking ECE from 0.138 to **0.060**. It never changes an
+argmax, so accuracy is 77.00 either way. Pass `calibrated=False` to `decide()`
+for the raw distribution.
+
+Question isolation is exact: adding a question moves another question's logits
+by at most 3e-07.
+
+## Latency
+
+NVIDIA H100 NVL, bf16, median of 30 calls after warm-up. End to end: packing,
+encoder and readout.
+
+| questions in one call | median | p95 |
+| --- | --- | --- |
+| 1 | 11.73 ms | 14.09 ms |
+| 2 | 11.88 ms | 12.17 ms |
+| **4** | **12.12 ms** | 12.29 ms |
+
+**Going from one decision to four costs 0.39 ms.** The state is encoded once and
+the question branches are masked apart, so a request carrying four questions is
+not four requests. Throughput at batch 64 and 1,024 tokens is 2.66 ms per
+decision.
+
+## Usage
+
+```bash
+pip install decision-jef
+```
+
+The weights are published separately from the package. Authenticate with
+`hf auth login` if the model repository is not yet public, or point
+`from_pretrained` at a local directory holding `model.pt`.
+
+```python
+from decision_jef import Decider, Question
+
+d = Decider.from_pretrained("BarraHome/Decision-Jef-0.1")
+
+state = """from: user@acme.com
+subject: Duplicate charge on invoice #4411
+body: We were billed twice for March. Please refund the duplicate today
+or we will cancel our plan."""
+
+answers = d.decide(state, {
+    "department": Question("choice", "Which department should handle this?", {
+        "billing": "invoices, payments, refunds",
+        "technical": "bugs, outages, system errors",
+        "sales": "pricing, new contracts",
+        "other": "everything else",
+    }),
+    "urgency": Question("score", "How urgent is this request?",
+                        ["not urgent", "soon", "critical or blocking"]),
+    "churn_risk": Question("noul", "Does the user threaten to leave?", {
+        "false": "The user makes no threat to stop using the service.",
+        "true": "The user threatens to cancel, churn or leave.",
+    }),
+})
+
+for qid, a in answers.items():
+    print(qid, a.choice or a.p("true"), a.confidence, a.probabilities)
+```
+
+```
+department  billing  0.94  {'billing': 0.9383, 'technical': 0.0147, 'sales': 0.0301, 'other': 0.017}
+urgency     2        0.58  {'0': 0.156, '1': 0.2662, '2': 0.5778}    score=1.42
+churn_risk  0.87     0.87  {'false': 0.1292, 'true': 0.8708}
+```
+
+`d.to_wire(answers)` returns the same content as a JSON-ready response body.
+
+### Give every yes/no outcome a description
+
+This is a requirement, not a style note. The model scores the option text, so
+a bare yes/no gives it nothing to compare. On the example above:
+
+| question | p(true) with bare yes/no | p(true) with descriptions |
+| --- | --- | --- |
+| threatens to leave | 0.096 — wrong | **0.850** — right |
+| requests a refund | 0.309 — wrong | **0.912** — right |
+
+## The three question types
+
+| type | `criteria` | answer |
+| --- | --- | --- |
+| `choice` | ordered map of key to description, up to 255 | `choice`, `probabilities` |
+| `noul` | optional map of `false` and `true` to a description — supply it | `noul` probability |
+| `score` | ordered array of 2 to 10 level descriptions | probability-weighted `score`, `legend` |
+
+Option order is part of the question. The same options in a different order
+are a different request, and the model is sensitive to it — include a
+permutation check in any evaluation.
+
+## How it works
+
+```
+<bos> state ... <eos>                                    shared, encoded once
+[Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     question 1
+[Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     question 2
+```
+
+The query is read at `[DEC]`, after the whole option list, so the decision sees
+every option. Keys come from each `[OPT]` in the same pass, so the options are
+read together rather than scored in isolation. Each question attends to the
+state and to itself only; the state attends to neither.
+
+## Limitations
+
+- **ECE is 0.060 only with the shipped temperatures applied**, 0.138 without.
+  They are on by default; do not disable them unless you are recalibrating.
+- **`score` is the weakest type** at 74.00, 2.38 behind Lex.
+- Trained and measured on **English** typed decisions. The backbone is
+  multilingual and the tokenizer covers 256k tokens, but no non-English
+  benchmark has been run — treat multilingual use as untested.
+- The `guardrails` and `moderation` tags reflect coverage of toxicity and
+  hate-speech decisions. **Neither capability has been benchmarked.**
+- Sensitive to option order, as above.
+- Long states are truncated to the window with the questions reserved first.
+
+## License and provenance
+
+MIT, following the `jhu-clsp/mmBERT-base` backbone. No weights, gradients or
+private data from any third-party decision service are used or claimed; the
+design follows publicly documented API behaviour and public benchmark splits.

decision_jef-0.1.0/decision_jef/__init__.py

@@ -0,0 +1,22 @@
+"""Decision-Jef: typed decisions with calibrated probabilities.
+
+    from decision_jef import Decider, Question
+
+    d = Decider.from_pretrained("BarraHome/Decision-Jef-0.1")
+    out = d.decide(
+        state="Payouts have failed three times. The bank says everything is fine.",
+        questions={
+            "queue": Question("choice", "Which team should handle this?",
+                              {"payments": "Payout failures",
+                               "account": "Login and account access",
+                               "other": "Something else"}),
+            "escalate": Question("noul", "Does this need urgent human attention?"),
+            "mood": Question("score", "How frustrated is the customer?",
+                             ["Calm", "Frustrated", "Very angry"]),
+        },
+    )
+"""
+from decision_jef.infer import Decider
+from decision_jef.wire import Answer, Question, Request
+
+__all__ = ["Decider", "Question", "Request", "Answer"]

decision_jef-0.1.0/decision_jef/infer.py

@@ -0,0 +1,130 @@
+"""Inference API.
+
+The answer space is built from the request, so the model cannot return a value
+you did not offer. Probabilities are temperature-scaled per (type, cardinality)
+bucket, with the temperatures fitted on a held-out calibration split.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Dict, Optional, Sequence
+
+import torch
+
+from decision_jef.model import DecisionJef
+from decision_jef.pack import pack
+from decision_jef.wire import Answer, Question, Request
+
+# Two decimal places is what a reported probability is worth here, so a
+# floor well below that costs no information and avoids claiming certainty.
+PROB_FLOOR = 1e-4
+
+
+class Decider:
+    def __init__(self, model: DecisionJef, tokenizer, temperatures=None,
+                 max_len: int = 1024):
+        self.model = model.eval()
+        self.tok = tokenizer
+        self.temperatures = temperatures or {}
+        self.max_len = max_len
+
+    @classmethod
+    def from_pretrained(cls, repo_or_path: str, device: str = "auto",
+                        max_len: int = 1024) -> "Decider":
+        from huggingface_hub import hf_hub_download
+        from transformers import AutoTokenizer
+
+        def grab(name):
+            if os.path.isdir(repo_or_path):
+                p = os.path.join(repo_or_path, name)
+                return p if os.path.exists(p) else None
+            try:
+                return hf_hub_download(repo_or_path, name)
+            except Exception:
+                return None
+
+        weights = grab("model.pt")
+        if weights is None:
+            raise FileNotFoundError(
+                f"No model.pt in {repo_or_path!r}.\n"
+                "The weights are published separately from this package. If the "
+                "repository is private or gated, authenticate first with "
+                "`hf auth login`, or pass a local directory containing model.pt.\n"
+                "See https://huggingface.co/BarraHome/Decision-Jef-0.1")
+        if device == "auto":
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+        dev = torch.device(device)
+        ck = torch.load(weights, map_location=dev, weights_only=False)
+        cfg = dict(ck["config"])
+        # Read any unrecorded geometry flag off the weights rather than
+        # trusting a default that may have changed.
+        if "noul_head" not in cfg:
+            cfg["noul_head"] = any(k.startswith("noul_head.") for k in ck["model"])
+        model = DecisionJef(**cfg).to(dev)
+        model.load_state_dict(ck["model"])
+        tok = AutoTokenizer.from_pretrained(cfg["model_name"])
+        temps = ck.get("temperatures") or {}
+        tf = grab("temperatures.json")
+        if not temps and tf:
+            with open(tf) as fh:
+                temps = json.load(fh)
+        return cls(model, tok, temps, max_len)
+
+    def _temp(self, kind: str, n: int) -> float:
+        from decision_jef.model import temperature_bucket
+        b = temperature_bucket(kind, n)
+        return float(self.temperatures.get(b, self.temperatures.get("_global", 1.0)))
+
+    @torch.no_grad()
+    def decide(self, state: str, questions: Dict[str, Question],
+               calibrated: bool = True) -> Dict[str, Answer]:
+        """One forward pass for every question. Questions cannot see each
+        other, so adding one never changes another's answer."""
+        req = Request(state, questions)
+        dev = next(self.model.parameters()).device
+        batch = pack([req], self.tok, self.max_len).to(dev)
+        logits = self.model(batch).float()
+        out: Dict[str, Answer] = {}
+        counts = batch.opt_mask.sum(-1).tolist()
+        for i, (qid, kind, keys) in enumerate(
+                zip(batch.qids, batch.kinds, batch.keys)):
+            row = logits[i]
+            if calibrated:
+                row = row / self._temp(kind, int(counts[i]))
+            p = torch.softmax(row[: len(keys)], -1).cpu().tolist()
+            # Never report certainty. Sharpening temperatures (around 0.34
+            # here) can drive a confident logit gap to a rounded 1.0, and a
+            # probability of exactly 1 claims the answer cannot be wrong.
+            # Clamp and renormalise so the distribution still sums to 1.
+            p = [min(max(v, PROB_FLOOR), 1.0 - PROB_FLOOR) for v in p]
+            total = sum(p)
+            p = [v / total for v in p]
+            d = {k: round(float(v), 4) for k, v in zip(keys, p)}
+            best = max(d, key=d.get)
+            out[qid] = Answer(
+                kind=kind, probabilities=d,
+                choice=best if kind != "noul" else None,
+                score=round(sum(j * v for j, v in enumerate(p)), 4)
+                if kind == "score" else None,
+                legend={str(j): t for j, t in enumerate(questions[qid].descriptions)}
+                if kind == "score" else None,
+                confidence=round(max(p), 4))
+        return out
+
+    def to_wire(self, answers: Dict[str, Answer]) -> dict:
+        """The response body, ready to serialise."""
+        body = {"model": "Decision-Jef-0.1", "answers": {}}
+        for qid, a in answers.items():
+            d = {"type": a.kind, "probabilities": a.probabilities,
+                 "confidence": a.confidence}
+            if a.kind == "noul":
+                d["noul"] = a.probabilities.get("true", 0.0)
+            else:
+                d["choice"] = a.choice
+                if a.kind == "score":
+                    d["score"] = a.score
+                    d["legend"] = a.legend
+            body["answers"][qid] = d
+        return body

decision_jef-0.1.0/decision_jef/model.py

@@ -0,0 +1,161 @@
+"""Decision-Jef.
+
+    h      = encoder(state + question blocks)
+    query  = q_proj(h[DEC])        one per question
+    keys   = o_proj(h[OPT_i])      one per option, in order
+    logits = <query, key_i> * scale
+
+The query is read after the whole option list, so the decision sees every
+option. The keys come from the same pass, so the options are read together
+rather than scored in isolation.
+
+The answer space is exactly the options supplied at call time. There is no
+classification head over a fixed label set, so a value you did not offer is
+not representable.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import AutoConfig, AutoModel
+from transformers.models.modernbert.modeling_modernbert import (
+    create_bidirectional_mask,
+    create_bidirectional_sliding_window_mask,
+)
+
+from decision_jef.pack import Packed, segment_attention_mask
+
+KINDS = ("choice", "noul", "score")
+
+
+class DecisionJef(nn.Module):
+    def __init__(self, model_name: str = "jhu-clsp/mmBERT-base",
+                 proj_dim: int = 256, dropout: float = 0.0,
+                 trainable_layers: int = -1, isolate_questions: bool = True,
+                 noul_head: bool = True):
+        super().__init__()
+        cfg = AutoConfig.from_pretrained(model_name)
+        cfg.attention_dropout = dropout
+        self.encoder = AutoModel.from_pretrained(model_name, config=cfg)
+        self.config = self.encoder.config
+        d = self.config.hidden_size
+        self.isolate_questions = isolate_questions
+
+        # Separate projections for the question and the option side.
+        self.q_proj = nn.Sequential(nn.LayerNorm(d), nn.Linear(d, proj_dim))
+        self.o_proj = nn.Sequential(nn.LayerNorm(d), nn.Linear(d, proj_dim))
+        # Learned temperature on normalised vectors.
+        self.logit_scale = nn.Parameter(torch.tensor(2.996))
+        # A yes/no question's two options are restatements of its
+        # instructions, so its two logits are read straight off [DEC].
+        # The outcome space is still exactly two.
+        self.noul_head = nn.Sequential(
+            nn.LayerNorm(d), nn.Linear(d, d), nn.GELU(), nn.Linear(d, 2)
+        ) if noul_head else None
+        self.model_name = model_name
+        self.proj_dim = proj_dim
+        self.use_noul_head = noul_head
+        self.set_trainable(trainable_layers)
+
+    def set_trainable(self, n: int):
+        """n < 0 unfreezes the whole encoder; n >= 0 keeps the top n layers."""
+        if n < 0:
+            for p in self.encoder.parameters():
+                p.requires_grad_(True)
+            return
+        for p in self.encoder.parameters():
+            p.requires_grad_(False)
+        for layer in list(self.encoder.layers)[len(self.encoder.layers) - n:]:
+            for p in layer.parameters():
+                p.requires_grad_(True)
+        if hasattr(self.encoder, "final_norm"):
+            for p in self.encoder.final_norm.parameters():
+                p.requires_grad_(True)
+
+    def _masks(self, batch: Packed, hidden) -> Dict[str, torch.Tensor]:
+        """The encoder's own masks, restricted to the per-question segments."""
+        kw = dict(config=self.config, inputs_embeds=hidden,
+                  attention_mask=batch.attention_mask)
+        masks = {"full_attention": create_bidirectional_mask(**kw),
+                 "sliding_attention": create_bidirectional_sliding_window_mask(**kw)}
+        if not self.isolate_questions:
+            return masks
+
+        allowed = segment_attention_mask(batch.segment_ids, batch.attention_mask)
+        out = {}
+        for name, m in masks.items():
+            if m is None:
+                # The constructors return None when a batch has no padding,
+                # so build the mask here.
+                base = allowed.clone()
+                if name == "sliding_attention":
+                    base = base & self._window(batch)
+                out[name] = base
+            elif m.dtype == torch.bool:
+                out[name] = m & allowed
+            else:
+                # Finite large negative, not -inf: a fully masked row with
+                # -inf yields NaN.
+                out[name] = m.masked_fill(~allowed, -1e4)
+        return out
+
+    def _window(self, batch: Packed) -> torch.Tensor:
+        """The local-attention band the sliding layers use, [1, 1, L, L] bool."""
+        L = batch.input_ids.shape[1]
+        half = self.config.local_attention // 2
+        idx = torch.arange(L, device=batch.input_ids.device)
+        band = (idx.unsqueeze(1) - idx.unsqueeze(0)).abs() <= half
+        return band.unsqueeze(0).unsqueeze(0)
+
+    def forward(self, batch: Packed, restrict: bool = True) -> torch.Tensor:
+        hidden = self.encoder.embeddings(input_ids=batch.input_ids)
+        h = self.encoder(input_ids=batch.input_ids,
+                         attention_mask=self._masks(batch, hidden)).last_hidden_state
+
+        flat = batch.batch_idx
+        q = h[flat, batch.dec_pos]                                  # [Nq, D]
+        qv = F.normalize(self.q_proj(q), dim=-1)
+
+        Nq, mo = batch.opt_pos.shape
+        rows = flat.unsqueeze(1).expand(Nq, mo)
+        o = h[rows.reshape(-1), batch.opt_pos.reshape(-1)]          # [Nq*mo, D]
+        ov = F.normalize(self.o_proj(o), dim=-1).view(Nq, mo, -1)
+
+        logits = (qv.unsqueeze(1) * ov).sum(-1) * self.logit_scale.exp()
+
+        if self.noul_head is not None and batch.kinds:
+            is_noul = torch.tensor([k == "noul" for k in batch.kinds],
+                                   device=logits.device)
+            if bool(is_noul.any()):
+                direct = self.noul_head(q)                      # [Nq, 2]
+                pad = logits.shape[1] - 2
+                if pad > 0:
+                    direct = torch.cat(
+                        [direct, direct.new_full((direct.shape[0], pad), -1e4)], 1)
+                logits = torch.where(is_noul.unsqueeze(1), direct[:, : logits.shape[1]],
+                                     logits)
+
+        if restrict:
+            logits = logits.masked_fill(~batch.opt_mask, -1e4)
+        return logits
+
+    def trainable_parameters(self) -> int:
+        return sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+
+def temperature_bucket(kind: str, n_options: int) -> str:
+    """Which temperature applies to a question of this type and size."""
+    if kind == "noul":
+        return "noul"
+    if kind == "score":
+        return f"score:{n_options}"
+
+    if n_options <= 3:
+        return "choice:2-3"
+    if n_options <= 6:
+        return "choice:4-6"
+    return "choice:7+"

decision_jef-0.1.0/decision_jef/pack.py

@@ -0,0 +1,157 @@
+"""Turn a request into one input sequence.
+
+Layout:
+
+    <bos> state ... <eos>                                    segment 0, shared
+    [Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     segment 1
+    [Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     segment 2
+
+The options of a question sit inline, in the order given. The [DEC] marker
+closes each question's block. Every question attends to the state and to
+itself only, and the state attends to neither, so adding a question never
+changes another question's answer.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional, Sequence, Tuple
+
+import torch
+
+from decision_jef.wire import Question, Request
+
+OPT_MARKER = "<unused0>"
+DEC_MARKER = "<unused1>"
+Q_MARKER = "<unused2>"
+
+# Reserve room for the questions first, then give the state whatever is left,
+# so a large schema is never silently truncated away.
+MIN_STATE_TOKENS = 16
+
+
+@dataclass
+class Packed:
+    input_ids: torch.Tensor        # [B, L]
+    attention_mask: torch.Tensor   # [B, L] 1 = real token
+    segment_ids: torch.Tensor      # [B, L] 0 = state, i+1 = question i
+    dec_pos: torch.Tensor          # [Nq] index of each question's [DEC]
+    opt_pos: torch.Tensor          # [Nq, max_opts] index of each [OPT]
+    opt_mask: torch.Tensor         # [Nq, max_opts] True = real option
+    batch_idx: torch.Tensor        # [Nq] which row of the batch
+    kinds: List[str]               # [Nq]
+    qids: List[str]                # [Nq]
+    keys: List[List[str]]          # [Nq][n_opts] answer keys, in order
+    dropped: int = 0               # questions that did not fit
+
+    def to(self, device) -> "Packed":
+        d = {k: (v.to(device) if torch.is_tensor(v) else v)
+             for k, v in self.__dict__.items()}
+        return Packed(**d)
+
+
+def _question_block(tok, q: Question, kind_prefix: bool = True) -> Tuple[List[int], List[int], int]:
+    """Token ids for one question, plus the offsets of its [OPT] markers and
+    its [DEC] marker, relative to the block start."""
+    opt_id = tok.convert_tokens_to_ids(OPT_MARKER)
+    dec_id = tok.convert_tokens_to_ids(DEC_MARKER)
+    q_id = tok.convert_tokens_to_ids(Q_MARKER)
+
+    enc = lambda s: tok(s, add_special_tokens=False)["input_ids"]
+    # The question type is named in the text rather than carried by a separate
+    # type embedding.
+    head = f"{q.kind} question: {q.instructions}" if kind_prefix else q.instructions
+    ids = [q_id] + enc(head)
+    opts = []
+    for i, desc in enumerate(q.descriptions):
+        # Ordinal rank is written into the level text, so the levels carry
+        # their order.
+        text = f"level {i}: {desc}" if q.kind == "score" else desc
+        opts.append(len(ids))
+        ids.append(opt_id)
+        ids.extend(enc(text)[:48])          # option text cap
+    dec = len(ids)
+    ids.append(dec_id)
+    return ids, opts, dec
+
+
+def pack(requests: Sequence[Request], tok, max_len: int = 1024,
+         kinds: Optional[Sequence[str]] = None) -> Packed:
+    bos = tok.bos_token_id if tok.bos_token_id is not None else tok.cls_token_id
+    eos = tok.eos_token_id if tok.eos_token_id is not None else tok.sep_token_id
+    pad = tok.pad_token_id
+    enc = lambda s: tok(s, add_special_tokens=False)["input_ids"]
+
+    rows, seg_rows, per_q, dropped = [], [], [], 0
+    for b, req in enumerate(requests):
+        blocks = []
+        for qid, q in req.questions.items():
+            if len(q.keys) < 2:
+                dropped += 1
+                continue
+            blocks.append((qid, q) + _question_block(tok, q))
+        budget = max_len - 2 - sum(len(ids) for *_, ids, _, _ in
+                                   [(0, 0, b[2], b[3], b[4]) for b in blocks])
+        state = enc(req.state)[:max(MIN_STATE_TOKENS, budget)]
+
+        ids = [bos] + state + [eos]
+        seg = [0] * len(ids)
+        for qi, (qid, q, blk, opts, dec) in enumerate(blocks):
+            if len(ids) + len(blk) > max_len:
+                dropped += 1
+                continue
+            base = len(ids)
+            ids.extend(blk)
+            seg.extend([qi + 1] * len(blk))
+            per_q.append(dict(batch=b, qid=qid, kind=q.kind, keys=q.keys,
+                              dec=base + dec, opts=[base + o for o in opts]))
+        rows.append(ids)
+        seg_rows.append(seg)
+
+    B, L = len(rows), max(len(r) for r in rows)
+    input_ids = torch.full((B, L), pad, dtype=torch.long)
+    attn = torch.zeros((B, L), dtype=torch.long)
+    segs = torch.zeros((B, L), dtype=torch.long)
+    for i, (r, s) in enumerate(zip(rows, seg_rows)):
+        input_ids[i, : len(r)] = torch.tensor(r)
+        attn[i, : len(r)] = 1
+        segs[i, : len(s)] = torch.tensor(s)
+
+    Nq = len(per_q)
+    mo = max((len(p["opts"]) for p in per_q), default=1)
+    dec_pos = torch.zeros(Nq, dtype=torch.long)
+    opt_pos = torch.zeros((Nq, mo), dtype=torch.long)
+    opt_mask = torch.zeros((Nq, mo), dtype=torch.bool)
+    batch_idx = torch.zeros(Nq, dtype=torch.long)
+    for i, p in enumerate(per_q):
+        dec_pos[i] = p["dec"]
+        batch_idx[i] = p["batch"]
+        for j, o in enumerate(p["opts"]):
+            opt_pos[i, j] = o
+            opt_mask[i, j] = True
+
+    return Packed(input_ids=input_ids, attention_mask=attn, segment_ids=segs,
+                  dec_pos=dec_pos, opt_pos=opt_pos, opt_mask=opt_mask,
+                  batch_idx=batch_idx,
+                  kinds=[p["kind"] for p in per_q],
+                  qids=[p["qid"] for p in per_q],
+                  keys=[p["keys"] for p in per_q],
+                  dropped=dropped)
+
+
+def segment_attention_mask(segment_ids: torch.Tensor,
+                           attention_mask: torch.Tensor) -> torch.Tensor:
+    """[B, 1, L, L] boolean: True where attention is allowed.
+
+    A position may attend to the state (segment 0) and to its own segment.
+    The state may not attend to any question, which is what makes the state
+    encoding identical no matter which questions accompany it.
+    """
+    sq = segment_ids.unsqueeze(2)                     # querying position
+    sk = segment_ids.unsqueeze(1)                     # key position
+    allowed = ((sk == 0) | (sq == sk)) & (sq != 0) | ((sq == 0) & (sk == 0))
+    allowed = allowed & attention_mask.bool().unsqueeze(1)
+    L = segment_ids.shape[-1]
+    eye = torch.arange(L, device=segment_ids.device)
+    allowed[:, eye, eye] = True                       # never mask a row entirely
+    return allowed.unsqueeze(1)

decision_jef-0.1.0/decision_jef/wire.py

@@ -0,0 +1,141 @@
+"""The request and response types.
+
+  choice  criteria is an ordered map of option key -> description, up to 255.
+  noul    yes/no. The answer is one probability.
+  score   criteria is an ordered array of 2 to 10 level descriptions. The
+          answer adds a legend and a probability-weighted score.
+
+Every container preserves insertion order: option order is part of the
+question, and nothing here sorts keys.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Sequence, Union
+
+KINDS = ("choice", "noul", "score")
+MAX_CHOICE_OPTIONS = 255          # 2**8 - 1
+MAX_SCORE_LEVELS = 10
+MIN_SCORE_LEVELS = 2
+
+
+@dataclass
+class Question:
+    kind: str
+    instructions: str
+    # choice: ordered {key: description}. score: ordered [description, ...].
+    # noul: empty.
+    criteria: Union[Dict[str, str], List[str], None] = None
+
+    def __post_init__(self):
+        if self.kind not in KINDS:
+            raise ValueError(f"unknown kind {self.kind!r}; expected one of {KINDS}")
+        if self.kind == "choice":
+            if not isinstance(self.criteria, dict) or len(self.criteria) < 2:
+                raise ValueError("choice needs an ordered map of at least 2 options")
+            if len(self.criteria) > MAX_CHOICE_OPTIONS:
+                raise ValueError(f"choice accepts at most {MAX_CHOICE_OPTIONS} options")
+        elif self.kind == "score":
+            if not isinstance(self.criteria, (list, tuple)):
+                raise ValueError("score needs an ordered array of level descriptions")
+            if not MIN_SCORE_LEVELS <= len(self.criteria) <= MAX_SCORE_LEVELS:
+                raise ValueError(
+                    f"score needs {MIN_SCORE_LEVELS} to {MAX_SCORE_LEVELS} levels")
+        elif self.criteria is not None:
+            # A noul question may optionally carry descriptions for false and
+            # true; anything else is rejected.
+            if not isinstance(self.criteria, dict) or \
+                    {k.lower() for k in self.criteria} != {"false", "true"}:
+                raise ValueError("noul criteria must be exactly false and true")
+
+    @property
+    def keys(self) -> List[str]:
+        """The answer keys, in order. Score levels are indexed from 0 as strings,
+        which is how the API returns them in `probabilities` and `legend`."""
+        if self.kind == "choice":
+            return list(self.criteria)
+        if self.kind == "score":
+            return [str(i) for i in range(len(self.criteria))]
+        return ["false", "true"]        # noul reports p(true) as `noul`
+
+    @property
+    def descriptions(self) -> List[str]:
+        """Option text in the same order as `keys`. A noul question has no
+        option text at all -- its two outcomes are implicit."""
+        if self.kind == "choice":
+            return list(self.criteria.values())
+        if self.kind == "score":
+            return list(self.criteria)
+        if self.criteria:
+            low = {k.lower(): v for k, v in self.criteria.items()}
+            return [low["false"], low["true"]]
+        return ["no", "yes"]
+
+
+@dataclass
+class Request:
+    state: str
+    questions: Dict[str, Question]          # ordered
+    model: str = "jev-latest"
+
+    def to_json(self) -> dict:
+        out = {"model": self.model, "state": self.state, "questions": {}}
+        for qid, q in self.questions.items():
+            d = {"type": q.kind, "instructions": q.instructions}
+            if q.kind == "choice":
+                d["criteria"] = dict(q.criteria)
+            elif q.kind == "score":
+                d["criteria"] = list(q.criteria)
+            out["questions"][qid] = d
+        return out
+
+    @classmethod
+    def from_json(cls, d: dict) -> "Request":
+        qs = {}
+        for qid, q in d["questions"].items():
+            qs[qid] = Question(q["type"], q["instructions"], q.get("criteria"))
+        return cls(state=d["state"], questions=qs, model=d.get("model", "jev-latest"))
+
+
+@dataclass
+class Answer:
+    kind: str
+    probabilities: Dict[str, float]         # ordered, sums to 1
+    choice: Optional[str] = None
+    score: Optional[float] = None
+    legend: Optional[Dict[str, str]] = None
+    confidence: Optional[float] = None
+
+    @classmethod
+    def from_json(cls, d: dict) -> "Answer":
+        kind = d["type"]
+        if kind == "noul":
+            # The API returns a single `noul` probability, not a distribution.
+            # Expand it so every kind reads the same downstream.
+            p = float(d["noul"])
+            probs = {"false": 1.0 - p, "true": p}
+        else:
+            probs = {k: float(v) for k, v in d["probabilities"].items()}
+        return cls(kind=kind, probabilities=probs, choice=d.get("choice"),
+                   score=d.get("score"), legend=d.get("legend"),
+                   confidence=d.get("confidence"))
+
+    def p(self, key: str) -> float:
+        return self.probabilities.get(key, 0.0)
+
+    def log_odds(self, a: str, b: str, floor: float = 5e-3) -> float:
+        """Log odds of one key against another.
+
+        The API rounds probabilities to two decimals, so a reported 0.00 is a
+        reporting floor and could be anything under 0.005. Clamping to that
+        floor keeps the ratio finite and states the assumption in one place.
+        """
+        import math
+        return math.log(max(self.p(a), floor) / max(self.p(b), floor))
+
+
+def answers_from_response(d: dict) -> Dict[str, Answer]:
+    return {qid: Answer.from_json(a) for qid, a in d["answers"].items()}
+

decision_jef-0.1.0/decision_jef.egg-info/PKG-INFO

@@ -0,0 +1,209 @@
+Metadata-Version: 2.4
+Name: decision-jef
+Version: 0.1.0
+Summary: Typed decisions with calibrated probabilities, in one forward pass
+License-Expression: MIT
+Project-URL: Homepage, https://huggingface.co/BarraHome/Decision-Jef-0.1
+Project-URL: Model, https://huggingface.co/BarraHome/Decision-Jef-0.1
+Project-URL: Issues, https://huggingface.co/BarraHome/Decision-Jef-0.1/discussions
+Keywords: typed-decisions,calibration,classification,routing,scoring,encoder,multilingual,nlp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.4
+Requires-Dist: transformers>=4.48
+Requires-Dist: huggingface-hub>=0.26
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+---
+license: mit
+base_model: jhu-clsp/mmBERT-base
+base_model_relation: finetune
+pipeline_tag: text-classification
+inference: false
+language:
+  - multilingual
+tags:
+  - system-one
+  - calibrated-decisions
+  - typed-decisions
+  - classification
+  - routing
+  - scoring
+  - guardrails
+  - moderation
+  - multilingual
+  - commercial-use
+---
+
+# Decision-Jef-0.1
+
+Answer several runtime-defined questions about one state, in a single forward
+pass, with calibrated probabilities over exactly the options you supply.
+
+307M parameters. **12.12 ms for four decisions in one forward pass.**
+
+The answer space is built from the request, so a value you did not offer is not
+representable — not merely unlikely. There is no classification head over a
+fixed label set.
+
+## Results
+
+Typed-decisions test set, 2,000 decisions: 600 `choice`, 600 `noul`, 800
+`score`. Same set and same split as the published competitors.
+
+| model | global | choice | noul | score |
+| --- | --- | --- | --- | --- |
+| Decision-1.0-Lex | **78.15** | **74.00** | 84.67 | **76.38** |
+| **Decision-Jef-0.1** | **77.00** | 73.67 | 84.33 | 74.00 |
+| Laya Typed Decisions | 76.60 | 73.33 | **85.67** | 72.25 |
+
+Ahead of Laya by 0.40 global and 1.75 on `score`. Behind Lex by 1.15 global,
+with `choice` and `noul` within a third of a point and the gap concentrated in
+`score`.
+
+| | value |
+| --- | --- |
+| NLL, choice / noul / score | 0.7200 / 0.4043 / 0.7316 |
+| ECE, 10 bins, calibrated | **0.060** |
+| ECE, 10 bins, uncalibrated | 0.138 |
+| mean confidence, calibrated | 0.827 |
+
+Temperature scaling per (type, cardinality) bucket ships with the model and is
+applied by default, taking ECE from 0.138 to **0.060**. It never changes an
+argmax, so accuracy is 77.00 either way. Pass `calibrated=False` to `decide()`
+for the raw distribution.
+
+Question isolation is exact: adding a question moves another question's logits
+by at most 3e-07.
+
+## Latency
+
+NVIDIA H100 NVL, bf16, median of 30 calls after warm-up. End to end: packing,
+encoder and readout.
+
+| questions in one call | median | p95 |
+| --- | --- | --- |
+| 1 | 11.73 ms | 14.09 ms |
+| 2 | 11.88 ms | 12.17 ms |
+| **4** | **12.12 ms** | 12.29 ms |
+
+**Going from one decision to four costs 0.39 ms.** The state is encoded once and
+the question branches are masked apart, so a request carrying four questions is
+not four requests. Throughput at batch 64 and 1,024 tokens is 2.66 ms per
+decision.
+
+## Usage
+
+```bash
+pip install decision-jef
+```
+
+The weights are published separately from the package. Authenticate with
+`hf auth login` if the model repository is not yet public, or point
+`from_pretrained` at a local directory holding `model.pt`.
+
+```python
+from decision_jef import Decider, Question
+
+d = Decider.from_pretrained("BarraHome/Decision-Jef-0.1")
+
+state = """from: user@acme.com
+subject: Duplicate charge on invoice #4411
+body: We were billed twice for March. Please refund the duplicate today
+or we will cancel our plan."""
+
+answers = d.decide(state, {
+    "department": Question("choice", "Which department should handle this?", {
+        "billing": "invoices, payments, refunds",
+        "technical": "bugs, outages, system errors",
+        "sales": "pricing, new contracts",
+        "other": "everything else",
+    }),
+    "urgency": Question("score", "How urgent is this request?",
+                        ["not urgent", "soon", "critical or blocking"]),
+    "churn_risk": Question("noul", "Does the user threaten to leave?", {
+        "false": "The user makes no threat to stop using the service.",
+        "true": "The user threatens to cancel, churn or leave.",
+    }),
+})
+
+for qid, a in answers.items():
+    print(qid, a.choice or a.p("true"), a.confidence, a.probabilities)
+```
+
+```
+department  billing  0.94  {'billing': 0.9383, 'technical': 0.0147, 'sales': 0.0301, 'other': 0.017}
+urgency     2        0.58  {'0': 0.156, '1': 0.2662, '2': 0.5778}    score=1.42
+churn_risk  0.87     0.87  {'false': 0.1292, 'true': 0.8708}
+```
+
+`d.to_wire(answers)` returns the same content as a JSON-ready response body.
+
+### Give every yes/no outcome a description
+
+This is a requirement, not a style note. The model scores the option text, so
+a bare yes/no gives it nothing to compare. On the example above:
+
+| question | p(true) with bare yes/no | p(true) with descriptions |
+| --- | --- | --- |
+| threatens to leave | 0.096 — wrong | **0.850** — right |
+| requests a refund | 0.309 — wrong | **0.912** — right |
+
+## The three question types
+
+| type | `criteria` | answer |
+| --- | --- | --- |
+| `choice` | ordered map of key to description, up to 255 | `choice`, `probabilities` |
+| `noul` | optional map of `false` and `true` to a description — supply it | `noul` probability |
+| `score` | ordered array of 2 to 10 level descriptions | probability-weighted `score`, `legend` |
+
+Option order is part of the question. The same options in a different order
+are a different request, and the model is sensitive to it — include a
+permutation check in any evaluation.
+
+## How it works
+
+```
+<bos> state ... <eos>                                    shared, encoded once
+[Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     question 1
+[Q] instructions ... [OPT] opt0 [OPT] opt1 ... [DEC]     question 2
+```
+
+The query is read at `[DEC]`, after the whole option list, so the decision sees
+every option. Keys come from each `[OPT]` in the same pass, so the options are
+read together rather than scored in isolation. Each question attends to the
+state and to itself only; the state attends to neither.
+
+## Limitations
+
+- **ECE is 0.060 only with the shipped temperatures applied**, 0.138 without.
+  They are on by default; do not disable them unless you are recalibrating.
+- **`score` is the weakest type** at 74.00, 2.38 behind Lex.
+- Trained and measured on **English** typed decisions. The backbone is
+  multilingual and the tokenizer covers 256k tokens, but no non-English
+  benchmark has been run — treat multilingual use as untested.
+- The `guardrails` and `moderation` tags reflect coverage of toxicity and
+  hate-speech decisions. **Neither capability has been benchmarked.**
+- Sensitive to option order, as above.
+- Long states are truncated to the window with the questions reserved first.
+
+## License and provenance
+
+MIT, following the `jhu-clsp/mmBERT-base` backbone. No weights, gradients or
+private data from any third-party decision service are used or claimed; the
+design follows publicly documented API behaviour and public benchmark splits.

decision_jef-0.1.0/decision_jef.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+decision_jef/__init__.py
+decision_jef/infer.py
+decision_jef/model.py
+decision_jef/pack.py
+decision_jef/py.typed
+decision_jef/wire.py
+decision_jef.egg-info/PKG-INFO
+decision_jef.egg-info/SOURCES.txt
+decision_jef.egg-info/dependency_links.txt
+decision_jef.egg-info/requires.txt
+decision_jef.egg-info/top_level.txt

decision_jef-0.1.0/decision_jef.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

decision_jef-0.1.0/decision_jef.egg-info/requires.txt

@@ -0,0 +1,6 @@
+torch>=2.4
+transformers>=4.48
+huggingface-hub>=0.26
+
+[dev]
+pytest>=8

decision_jef-0.1.0/decision_jef.egg-info/top_level.txt

@@ -0,0 +1 @@
+decision_jef

decision_jef-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "decision-jef"
+version = "0.1.0"
+description = "Typed decisions with calibrated probabilities, in one forward pass"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "typed-decisions", "calibration", "classification", "routing",
+    "scoring", "encoder", "multilingual", "nlp",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Text Processing :: Linguistic",
+    "Typing :: Typed",
+]
+dependencies = [
+    "torch>=2.4",
+    "transformers>=4.48",
+    "huggingface-hub>=0.26",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8"]
+
+[project.urls]
+Homepage = "https://huggingface.co/BarraHome/Decision-Jef-0.1"
+Model = "https://huggingface.co/BarraHome/Decision-Jef-0.1"
+Issues = "https://huggingface.co/BarraHome/Decision-Jef-0.1/discussions"
+
+[tool.setuptools]
+packages = ["decision_jef"]
+
+[tool.setuptools.package-data]
+decision_jef = ["py.typed"]

decision_jef-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+