Add Dinah-0 Apache: Dinah-0 retrained without non-commercial data

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,175 @@
+---
+license: apache-2.0
+language:
+  - en
+  - pt
+base_model: Tropic-AI/moBERTo
+library_name: transformers
+pipeline_tag: text-classification
+tags:
+  - modernbert
+  - encoder
+  - typed-decisions
+  - decision-index
+  - onnx
+  - cpu
+  - decision-model
+---
+
+# Dinah-0 Apache
+
+**The same Dinah-0, retrained without non-commercial data and released under Apache-2.0: a 150M-parameter encoder that makes typed decisions, in English and Portuguese, on a CPU.**
+
+This is not a new version. It is [Dinah-0](https://huggingface.co/Lukitaduarte/dinah-0) rebuilt for commercial use. Dinah-0 was trained on a few thousand items from RACE and MCTest and is therefore released under CC BY-NC 4.0. Dinah-0 Apache starts from a lineage with no non-commercial source and drops those items. Same architecture, same question format (`choice`, `noul`, `score`, with probabilities and confidence), same 8,192-token context. It scores about 0.2 points lower on the Decision Index than Dinah-0, which is the price of the clean license. Not affiliated with TypeSafe.
+
+- Apache-2.0 weights, ONNX files (int8 and 8-bit) and inference code
+- Decision Index 0.3 public index **25.86** (official kit run), against 26.06 for Dinah-0
+- On par with Dinah-0 on English, Portuguese and chess guard sets
+
+## What it does
+
+It reads a question (instructions, state and a set of options) and returns a probability distribution over the options. The same model answers three question types:
+
+| Type | Output |
+|---|---|
+| `choice` | the chosen label, a confidence and the probability of every label |
+| `noul` | the probability that a statement is true |
+| `score` | the expected value on an ordered rubric, plus confidence and probabilities |
+
+It does not generate text. It is built for classification, routing, tool selection, extraction checks and similar decisions where a small, fast and cheap model is enough.
+
+## Results
+
+### Decision Index 0.3
+
+Official run of the [Decision Index](https://github.com/apolinario/decision-index) kit with the engine in this repository (`decision_index_engine.py`), edition 0.3, on one NVIDIA RTX 5090, one process per variant. 140,620 requests run; 140,178 are scoreable after the kit's exclusions, all with a result except 8 refused as unsupported. In total 324 requests do not fit in 8,192 tokens and are refused (nothing is truncated).
+
+| | Public index (balanced skill) | Raw index |
+|---|---:|---:|
+| **Dinah-0 Apache** | **25.86** | 44.50 |
+| Dinah-0 (CC BY-NC 4.0, from the live board) | 26.06 | n/d |
+
+The calibration described below changes probabilities and confidence but not a single chosen option, so the index is identical with and without it (25.86 both ways, checked on all 314,940 answers).
+
+The raw results of this run are published for auditing in [Lukitaduarte/dinah-0-decision-index-results](https://huggingface.co/datasets/Lukitaduarte/dinah-0-decision-index-results) under `runs/dinah-0-apache/`.
+
+### Guard sets
+
+Held-out sets of 1,000 items each, accuracy:
+
+| Set | Dinah-0 | Dinah-0 Apache |
+|---|---:|---:|
+| Typed decisions, English | 0.78 | 0.789 |
+| Typed decisions, Portuguese | 0.784 | 0.786 |
+| Chess puzzles | 0.59 | 0.587 |
+
+Dinah-0 Apache is a weight average (50/50) of two checkpoints trained in sequence from the same starting point, one favoring tools and new domains and one restoring Portuguese. No benchmark test row was used for training.
+
+## Calibration
+
+Two numbers come out of each answer and they mean different things:
+
+- **`probabilities`** estimate the distribution of the label. The typed-decision labels are distributions (the mean mass of the top option is about 0.66), so the top probability is not the chance of being right and is usually lower than the accuracy.
+- **`confidence`** estimates the chance that the chosen option is right.
+
+Both are calibrated inside `dinah.py` (settings in `config.json`, key `dinah.calibration`): one temperature per question type and number of options (2 to 9) for the probabilities, and a Platt map for the confidence. They were fit on the even-indexed half of the English and Portuguese typed-decision test sets. On the other half, which was not used for fitting, the expected calibration error of `confidence` is 0.069 (English) and 0.060 (Portuguese). Treat that as the figure for in-distribution questions and measure again on your own domain before relying on it.
+
+## Usage
+
+```python
+from dinah import Dinah, DinahONNX
+
+model = Dinah.from_pretrained("Lukitaduarte/dinah-0-apache")       # PyTorch, fp32 weights
+model = DinahONNX.from_pretrained("Lukitaduarte/dinah-0-apache")   # onnxruntime, int8, CPU
+
+model.choice(state="The package arrived broken.",
+             criteria={"refund": "Customer wants money back", "replace": "Customer wants a new unit"},
+             instructions="What does the customer want?")
+```
+
+Files:
+
+| File | What it is |
+|---|---|
+| `model.safetensors` | fp32 weights for the PyTorch backend |
+| `onnx/model_int8.onnx` | int8, 151 MB, the default CPU backend of `dinah.py` |
+| `onnx/model_8bit.onnx` | 8-bit weights, 165 MB, listed in `decision_ai.json` |
+| `dinah.py` | minimal inference code (PyTorch and ONNX backends) |
+| `decision_index_engine.py` | engine used to run the Decision Index kit |
+| `decision_ai.json` | manifest for the Decision AI runtime |
+
+ONNX parity with PyTorch on real items: identical argmax in 100% of 64 items, maximum probability difference 2e-5.
+
+## Training data and licenses
+
+Dinah-0 Apache was trained in stages from [Tropic-AI/moBERTo](https://huggingface.co/Tropic-AI/moBERTo) (Apache-2.0). Each dataset is listed with the license its own card declares.
+
+| Source | License |
+|---|---|
+| ZefanCai/Open-Jev | CC0-1.0 |
+| LocalLLaMA/typed-decisions | Apache-2.0 |
+| typed-decisions-pt (translated with Qwen3-4B, Apache-2.0) | Apache-2.0 |
+| Lichess puzzles | CC0-1.0 |
+| google-deepmind/searchless_chess (ChessBench) | Apache-2.0 |
+| AmazonScience/massive | CC BY 4.0 |
+| Bitext customer support | CDLA-Sharing-1.0 |
+| ESCI | Apache-2.0 |
+| WANLI | CC BY 4.0 |
+| SNLI | CC BY-SA 4.0 |
+| HoVer | CC BY-SA 4.0 |
+| CommonsenseQA | MIT |
+| Cosmos QA | CC BY 4.0 |
+| BoolQ | CC BY-SA 3.0 |
+| HellaSwag | MIT |
+| WinoGrande | Apache-2.0 |
+| ARC (train split) | CC BY-SA 4.0 |
+| QASC | CC BY 4.0 |
+| StrategyQA | MIT |
+| bAbI-NLI | BSD |
+| BIG-bench tasks (tasksource, BBH tasks excluded) | Apache-2.0 |
+| MMLU auxiliary train (ARC and OpenBookQA parts only) | MIT |
+| PubMedQA | MIT |
+| MedMCQA | Apache-2.0 |
+| GoEmotions | Apache-2.0 |
+| Civil Comments | CC0-1.0 |
+| twitter-financial-news-sentiment | MIT |
+| financial-tweets-sentiment | MIT |
+| NOSIBLE financial-sentiment | ODC-By |
+| FinQA hallucination detection | MIT |
+| CUAD | CC BY 4.0 |
+| BANKING77 | CC BY 4.0 |
+| CLINC150 | CC BY 3.0 |
+| ContractNLI | CC BY 4.0 |
+| IBM Claim Stance | CC BY 3.0 |
+| HaluEval | Apache-2.0 |
+| GSM8K | MIT |
+| CLadder | MIT |
+| iSarcasmEval | MIT |
+| B2W-Reviews01 | CC BY 4.0 |
+| multilingual-sentiments (pt) | Apache-2.0 |
+| jurisprudencias_br | CC BY 4.0 |
+| FaQuAD-NLI | CC BY 4.0 |
+| FAQ_BACEN | Apache-2.0 |
+| ExtraGLUE (RTE and COPA, pt) | MIT |
+| glaiveai/glaive-function-calling-v2 | Apache-2.0 |
+| Team-ACE/ToolACE | Apache-2.0 |
+| NousResearch/hermes-function-calling-v1 | Apache-2.0 |
+| nvidia/When2Call | CC BY 4.0 |
+| Dizzzy0x00/LLMGen-Phishing-Email-Dataset | Apache-2.0 |
+| kudzaiprichard/aura-phishing-email-corpus (SpamAssassin part) | CC BY 4.0 |
+| Synthetic phishing emails, written with openai/gpt-oss-120b (signals and labels set by code) | Apache-2.0 |
+| English to Portuguese translations of NLI, HellaSwag, Cosmos QA, CommonsenseQA and BoolQ items, made with Helsinki-NLP/opus-mt-tc-big-en-pt | CC BY 4.0 |
+| Programmatic skills (arithmetic, dates, units, sorting, graphs, code output): generated by our own scripts | Apache-2.0 |
+
+Datasets under CC BY-SA and CDLA-Sharing are used for training only and are not redistributed here.
+
+## Limits
+
+- 8,192-token context. Nothing is truncated: a longer request raises `RequestTooLong`.
+- English and Portuguese only. Other languages work to the extent the base model saw them, and were not evaluated.
+- It does not generate text and it does not know facts beyond its training: on knowledge-heavy benchmarks (MMLU, GPQA, HLE) it is far behind decoder models with billions of parameters.
+- Confidence is calibrated on the training distribution. On a new domain, measure it before trusting it.
+
+## License
+
+Apache-2.0. See `LICENSE`.

config.json

@@ -0,0 +1,93 @@
+{
+  "architectures": [
+    "ModernBertModel"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 50281,
+  "classifier_activation": "silu",
+  "classifier_bias": false,
+  "classifier_dropout": 0.0,
+  "classifier_pooling": "mean",
+  "cls_token_id": 50281,
+  "decoder_bias": true,
+  "deterministic_flash_attn": false,
+  "embedding_dropout": 0.0,
+  "eos_token_id": 50282,
+  "global_attn_every_n_layers": 3,
+  "global_rope_theta": 160000.0,
+  "gradient_checkpointing": false,
+  "hidden_activation": "gelu",
+  "hidden_size": 768,
+  "initializer_cutoff_factor": 2.0,
+  "initializer_range": 0.02,
+  "intermediate_size": 1152,
+  "layer_norm_eps": 1e-05,
+  "local_attention": 128,
+  "local_rope_theta": 10000.0,
+  "max_position_embeddings": 8192,
+  "mlp_bias": false,
+  "mlp_dropout": 0.0,
+  "model_type": "modernbert",
+  "norm_bias": false,
+  "norm_eps": 1e-05,
+  "num_attention_heads": 12,
+  "num_hidden_layers": 22,
+  "pad_token_id": 50283,
+  "position_embedding_type": "absolute",
+  "sep_token_id": 50282,
+  "tie_word_embeddings": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.48.0",
+  "vocab_size": 50369,
+  "dinah": {
+    "opt_token": "[OPT]",
+    "opt_token_id": 50368,
+    "question_types": {
+      "noul": 0,
+      "choice": 1,
+      "score": 2
+    },
+    "max_length": 8192,
+    "pad_multiple": 64,
+    "calibration": {
+      "temperature": [
+        [
+          1.3,
+          1.0,
+          1.0,
+          1.0,
+          1.0,
+          1.0,
+          1.0,
+          1.0
+        ],
+        [
+          1.0,
+          1.0,
+          1.4,
+          1.35,
+          1.0,
+          1.0,
+          1.0,
+          1.0
+        ],
+        [
+          1.0,
+          1.0,
+          1.3,
+          1.3,
+          1.0,
+          1.0,
+          1.0,
+          1.0
+        ]
+      ],
+      "platt": [
+        0.7,
+        -0.1
+      ],
+      "note": "temperature[question_type][min(max(k,2),9)-2] divides the logits (fit on soft-label NLL); platt maps the confidence logit: sigmoid(a*z+b). Fit on half of the typed-decisions test sets (even indices); the other half is held out."
+    }
+  }
+}

decision_ai.json

@@ -0,0 +1,39 @@
+{
+  "format": "decision-ai/option-reader@1",
+  "name": "Dinah-0 Apache",
+  "license": "apache-2.0",
+  "homepage": "https://huggingface.co/Lukitaduarte/dinah-0-apache",
+  "files": {
+    "model": "onnx/model_8bit.onnx",
+    "tokenizer": "tokenizer.json"
+  },
+  "sha256": {
+    "onnx/model_8bit.onnx": "412e14a95c7cb8eb8a95feb9b0cbf4c05f9177418233be5010590d73923c7cf6",
+    "tokenizer.json": "edeac9e7b2f170022cefd1c7b396ebca3ac9c57f2f93604844cb7fb16b1a71ca"
+  },
+  "max_length": 8192,
+  "pad_multiple": 64,
+  "tokens": {
+    "cls": "[CLS]",
+    "sep": "[SEP]",
+    "pad": "[PAD]",
+    "option": "[OPT]"
+  },
+  "question_types": {
+    "noul": 0,
+    "choice": 1,
+    "score": 2
+  },
+  "noul_false_default": "The statement above is false.",
+  "inputs": {
+    "ids": "ids",
+    "pad_mask": "pad_mask",
+    "option_positions": "opt_positions",
+    "option_mask": "opt_mask",
+    "question_type": "qtype"
+  },
+  "outputs": {
+    "logits": "logits",
+    "confidence_logit": "conf_logit"
+  }
+}

decision_index_engine.py

@@ -0,0 +1,59 @@
+"""Decision Index engine for Dinah-0 (https://github.com/apolinario/decision-index).
+
+    python -m decision_index run --engine decision_index_engine:DinahEngine \
+        --option revision=<commit> --edition 0.2.1 --suite-dir suite-0.2 --out runs/dinah-0-apache
+
+Put this file next to `dinah.py` (both are in the model repository) and on PYTHONPATH.
+Kit rules: nothing is truncated and no option is dropped. A request that does not fit in 8,192 tokens,
+or a question type the model does not support, raises `Unsupported`.
+
+One call = one request (a state and several questions); all questions of a request go through the
+encoder together, 16 at a time. Probabilities are the softmax over the option logits; the confidence
+of a `choice` answer comes from the confidence head.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from decision_index.engines import Engine, Unsupported
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from dinah import Dinah, RequestTooLong  # noqa: E402
+
+
+class DinahEngine(Engine):
+    name = "dinah-0-apache"
+    latency = ("In-process request wall time: tokenization plus one encoder pass per request "
+               "(all questions of the request batched together); excludes model loading.")
+
+    def __init__(self, repo: str = "Lukitaduarte/dinah-0-apache", revision: str | None = None, device: str | None = None,
+                 dtype: str | None = None, batch_size: int = 16, calibrate: str | bool = True, **options):
+        super().__init__(**options)
+        self.model = Dinah.from_pretrained(repo, device=device, dtype=dtype, revision=revision)
+        self.calibrated = str(calibrate).lower() not in ("0", "false", "no", "off")
+        if not self.calibrated:   # raw logits and raw confidence head, for comparison with the calibrated run
+            self.model.temperature, self.model.platt = None, None
+        self.batch_size = int(batch_size)
+        self.provenance = {"repo": repo, "revision": revision or "main", "device": self.model.device,
+                           "dtype": self.model.dtype, "max_length": self.model.max_length, "calibrated": self.calibrated,
+                           "truncation": "none: requests above 8,192 tokens raise Unsupported"}
+
+    def __call__(self, state, questions):
+        keys = list(questions)
+        batch = []
+        for key in keys:
+            q = questions[key]
+            if q["type"] not in ("choice", "noul"):
+                raise Unsupported(f"question type {q['type']}")
+            batch.append({"type": q["type"], "state": state, "instructions": q.get("instructions"),
+                          "criteria": q.get("criteria")})
+        try:
+            answers = self.model.predict(batch, batch_size=self.batch_size)
+        except RequestTooLong as e:
+            raise Unsupported(f"context window: {e}")
+        return {"model": "dinah-0-apache", "answers": dict(zip(keys, answers))}, None
+
+    def synchronize(self):
+        if self.model.device.startswith("cuda"):
+            self.model.torch.cuda.synchronize()

dinah.py

@@ -0,0 +1,256 @@
+"""Minimal inference code for Dinah-0 Apache.
+
+Dinah-0 Apache is a 150M-parameter encoder (ModernBERT architecture) that answers typed decisions:
+
+    choice  pick one label out of a set             -> {"choice", "confidence", "probabilities"}
+    noul    probability that a statement is true    -> {"noul"}
+    score   expected value on an ordered rubric     -> {"score", "confidence", "probabilities"}
+
+Every question is read as one sequence
+
+    [CLS] instructions [SEP] state [SEP] [OPT] option_1 [OPT] option_2 ... [OPT] option_n
+
+and each option is scored from the hidden state at its [OPT] marker. Nothing is truncated: a request
+longer than `max_length` (8,192 tokens) raises `RequestTooLong`.
+
+Two backends with the same API:
+
+    from dinah import Dinah, DinahONNX
+    model = Dinah.from_pretrained("Lukitaduarte/dinah-0-apache")        # PyTorch, fp32 weights
+    model = DinahONNX.from_pretrained("Lukitaduarte/dinah-0-apache")    # onnxruntime, int8, CPU
+
+    model.choice(state="The package arrived broken.",
+                 criteria={"refund": "Customer wants money back", "replace": "Customer wants a new unit"},
+                 instructions="What does the customer want?")
+"""
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+QUESTION_TYPES = {"noul": 0, "choice": 1, "score": 2}
+NEG = -1e4
+
+
+class RequestTooLong(ValueError):
+    """The request does not fit in `max_length` tokens. Nothing is ever truncated."""
+
+
+def render(content: Any) -> str:
+    """Strings are stripped; objects and arrays become compact JSON with sorted keys (as in training)."""
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content.strip()
+    return json.dumps(content, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def _resolve(path_or_repo: str | Path, files: list[str], revision: str | None = None) -> Path:
+    path = Path(path_or_repo)
+    if path.is_dir():
+        return path
+    from huggingface_hub import snapshot_download
+    return Path(snapshot_download(str(path_or_repo), allow_patterns=files, revision=revision))
+
+
+class _Base:
+    """Tokenization, batching and the typed-decision API shared by both backends."""
+
+    def __init__(self, directory: Path):
+        from transformers import AutoTokenizer
+        self.config = json.loads((directory / "config.json").read_text())
+        extra = self.config["dinah"]
+        self.tokenizer = AutoTokenizer.from_pretrained(str(directory))
+        self.opt_id = self.tokenizer.convert_tokens_to_ids(extra["opt_token"])
+        assert self.opt_id == extra["opt_token_id"], "tokenizer does not match the model"
+        self.max_length = extra["max_length"]
+        self.pad_multiple = extra["pad_multiple"]
+        cal = extra.get("calibration")
+        self.temperature = np.array(cal["temperature"], dtype=np.float64) if cal else None
+        self.platt = tuple(cal["platt"]) if cal else None
+
+    def _ids(self, text: str) -> list[int]:
+        return self.tokenizer(text, add_special_tokens=False)["input_ids"] if text else []
+
+    def _encode(self, instructions: Any, state: Any, options: list[Any]) -> tuple[list[int], list[int]]:
+        t = self.tokenizer
+        ids = [t.cls_token_id, *self._ids(render(instructions)), t.sep_token_id, *self._ids(render(state)), t.sep_token_id]
+        positions = []
+        for option in options:
+            positions.append(len(ids))
+            ids += [self.opt_id, *self._ids(render(option))]
+        if len(ids) > self.max_length:
+            raise RequestTooLong(f"request needs {len(ids)} tokens, above max_length={self.max_length} (no truncation)")
+        return ids, positions
+
+    def _batch(self, items: list[tuple[list[int], list[int], int]]) -> dict[str, np.ndarray]:
+        b = len(items)
+        length = max(len(ids) for ids, _, _ in items)
+        length = -(-length // self.pad_multiple) * self.pad_multiple
+        n = max(len(pos) for _, pos, _ in items)
+        batch = {"ids": np.full((b, length), self.tokenizer.pad_token_id, dtype=np.int64),
+                 "pad_mask": np.zeros((b, length), dtype=bool),
+                 "opt_positions": np.zeros((b, n), dtype=np.int64),   # padding points at [CLS], masked below
+                 "opt_mask": np.zeros((b, n), dtype=bool),
+                 "qtype": np.array([q for _, _, q in items], dtype=np.int64)}
+        for i, (ids, pos, _) in enumerate(items):
+            batch["ids"][i, :len(ids)] = ids
+            batch["pad_mask"][i, :len(ids)] = True
+            batch["opt_positions"][i, :len(pos)] = pos
+            batch["opt_mask"][i, :len(pos)] = True
+        return batch
+
+    def _forward(self, batch: dict[str, np.ndarray]) -> tuple[np.ndarray, np.ndarray]:
+        raise NotImplementedError
+
+    def predict(self, questions: list[dict[str, Any]], batch_size: int = 16) -> list[dict[str, Any]]:
+        """Answer a list of questions. Each question is a dict with `type` ("choice", "noul" or "score"),
+        `state`, optional `instructions`, and `criteria`:
+          choice: {label: description or None}   (None means the label is its own description)
+          noul:   {"true": ..., "false": ...} describing both poles (strongly recommended)
+          score:  list of descriptions, ordered from lowest (0) to highest
+        """
+        encoded, meta = [], []
+        for q in questions:
+            kind = q["type"]
+            if kind == "choice":
+                labels = list(q["criteria"])
+                options = [d if d is not None else label for label, d in q["criteria"].items()]
+            elif kind == "noul":
+                c = q.get("criteria") or {}
+                options = [c.get("false") or "The statement above is false.", c.get("true") or q.get("instructions")]
+                labels = None
+            elif kind == "score":
+                options, labels = list(q["criteria"]), None
+            else:
+                raise ValueError(f"unknown question type {kind!r}")
+            if len(options) < 2:
+                raise ValueError("a question needs at least 2 options")
+            ids, pos = self._encode(q.get("instructions"), q.get("state"), options)
+            encoded.append((ids, pos, QUESTION_TYPES[kind]))
+            meta.append((kind, labels, options))
+
+        answers = []
+        for start in range(0, len(encoded), batch_size):
+            logits, conf_logits = self._forward(self._batch(encoded[start:start + batch_size]))
+            for j, (kind, labels, options) in enumerate(meta[start:start + batch_size]):
+                z = logits[j, :len(options)].astype(np.float64)
+                if self.temperature is not None:   # one temperature per (question type, number of options 2..9)
+                    z = z / self.temperature[QUESTION_TYPES[kind], min(max(len(options), 2), 9) - 2]
+                p = np.exp(z - z.max()); p /= p.sum()
+                c = float(conf_logits[j])
+                if self.platt is not None:
+                    c = self.platt[0] * c + self.platt[1]
+                confidence = 1.0 / (1.0 + math.exp(-max(min(c, 30.0), -30.0)))
+                if kind == "noul":
+                    answers.append({"type": "noul", "noul": float(p[1])})
+                elif kind == "choice":
+                    best = int(p.argmax())
+                    answers.append({"type": "choice", "choice": labels[best], "confidence": confidence,
+                                    "probabilities": {l: float(x) for l, x in zip(labels, p)}})
+                else:
+                    answers.append({"type": "score", "score": float(sum(i * x for i, x in enumerate(p))),
+                                    "confidence": confidence, "probabilities": {str(i): float(x) for i, x in enumerate(p)}})
+        return answers
+
+    def choice(self, state: Any, criteria: dict[str, Any], instructions: Any = None) -> dict[str, Any]:
+        return self.predict([{"type": "choice", "state": state, "criteria": criteria, "instructions": instructions}])[0]
+
+    def noul(self, state: Any, instructions: Any, true: Any = None, false: Any = None) -> dict[str, Any]:
+        return self.predict([{"type": "noul", "state": state, "instructions": instructions,
+                              "criteria": {"true": true, "false": false}}])[0]
+
+    def score(self, state: Any, criteria: list[Any], instructions: Any = None) -> dict[str, Any]:
+        return self.predict([{"type": "score", "state": state, "criteria": criteria, "instructions": instructions}])[0]
+
+
+def _confidence_features(probs, mask, qtype):
+    """Shape of the option distribution: top-1, margin, normalized entropy, 1/k and the question type."""
+    import torch
+    k = mask.sum(-1).clamp(min=2).float()
+    top2 = torch.where(mask, probs, torch.zeros_like(probs)).sort(dim=-1, descending=True).values[:, :2]
+    entropy = -(probs * probs.clamp(min=1e-9).log()).sum(-1) / k.log()
+    onehot = (qtype[:, None] == torch.arange(len(QUESTION_TYPES), device=qtype.device)[None, :]).float()
+    return torch.cat([top2[:, :1], top2[:, :1] - top2[:, 1:2], entropy[:, None], (1.0 / k)[:, None], onehot], dim=-1)
+
+
+class Dinah(_Base):
+    """PyTorch backend (fp32 weights, model.safetensors). On CUDA it runs under bfloat16 autocast by default."""
+
+    FILES = ["config.json", "model.safetensors", "tokenizer.json", "tokenizer_config.json", "special_tokens_map.json"]
+
+    def __init__(self, directory: Path, device: str | None = None, dtype: str | None = None):
+        super().__init__(directory)
+        import torch
+        import torch.nn as nn
+        from safetensors.torch import load_file
+        from transformers import ModernBertConfig, ModernBertModel
+
+        cfg = ModernBertConfig(**{k: v for k, v in self.config.items() if k not in ("dinah", "architectures")})
+        hidden = cfg.hidden_size
+        net = nn.Module()
+        net.encoder = ModernBertModel(cfg)
+        net.type_embedding = nn.Embedding(len(QUESTION_TYPES), hidden)
+        net.scorer = nn.Sequential(nn.LayerNorm(hidden), nn.Dropout(0.0), nn.Linear(hidden, hidden), nn.GELU(), nn.Linear(hidden, 1))
+        net.confidence = nn.Module()
+        net.confidence.net = nn.Sequential(nn.Linear(7, 64), nn.GELU(), nn.Linear(64, 64), nn.GELU(), nn.Linear(64, 1))
+        net.load_state_dict(load_file(str(directory / "model.safetensors")), strict=True)
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.dtype = dtype or ("bfloat16" if self.device == "cuda" else "float32")
+        self.net = net.to(self.device).eval()
+        self.torch = torch
+
+    @classmethod
+    def from_pretrained(cls, path_or_repo: str | Path = "Lukitaduarte/dinah-0-apache", device: str | None = None,
+                        dtype: str | None = None, revision: str | None = None) -> "Dinah":
+        return cls(_resolve(path_or_repo, cls.FILES, revision), device, dtype)
+
+    def _forward(self, batch):
+        torch = self.torch
+        t = {k: torch.as_tensor(v, device=self.device) for k, v in batch.items()}
+        autocast = self.dtype != "float32" and self.device.startswith("cuda")
+        with torch.no_grad(), torch.autocast("cuda", dtype=getattr(torch, self.dtype), enabled=autocast):
+            h = self.net.encoder(input_ids=t["ids"], attention_mask=t["pad_mask"]).last_hidden_state
+            h = h + self.net.type_embedding(t["qtype"])[:, None, :]
+            idx = t["opt_positions"].unsqueeze(-1).expand(-1, -1, h.size(-1))
+            logits = self.net.scorer(h.gather(1, idx)).squeeze(-1).float()
+            logits = torch.where(t["opt_mask"], logits, torch.full_like(logits, NEG))
+            probs = logits.log_softmax(-1).exp() * t["opt_mask"]
+            conf = self.net.confidence.net(_confidence_features(probs, t["opt_mask"], t["qtype"])).squeeze(-1)
+        return logits.float().cpu().numpy(), conf.float().cpu().numpy()
+
+
+class DinahONNX(_Base):
+    """onnxruntime backend (int8 weights, block-local attention). Made for CPU."""
+
+    FILES = ["config.json", "onnx/model_int8.onnx", "tokenizer.json", "tokenizer_config.json", "special_tokens_map.json"]
+
+    def __init__(self, directory: Path, threads: int | None = None):
+        super().__init__(directory)
+        import onnxruntime as ort
+        options = ort.SessionOptions()
+        if threads:
+            options.intra_op_num_threads = threads
+        self.session = ort.InferenceSession(str(directory / "onnx/model_int8.onnx"), options, providers=["CPUExecutionProvider"])
+
+    @classmethod
+    def from_pretrained(cls, path_or_repo: str | Path = "Lukitaduarte/dinah-0-apache", threads: int | None = None,
+                        revision: str | None = None) -> "DinahONNX":
+        return cls(_resolve(path_or_repo, cls.FILES, revision), threads)
+
+    def _forward(self, batch):
+        logits, conf = self.session.run(["logits", "conf_logit"], batch)
+        return logits, conf
+
+
+if __name__ == "__main__":
+    model = DinahONNX.from_pretrained(".")
+    print(model.choice(state="The package arrived broken and I need it for tomorrow.",
+                       criteria={"refund": "The customer wants their money back",
+                                 "replacement": "The customer wants a new unit sent",
+                                 "complaint": "The customer only wants to complain"},
+                       instructions="What does the customer want?"))

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7cdb65b6ae003c79188ce7d0fcbe4db63cd247fc632c36a16fd797fb448e6a80
+size 598475136

onnx/model_8bit.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:412e14a95c7cb8eb8a95feb9b0cbf4c05f9177418233be5010590d73923c7cf6
+size 164506374

onnx/model_int8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5499edd7b6d0e76c55aef7e89df216fc577686d913ec1a856738a7aad3942f09
+size 150722915

special_tokens_map.json

@@ -0,0 +1,8 @@
+{
+  "cls_token": "[CLS]",
+  "sep_token": "[SEP]",
+  "pad_token": "[PAD]",
+  "mask_token": "[MASK]",
+  "unk_token": "[UNK]",
+  "additional_special_tokens": ["[OPT]"]
+}

tokenizer_config.json

@@ -0,0 +1,12 @@
+{
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "sep_token": "[SEP]",
+  "pad_token": "[PAD]",
+  "mask_token": "[MASK]",
+  "unk_token": "[UNK]",
+  "additional_special_tokens": ["[OPT]"],
+  "model_input_names": ["input_ids", "attention_mask"],
+  "model_max_length": 8192
+}