Publish MoJev

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,200 @@
+---
+license: mit
+pretty_name: MoJev
+base_model: Qwen/Qwen3.5-0.8B
+datasets:
+  - MoLeMo-Lab/mojev-mix
+library_name: transformers
+pipeline_tag: text-classification
+tags:
+  - calibration
+  - structured-output
+  - multiple-choice
+  - preference-learning
+  - multimodal
+  - mojev
+model-index:
+  - name: MoJev
+    results:
+      - task:
+          type: text-classification
+          name: Typed decision scoring
+        dataset:
+          type: MoLeMo-Lab/mojev-mix
+          name: MoJev-Mix test
+          split: test
+        metrics:
+          - type: accuracy
+            value: 0.9323
+            name: Accuracy
+---
+
+<img align="right" src="https://molemo-lab.github.io/mojev/assets/molemo-logo.png" width="76" alt="MoLeMo Lab logo">
+
+# MoJev
+
+[![Homepage](https://img.shields.io/badge/Project-Homepage-AD1853)](https://molemo-lab.github.io/mojev/)
+[![Hugging Face Space](https://img.shields.io/badge/Try-Space-AD1853?logo=huggingface)](https://huggingface.co/spaces/di-zhang-fdu/mojev)
+[![Preprint](https://img.shields.io/badge/Preprint-PDF-AD1853)](https://github.com/MoLeMo-Lab/mojev/blob/master/paper/mojev-preprint.pdf)
+[![Code](https://img.shields.io/badge/GitHub-Code-24292F?logo=github&logoColor=white)](https://github.com/MoLeMo-Lab/mojev)
+[![Dataset](https://img.shields.io/badge/Hugging_Face-Dataset-FFD21E?logo=huggingface&logoColor=111111)](https://huggingface.co/datasets/MoLeMo-Lab/mojev-mix)
+
+**Typed, calibrated decisions in one forward pass.**
+
+Contact: [contact@molemo.org](mailto:contact@molemo.org)
+
+This is the trained checkpoint for the
+[`mojev`](https://github.com/MoLeMo-Lab/mojev) runtime. It scores
+request-time candidate values from unstructured state and returns schema-bound
+probability distributions.
+
+| MoJev family resource | location |
+|---|---|
+| Code | [MoLeMo-Lab/mojev](https://github.com/MoLeMo-Lab/mojev) |
+| Model | **MoLeMo-Lab/mojev** |
+| Dataset | [MoLeMo-Lab/mojev-mix](https://huggingface.co/datasets/MoLeMo-Lab/mojev-mix) |
+| Results | [MoJev results](https://github.com/MoLeMo-Lab/mojev#results) |
+| Preprint | [MoJev (PDF)](https://github.com/MoLeMo-Lab/mojev/blob/master/paper/mojev-preprint.pdf) |
+| Project page | [MoJev](https://molemo-lab.github.io/mojev/) |
+
+## Interactive demo
+
+[Try MoJev on Hugging Face Spaces](https://huggingface.co/spaces/di-zhang-fdu/mojev):
+text, one or multiple images, a question, and custom candidates are scored on
+server-side ZeroGPU. No model weights are downloaded to the browser.
+
+The optional [`browser/`](browser) text export uses asymmetric INT4 linear weights,
+INT8 token embeddings, and an FP32 decision head. Export scripts and numerical comparisons are described in
+the [browser guide](https://github.com/MoLeMo-Lab/mojev/tree/master/browser).
+
+## Model contract
+
+| input | released configuration |
+|---|---|
+| state | text and local image references; 16,384-token training truncation |
+| question | instruction text |
+| candidates | request-time strings |
+| output | logits decoded as `Choice`, `Noul`, or `Score` distributions |
+
+Candidate names are supplied by the caller and encoded directly from their text.
+
+MoJev's Qwen3.5 backbone supports 262,144 tokens natively and up to
+1,010,000 tokens with [YaRN scaling](https://github.com/vllm-project/recipes/blob/main/Qwen/Qwen3.5.md).
+The checkpoint records the 16,384-token training window. The MoJev runtime
+accepts a larger inference state window through `--context-tokens`; the packed
+sequence also includes question and candidate tokens.
+
+## Run with the MoJev server
+
+```sh
+git clone https://github.com/MoLeMo-Lab/mojev
+cd mojev
+pip install -e '.[transformers]'
+
+mojev serve MoLeMo-Lab/mojev --port 8000
+```
+
+For a longer state within the native context:
+
+```sh
+mojev serve MoLeMo-Lab/mojev --port 8000 --context-tokens 65536
+```
+
+```python
+from typesafe_sdk import Choice, TypeSafeClient
+
+with TypeSafeClient(api_key="local", base_url="http://127.0.0.1:8000") as client:
+    result = client.system_one(
+        state={"document": "I was charged twice. Please fix this ASAP."},
+        questions={
+            "category": Choice(
+                instructions="What is this ticket about?",
+                criteria={"billing": None, "technical": None, "other": None},
+            )
+        },
+    )
+
+print(result.choices["category"].choice)
+print(result.choices["category"].probabilities)
+```
+
+## Load with Transformers
+
+```python
+from transformers import AutoModel, AutoProcessor
+
+model = AutoModel.from_pretrained(
+    "MoLeMo-Lab/mojev",
+    trust_remote_code=True,
+).to("cuda").eval()
+processor = AutoProcessor.from_pretrained(
+    "MoLeMo-Lab/mojev",
+    trust_remote_code=True,
+)
+```
+
+The model directory contains the scorer implementation through `auto_map`.
+Packing, candidate sorting, and schema decoding are provided by the
+[`mojev`](https://github.com/MoLeMo-Lab/mojev) package.
+
+## Multimodal input
+
+```sh
+pip install -e '.[transformers]'
+mojev serve MoLeMo-Lab/mojev --port 8000
+```
+
+Use the image marker followed by an absolute path in the request state:
+
+```python
+from pathlib import Path
+
+image = Path("examples/cat.jpg").resolve()
+state = f"Identify the subject. <|vision_start|><|image_pad|><|vision_end|>{image}"
+```
+
+The processor expands the image into visual patch tokens in the state branch.
+Every question and candidate in the request can attend to those tokens.
+
+| candidate set | grey image P(cat) | cat image P(cat) |
+|---|---:|---:|
+| `cat`, `dog` | 0.471 | **0.786** |
+| `cat`, `dog`, `car`, `other` | 0.264 | **0.528** |
+
+## Evaluation
+
+On 12,000 evaluation decisions, the released checkpoint reaches **93.23%**
+accuracy with **0.79%** expected calibration error.
+
+## Architecture
+
+![MoJev architecture: TreePacked Attention and typed decision head](https://molemo-lab.github.io/mojev/assets/model-architecture.svg)
+
+- Base: Qwen3.5-0.8B; all 854,036,544 parameters trained.
+- Packing: state, questions, and candidates in one sequence.
+- Attention: tree mask with isolated question/candidate branches.
+- Readout: rank-512 context and candidate projections with scaled dot product.
+- Objective: Plackett–Luce ranking plus Brier calibration loss.
+- Precision: bf16 encoder and fp32 readout.
+
+## Training
+
+| item | value |
+|---|---|
+| data | 205,084 rows from 18 Open-Jev generators |
+| epochs | 1 |
+| parallelism | 8-way data parallel |
+| learning rate | 1e-5 |
+| state truncation | 16,384 tokens |
+| Brier weight | 1.0 |
+| wall time | 47 minutes |
+
+## Applications
+
+- routing and triage;
+- policy and evidence classification;
+- tool and workflow selection;
+- calibrated execution, deferral, and escalation thresholds;
+- multiple typed decisions over shared state.
+
+Code is MIT licensed. The Qwen base model license applies to the checkpoint.

browser/comparison.json

@@ -0,0 +1,111 @@
+{
+  "source_revision": "d439315bd9a11409584e16758bb76a9d75b5bea7",
+  "source_encoder_dtype": "torch.bfloat16",
+  "scope": "Four English/Chinese text cases for numerical comparison.",
+  "cases": [
+    {
+      "context": "The customer was charged twice for the same order and wants the duplicate payment returned.",
+      "question": "Which team should handle this request?",
+      "candidates": [
+        "Billing",
+        "Technical support",
+        "Sales"
+      ],
+      "tokens": 40,
+      "reference": [
+        0.9212515354156494,
+        0.04107579588890076,
+        0.037672750651836395
+      ],
+      "quantized": [
+        0.8891163468360901,
+        0.05538984015583992,
+        0.05549393594264984
+      ],
+      "quantized_logits": [
+        2.8020951747894287,
+        0.0262632817029953,
+        0.028140777722001076
+      ],
+      "top1_agrees": true,
+      "max_probability_error": 0.032135188579559326,
+      "onnx_cpu_seconds": 0.33495458390098065
+    },
+    {
+      "context": "The red box is empty. The blue box contains the key.",
+      "question": "Which box contains the key?",
+      "candidates": [
+        "The red box",
+        "The blue box"
+      ],
+      "tokens": 39,
+      "reference": [
+        0.020697807893157005,
+        0.9793022274971008
+      ],
+      "quantized": [
+        0.03171052783727646,
+        0.9682894349098206
+      ],
+      "quantized_logits": [
+        0.6149787306785583,
+        4.03386116027832
+      ],
+      "top1_agrees": true,
+      "max_probability_error": 0.011012792587280273,
+      "onnx_cpu_seconds": 0.2776173329912126
+    },
+    {
+      "context": "A parcel must arrive by Friday. Express delivery arrives Thursday; standard delivery arrives Monday.",
+      "question": "Which delivery option meets the deadline?",
+      "candidates": [
+        "Express delivery",
+        "Standard delivery"
+      ],
+      "tokens": 40,
+      "reference": [
+        0.30602750182151794,
+        0.6939724683761597
+      ],
+      "quantized": [
+        0.26124119758605957,
+        0.7387588024139404
+      ],
+      "quantized_logits": [
+        2.2718594074249268,
+        3.311386823654175
+      ],
+      "top1_agrees": true,
+      "max_probability_error": 0.04478633403778076,
+      "onnx_cpu_seconds": 0.2724832500098273
+    },
+    {
+      "context": "用户说：订单被重复扣款，希望退回多付的钱。",
+      "question": "应该把请求转给哪个团队？",
+      "candidates": [
+        "账单与退款",
+        "技术支持",
+        "销售咨询"
+      ],
+      "tokens": 47,
+      "reference": [
+        0.9347994327545166,
+        0.04668309539556503,
+        0.018517442047595978
+      ],
+      "quantized": [
+        0.8895391821861267,
+        0.08191443234682083,
+        0.028546439483761787
+      ],
+      "quantized_logits": [
+        2.27278733253479,
+        -0.11224094033241272,
+        -1.166383981704712
+      ],
+      "top1_agrees": true,
+      "max_probability_error": 0.04526025056838989,
+      "onnx_cpu_seconds": 0.360311041935347
+    }
+  ]
+}

browser/embeddings-int8.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5032e7a0fc5a8624f72e4ed92786993ab74deb8bdb6623f02e0a38b70ea401c6
+size 254279680

browser/embeddings-scales.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5aebec9840f73cf88236eaff35b9a28cc1cd64021d4c8c19152d5959270864fb
+size 993280

browser/head.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57f4f82d356d5bb5d9165a5790c864072eb3b32227715219aed7cea52d136046
+size 4211043

browser/layer-00-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:339a24722fb2d0bb1e1e7c209c6fc381c42c7a711c2622768232675a7771cac0
+size 13930999

browser/layer-01-q4.onnx

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

browser/layer-02-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:26d20e1fa8d16cab9d8cf93fc050bd12cc6cc90947518d9c87b37456c5f7ad6a
+size 13930999

browser/layer-03-q4.onnx

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

browser/layer-04-q4.onnx

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

browser/layer-05-q4.onnx

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

browser/layer-06-q4.onnx

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

browser/layer-07-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76e3461b9c56d3b7eed6a192b5faebf9a2f9a980324bc9091cb8c55abf74a368
+size 11847926

browser/layer-08-q4.onnx

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

browser/layer-09-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e2b111dee724f586eb4da7b954fad89cb3f1fccbc94e1ea7165b4f2ecd86b54
+size 13930999

browser/layer-10-q4.onnx

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

browser/layer-11-q4.onnx

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

browser/layer-12-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2359186f1b54f2937c7c01a56819e3ce0ea63b3e5ad162dbb58c4bcfcdb940bf
+size 13930999

browser/layer-13-q4.onnx

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

browser/layer-14-q4.onnx

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

browser/layer-15-q4.onnx

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

browser/layer-16-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25a08af6d7432e07eec78017e3fe3750ffc4e5e67fd16aae5a07ee35576eb3eb
+size 13930999

browser/layer-17-q4.onnx

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

browser/layer-18-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:36f34165d21862b08b11898ed189c6e6a7f2f8f19faa87b361d1b70e41f1124f
+size 13930999

browser/layer-19-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19ea7c9a796dacbec7a733a897e2919cbf78522f414f698aa531414e873b77e0
+size 11847926

browser/layer-20-q4.onnx

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

browser/layer-21-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61df1d01e2afe4f372f81df2905e0b671de2b95c2cb0140184869684074d5e3a
+size 13930999

browser/layer-22-q4.onnx

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

browser/layer-23-q4.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99f2d5d78d8df94895ecd394b060a2ba8e688394f8bd057fb6185d01c4579c4f
+size 11847926

browser/manifest.json

@@ -0,0 +1,158 @@
+{
+  "format": "mojev-browser-v1",
+  "source": "MoLeMo-Lab/mojev",
+  "source_revision": "d439315bd9a11409584e16758bb76a9d75b5bea7",
+  "source_sha256": "eae27bf03e0e44501316cafab2406b1505732ddf4b836d19fbb8deb642f55f50",
+  "width": 1024,
+  "layer_types": [
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention"
+  ],
+  "precision": {
+    "layers": "asymmetric int4, block 32",
+    "embeddings": "int8 per row",
+    "head": "float32"
+  },
+  "modality": "text",
+  "files": {
+    "embeddings-int8.bin": {
+      "bytes": 254279680,
+      "sha256": "5032e7a0fc5a8624f72e4ed92786993ab74deb8bdb6623f02e0a38b70ea401c6"
+    },
+    "embeddings-scales.bin": {
+      "bytes": 993280,
+      "sha256": "5aebec9840f73cf88236eaff35b9a28cc1cd64021d4c8c19152d5959270864fb"
+    },
+    "head.onnx": {
+      "bytes": 4211043,
+      "sha256": "57f4f82d356d5bb5d9165a5790c864072eb3b32227715219aed7cea52d136046"
+    },
+    "tokenizer.json": {
+      "bytes": 19989325,
+      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
+    },
+    "tokenizer_config.json": {
+      "bytes": 1124,
+      "sha256": "66e427c470fe580fe8c7b5725d857af23d8417e37fae62667ec698306a19987b"
+    },
+    "layer-00-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "339a24722fb2d0bb1e1e7c209c6fc381c42c7a711c2622768232675a7771cac0"
+    },
+    "layer-01-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "a61bbd7b5b407f1ff175d9b8a879bfbfa5174ad4c8f430a789e3245563c645ff"
+    },
+    "layer-02-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "26d20e1fa8d16cab9d8cf93fc050bd12cc6cc90947518d9c87b37456c5f7ad6a"
+    },
+    "layer-03-q4.onnx": {
+      "bytes": 11847926,
+      "sha256": "a720bbcf1eb03fc444864b73cd3d3f97c4846c8e8f3a05c011ad9d3ca8bc3dd4"
+    },
+    "layer-04-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "b83acd1c46dc4136146b5dc4858a1b2ddd28e15d77b601057872536c53f43163"
+    },
+    "layer-05-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "b378e6f362e93c2eee3b8600eafc569e9e623798f1448280d36d8658f558ad77"
+    },
+    "layer-06-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "e78c6f6f138f8d60a54bb8fe9821588166ccf69296655cabadd64d45b642dd6c"
+    },
+    "layer-07-q4.onnx": {
+      "bytes": 11847926,
+      "sha256": "76e3461b9c56d3b7eed6a192b5faebf9a2f9a980324bc9091cb8c55abf74a368"
+    },
+    "layer-08-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "c89020a7bdf5b9709a897d61895f583576e6be3fef9ddc53331eb22fa2f7a049"
+    },
+    "layer-09-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "5e2b111dee724f586eb4da7b954fad89cb3f1fccbc94e1ea7165b4f2ecd86b54"
+    },
+    "layer-10-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "d1020ff2d1ec8f9572837b6c467a5a31721b434e78060fff8cc76d9fa0e658b3"
+    },
+    "layer-11-q4.onnx": {
+      "bytes": 11847926,
+      "sha256": "3ae7203a0c8ef7ac9b4a8a6fcb5c203e8ba0b0be61de137b1e5ba462a73d7f3f"
+    },
+    "layer-12-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "2359186f1b54f2937c7c01a56819e3ce0ea63b3e5ad162dbb58c4bcfcdb940bf"
+    },
+    "layer-13-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "b84c3ce848e84be4f125dc3bc5db46043cd974188138fe7adec1ef1e6e486b3c"
+    },
+    "layer-14-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "b2a9b8c5007d032154b982f734e6905a3422dd22e48823d29bcf82dd2d575389"
+    },
+    "layer-15-q4.onnx": {
+      "bytes": 11847926,
+      "sha256": "deb8c1d059a7ca2911ad68174ec673c4bf00b0396fb62f4fb05e38428461480b"
+    },
+    "layer-16-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "25a08af6d7432e07eec78017e3fe3750ffc4e5e67fd16aae5a07ee35576eb3eb"
+    },
+    "layer-17-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "7a92793c044d96f3983b710f4acc8483a78abaa71214c65704d7fcc76710833d"
+    },
+    "layer-18-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "36f34165d21862b08b11898ed189c6e6a7f2f8f19faa87b361d1b70e41f1124f"
+    },
+    "layer-19-q4.onnx": {
+      "bytes": 11847926,
+      "sha256": "19ea7c9a796dacbec7a733a897e2919cbf78522f414f698aa531414e873b77e0"
+    },
+    "layer-20-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "fcee1290c07ed2b56daddea42021520b3a4675c287c685dc021a349aa366f16a"
+    },
+    "layer-21-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "61df1d01e2afe4f372f81df2905e0b671de2b95c2cb0140184869684074d5e3a"
+    },
+    "layer-22-q4.onnx": {
+      "bytes": 13930999,
+      "sha256": "ad9093090c30af97d1d809f48ed05f13c3f3e0f32134b0a7c488ff62954e039f"
+    },
+    "layer-23-q4.onnx": {
+      "bytes": 11847926,
+      "sha256": "99f2d5d78d8df94895ecd394b060a2ba8e688394f8bd057fb6185d01c4579c4f"
+    }
+  },
+  "semantics": "Matches the pinned Transformers scorer: full-attention layers use the tree mask; linear-attention layers use sequential recurrence."
+}

browser/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523
+size 19989325

browser/tokenizer_config.json

@@ -0,0 +1,32 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

browser/validation.json

@@ -0,0 +1,242 @@
+[
+  {
+    "layer": 0,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 0,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 1,
+    "length": 5,
+    "max_abs_error": 5.364418029785156e-07
+  },
+  {
+    "layer": 1,
+    "length": 13,
+    "max_abs_error": 5.960464477539062e-07
+  },
+  {
+    "layer": 2,
+    "length": 5,
+    "max_abs_error": 3.5762786865234375e-07
+  },
+  {
+    "layer": 2,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 3,
+    "length": 5,
+    "max_abs_error": 9.5367431640625e-07
+  },
+  {
+    "layer": 3,
+    "length": 13,
+    "max_abs_error": 1.3113021850585938e-06
+  },
+  {
+    "layer": 4,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 4,
+    "length": 13,
+    "max_abs_error": 5.960464477539062e-07
+  },
+  {
+    "layer": 5,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 5,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 6,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 6,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 7,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 7,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 8,
+    "length": 5,
+    "max_abs_error": 5.960464477539062e-07
+  },
+  {
+    "layer": 8,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 9,
+    "length": 5,
+    "max_abs_error": 2.384185791015625e-07
+  },
+  {
+    "layer": 9,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 10,
+    "length": 5,
+    "max_abs_error": 2.384185791015625e-07
+  },
+  {
+    "layer": 10,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 11,
+    "length": 5,
+    "max_abs_error": 5.364418029785156e-07
+  },
+  {
+    "layer": 11,
+    "length": 13,
+    "max_abs_error": 7.152557373046875e-07
+  },
+  {
+    "layer": 12,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 12,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 13,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 13,
+    "length": 13,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 14,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 14,
+    "length": 13,
+    "max_abs_error": 5.960464477539062e-07
+  },
+  {
+    "layer": 15,
+    "length": 5,
+    "max_abs_error": 9.5367431640625e-07
+  },
+  {
+    "layer": 15,
+    "length": 13,
+    "max_abs_error": 8.940696716308594e-07
+  },
+  {
+    "layer": 16,
+    "length": 5,
+    "max_abs_error": 4.76837158203125e-07
+  },
+  {
+    "layer": 16,
+    "length": 13,
+    "max_abs_error": 7.450580596923828e-07
+  },
+  {
+    "layer": 17,
+    "length": 5,
+    "max_abs_error": 5.513429641723633e-07
+  },
+  {
+    "layer": 17,
+    "length": 13,
+    "max_abs_error": 5.960464477539062e-07
+  },
+  {
+    "layer": 18,
+    "length": 5,
+    "max_abs_error": 7.152557373046875e-07
+  },
+  {
+    "layer": 18,
+    "length": 13,
+    "max_abs_error": 7.152557373046875e-07
+  },
+  {
+    "layer": 19,
+    "length": 5,
+    "max_abs_error": 1.862645149230957e-06
+  },
+  {
+    "layer": 19,
+    "length": 13,
+    "max_abs_error": 2.1457672119140625e-06
+  },
+  {
+    "layer": 20,
+    "length": 5,
+    "max_abs_error": 6.556510925292969e-07
+  },
+  {
+    "layer": 20,
+    "length": 13,
+    "max_abs_error": 7.152557373046875e-07
+  },
+  {
+    "layer": 21,
+    "length": 5,
+    "max_abs_error": 9.5367431640625e-07
+  },
+  {
+    "layer": 21,
+    "length": 13,
+    "max_abs_error": 8.940696716308594e-07
+  },
+  {
+    "layer": 22,
+    "length": 5,
+    "max_abs_error": 9.5367431640625e-07
+  },
+  {
+    "layer": 22,
+    "length": 13,
+    "max_abs_error": 1.1920928955078125e-06
+  },
+  {
+    "layer": 23,
+    "length": 5,
+    "max_abs_error": 8.344650268554688e-07
+  },
+  {
+    "layer": 23,
+    "length": 13,
+    "max_abs_error": 1.5497207641601562e-06
+  }
+]

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is true %}
+        {{- '<think>\n' }}
+    {%- else %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,241 @@
+{
+  "architectures": [
+    "PackedScorer"
+  ],
+  "auto_map": {
+    "AutoConfig": "modeling.PackedScorerConfig",
+    "AutoModel": "modeling.PackedScorer"
+  },
+  "context_tokens": 16384,
+  "dtype": "bfloat16",
+  "encoder_config": {
+    "_name_or_path": "Qwen/Qwen3.5-0.8B",
+    "architectures": [
+      "Qwen3_5ForConditionalGeneration"
+    ],
+    "chunk_size_feed_forward": 0,
+    "dtype": "bfloat16",
+    "id2label": {
+      "0": "LABEL_0",
+      "1": "LABEL_1"
+    },
+    "image_token_id": 248056,
+    "is_encoder_decoder": false,
+    "label2id": {
+      "LABEL_0": 0,
+      "LABEL_1": 1
+    },
+    "model_type": "qwen3_5",
+    "output_attentions": false,
+    "output_hidden_states": false,
+    "problem_type": null,
+    "return_dict": true,
+    "text_config": {
+      "_name_or_path": "",
+      "architectures": null,
+      "attention_bias": false,
+      "attention_dropout": 0.0,
+      "attn_output_gate": true,
+      "bos_token_id": null,
+      "chunk_size_feed_forward": 0,
+      "dtype": "bfloat16",
+      "eos_token_id": 248044,
+      "full_attention_interval": 4,
+      "head_dim": 256,
+      "hidden_act": "silu",
+      "hidden_size": 1024,
+      "id2label": {
+        "0": "LABEL_0",
+        "1": "LABEL_1"
+      },
+      "initializer_range": 0.02,
+      "intermediate_size": 3584,
+      "is_encoder_decoder": false,
+      "label2id": {
+        "LABEL_0": 0,
+        "LABEL_1": 1
+      },
+      "layer_types": [
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention"
+      ],
+      "linear_conv_kernel_dim": 4,
+      "linear_key_head_dim": 128,
+      "linear_num_key_heads": 16,
+      "linear_num_value_heads": 16,
+      "linear_value_head_dim": 128,
+      "mamba_ssm_dtype": "float32",
+      "max_position_embeddings": 262144,
+      "mlp_only_layers": [],
+      "model_type": "qwen3_5_text",
+      "mtp_num_hidden_layers": 1,
+      "mtp_use_dedicated_embeddings": false,
+      "num_attention_heads": 8,
+      "num_hidden_layers": 24,
+      "num_key_value_heads": 2,
+      "output_attentions": false,
+      "output_hidden_states": false,
+      "pad_token_id": null,
+      "partial_rotary_factor": 0.25,
+      "problem_type": null,
+      "return_dict": true,
+      "rms_norm_eps": 1e-06,
+      "rope_parameters": {
+        "mrope_interleaved": true,
+        "mrope_section": [
+          11,
+          11,
+          10
+        ],
+        "partial_rotary_factor": 0.25,
+        "rope_theta": 10000000,
+        "rope_type": "default"
+      },
+      "tie_word_embeddings": true,
+      "use_cache": true,
+      "vocab_size": 248320
+    },
+    "tie_word_embeddings": true,
+    "video_token_id": 248057,
+    "vision_config": {
+      "_name_or_path": "",
+      "architectures": null,
+      "chunk_size_feed_forward": 0,
+      "deepstack_visual_indexes": [],
+      "depth": 12,
+      "dtype": "bfloat16",
+      "hidden_act": "gelu_pytorch_tanh",
+      "hidden_size": 768,
+      "id2label": {
+        "0": "LABEL_0",
+        "1": "LABEL_1"
+      },
+      "in_channels": 3,
+      "initializer_range": 0.02,
+      "intermediate_size": 3072,
+      "is_encoder_decoder": false,
+      "label2id": {
+        "LABEL_0": 0,
+        "LABEL_1": 1
+      },
+      "model_type": "qwen3_5_vision",
+      "num_heads": 12,
+      "num_position_embeddings": 2304,
+      "out_hidden_size": 1024,
+      "output_attentions": false,
+      "output_hidden_states": false,
+      "patch_size": 16,
+      "problem_type": null,
+      "return_dict": true,
+      "rope_parameters": {
+        "rope_theta": 10000.0,
+        "rope_type": "axial"
+      },
+      "spatial_merge_size": 2,
+      "temporal_patch_size": 2
+    },
+    "vision_end_token_id": 248054,
+    "vision_start_token_id": 248053
+  },
+  "encoder_name": "Qwen/Qwen3.5-0.8B",
+  "model_type": "mojev-scorer",
+  "rank": 512,
+  "schema": {
+    "fields": [
+      {
+        "description": "the option the state and question license",
+        "kind": "choice",
+        "name": "answer",
+        "options": [
+          "slot-0",
+          "slot-1",
+          "slot-2",
+          "slot-3",
+          "slot-4",
+          "slot-5",
+          "slot-6",
+          "slot-7",
+          "slot-8",
+          "slot-9",
+          "slot-10",
+          "slot-11",
+          "slot-12",
+          "slot-13",
+          "slot-14",
+          "slot-15",
+          "slot-16",
+          "slot-17",
+          "slot-18",
+          "slot-19",
+          "slot-20",
+          "slot-21",
+          "slot-22",
+          "slot-23",
+          "slot-24",
+          "slot-25",
+          "slot-26",
+          "slot-27",
+          "slot-28",
+          "slot-29",
+          "slot-30",
+          "slot-31",
+          "slot-32",
+          "slot-33",
+          "slot-34",
+          "slot-35",
+          "slot-36",
+          "slot-37",
+          "slot-38",
+          "slot-39",
+          "slot-40",
+          "slot-41",
+          "slot-42",
+          "slot-43",
+          "slot-44",
+          "slot-45",
+          "slot-46",
+          "slot-47",
+          "slot-48",
+          "slot-49",
+          "slot-50",
+          "slot-51",
+          "slot-52",
+          "slot-53",
+          "slot-54",
+          "slot-55",
+          "slot-56",
+          "slot-57",
+          "slot-58",
+          "slot-59",
+          "slot-60",
+          "slot-61",
+          "slot-62",
+          "slot-63"
+        ]
+      }
+    ]
+  },
+  "transformers_version": "5.17.0"
+}

model.safetensors

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

modeling.py

@@ -0,0 +1,263 @@
+"""The scorer as a HuggingFace model: config, weights, and registration.
+
+A checkpoint used to be ``torch.save({"schema", "state_dict", "args"})``, which
+cost three things. Loading one ran arbitrary pickle, because the payload carried
+the training ``args`` beside the tensors and every reader had to pass
+``weights_only=False``. Every load read the pretrained encoder and then threw it
+away -- 4.32 s to fetch 473 tensors that ``load_state_dict`` immediately
+overwrote, against 0.30 s for the same weights through ``from_pretrained``. And
+the layout was private, so four call sites each re-derived it and the encoder's
+identity lived in a free-text ``args`` field rather than in a config, which is
+why every entry point wanted ``--hf-model`` passed alongside the checkpoint.
+
+So the model is a ``PreTrainedModel``. ``save_pretrained`` writes
+``config.json`` plus safetensors, ``from_pretrained`` reads them once, the
+encoder config nests inside the model config, and the schema travels with the
+weights. Registration below makes the directory loadable as
+``AutoModel.from_pretrained(path, trust_remote_code=True)`` by anyone with
+transformers and no copy of this package.
+
+**Dtypes are mixed and that is load-bearing.** The encoder is bf16; the head --
+``option_proj``, ``context_proj``, ``norm`` -- is fp32, which is how training
+produced it and what ``layer_norm`` needs. Both failure modes here were measured:
+building the model in fp32 before loading upcast the whole encoder, ``F32`` went
+to disk for all 477 tensors, and predictions drifted 4.7e-03; passing
+``dtype=torch.bfloat16`` to ``from_pretrained`` casts the head too and
+``layer_norm`` then raises. The per-module dtype has to come from ``__init__``,
+which is what ``_dtype_for`` below is for.
+"""
+
+from __future__ import annotations
+
+import torch
+from torch import nn
+from transformers import AutoConfig, AutoModel, PretrainedConfig, PreTrainedModel
+
+from .schema import Schema
+
+ENCODER_DTYPE = torch.bfloat16
+HEAD_DTYPE = torch.float32
+DEFAULT_TRAINING_CONTEXT_TOKENS = 16_384
+
+
+class PackedScorerConfig(PretrainedConfig):
+    """Everything needed to rebuild the scorer, including the encoder's own config.
+
+    ``schema`` is the JSON ``Schema.to_json`` already produces, so the schema a
+    checkpoint was trained with travels with its weights. ``context_tokens``
+    records the 16K state budget used in training. Inference callers can select
+    a larger state window without changing the model weights. Candidate text
+    has no separate token limit.
+    """
+
+    model_type = "mojev-scorer"
+    sub_configs = {"encoder_config": AutoConfig}
+
+    def __init__(self, encoder_config=None, rank: int = 512, schema=None,
+                 context_tokens: int = DEFAULT_TRAINING_CONTEXT_TOKENS,
+                 encoder_name: str | None = None, **kwargs) -> None:
+        # from_dict hands back a plain dict; for_model rebuilds the right class
+        # using the model_type that to_dict preserved.
+        if isinstance(encoder_config, dict):
+            encoder_config = AutoConfig.for_model(**encoder_config)
+        self.encoder_config = encoder_config
+        self.rank = rank
+        self.schema = schema
+        if context_tokens < 1:
+            raise ValueError("context_tokens must be positive")
+        self.context_tokens = context_tokens
+        kwargs.pop("option_tokens", None)
+        # Kept for provenance only. Loading does not consult it -- the weights are
+        # in the checkpoint -- but it records which encoder the run started from.
+        self.encoder_name = encoder_name
+        super().__init__(**kwargs)
+
+
+class PackedScorer(PreTrainedModel):
+    """Encode context and every option in one sequence, then score each option.
+
+    Layout per row:
+
+        [context tokens] [opt 0 tokens] [opt 1 tokens] ... [opt N-1 tokens]
+
+    The attention mask is block-diagonal over the option spans: an option sees
+    the context and itself, never another option. Without that, scores would
+    depend on which rivals happened to be present and permutation invariance
+    would be gone -- the property that separates this from putting the choices
+    in a prompt.
+    """
+
+    config_class = PackedScorerConfig
+    base_model_prefix = "encoder"
+    _supports_sdpa = True
+
+    def __init__(self, config: PackedScorerConfig) -> None:
+        super().__init__(config)
+        self.encoder = AutoModel.from_config(config.encoder_config, dtype=ENCODER_DTYPE)
+        width = self.hidden_size(config.encoder_config)
+        self.width = width
+        self.rank = config.rank
+        self.option_proj = nn.Linear(width, config.rank, bias=False, dtype=HEAD_DTYPE)
+        self.context_proj = nn.Linear(width, config.rank, bias=False, dtype=HEAD_DTYPE)
+        self.norm = nn.LayerNorm(width, dtype=HEAD_DTYPE)
+        # Sets all_tied_weights_keys and the rest of the composite-model state;
+        # without it from_pretrained raises AttributeError on the first of them.
+        self.post_init()
+
+    @staticmethod
+    def hidden_size(encoder_config) -> int:
+        """Multimodal configs nest the text stack; single-stack ones do not."""
+        return getattr(encoder_config, "text_config", encoder_config).hidden_size
+
+    @property
+    def schema(self) -> Schema:
+        return Schema.from_json(self.config.schema)
+
+    @classmethod
+    def from_encoder(cls, model_name: str, schema: Schema, rank: int = 512,
+                     context_tokens: int = DEFAULT_TRAINING_CONTEXT_TOKENS):
+        """Build a fresh scorer on a pretrained encoder -- the training entry point.
+
+        This is the one path that should read pretrained weights, because starting
+        from them is the point. Loading a trained checkpoint goes through
+        ``from_pretrained`` instead and reads the encoder exactly once.
+        """
+        config = PackedScorerConfig(
+            encoder_config=AutoConfig.from_pretrained(model_name),
+            rank=rank, schema=schema.to_json(), context_tokens=context_tokens,
+            encoder_name=str(model_name),
+        )
+        model = cls(config)
+        model.encoder = AutoModel.from_pretrained(model_name, dtype=ENCODER_DTYPE)
+        return model
+
+    def build_mask(self, context_span: torch.Tensor, field_span: torch.Tensor,
+                   option_span: torch.Tensor) -> torch.Tensor:
+        """(B, 1, L, L) additive mask enforcing a state -> question -> candidate tree.
+
+        Three levels, not two:
+
+            state      attends within itself
+            question   attends to the state and to itself
+            candidate  attends to the state, to *its own* question, and to itself
+
+        What the two-level version got wrong is the middle row. With candidates
+        hanging straight off the context, a question's wording reached every
+        candidate in the request, so the eight questions of a customer-service row
+        could see each other's text. Worse, question spans sat unmasked in the
+        sequence, which let candidates of question A read question B -- scores then
+        depend on which other questions happen to be in the same request, and the
+        parallel-sampling guarantee (independent decisions, exact permutation
+        invariance) no longer holds.
+
+        Sibling isolation is the point: two candidates of the same question cannot
+        see each other, and two questions of the same state cannot see each other.
+        """
+        batch, fields, width, total = option_span.shape
+        device = option_span.device
+        state = context_span > 0                                 # (B, L)
+        question = field_span > 0                                # (B, F, L)
+        candidate = option_span > 0                              # (B, F, N, L)
+
+        allow = torch.zeros(batch, total, total, dtype=torch.bool, device=device)
+        # state -> state
+        allow |= state[:, :, None] & state[:, None, :]
+        # question -> state, question -> itself
+        q_any = question.any(1)
+        allow |= q_any[:, :, None] & state[:, None, :]
+        allow |= torch.einsum("bfi,bfj->bij", question.float(), question.float()).bool()
+        # candidate -> state
+        c_any = candidate.any(1).any(1)
+        allow |= c_any[:, :, None] & state[:, None, :]
+        # candidate -> its own question (broadcast over that question's candidates)
+        own_question = torch.einsum(
+            "bfni,bfj->bij", candidate.float(), question.float()
+        ).bool()
+        allow |= own_question
+        # candidate -> itself only, never a sibling
+        allow |= torch.einsum("bfni,bfnj->bij", candidate.float(), candidate.float()).bool()
+        # Padding positions belong to no node in the tree, so every one of their
+        # rows would be entirely masked and softmax would divide by zero -- the
+        # NaN this produced showed up within 200 steps. Let each position attend
+        # to itself; the result is discarded because nothing pools from padding.
+        eye = torch.eye(total, dtype=torch.bool, device=device)
+        allow |= eye[None, :, :]
+        return torch.where(allow, 0.0, torch.finfo(torch.float32).min).unsqueeze(1)
+
+    def forward(self, batch: dict) -> torch.Tensor:
+        # The tree mask, not a plain padding mask: without it every span in the
+        # sequence is mutually visible and the per-decision independence this
+        # design rests on is lost.
+        mask = self.build_mask(
+            batch["context_span"], batch["field_span"], batch["option_span"]
+        )
+        # Padding columns are unreachable, but the diagonal must survive or the
+        # padding rows go fully masked again and softmax divides by zero.
+        floor = torch.finfo(mask.dtype).min
+        total = mask.shape[-1]
+        keep = batch["packed_mask"][:, None, None, :] | torch.eye(
+            total, dtype=torch.bool, device=mask.device
+        )[None, None]
+        mask = mask.masked_fill(~keep, floor)
+        extra = {}
+        if "pixel_values" in batch:
+            extra["pixel_values"] = batch["pixel_values"]
+            extra["image_grid_thw"] = batch["image_grid_thw"]
+            # The processor sizes mm_token_type_ids to the state alone; packing
+            # appends questions and candidates, so it is padded with zeros (text)
+            # out to the full sequence.
+            token_types = batch["mm_token_type_ids"]
+            if token_types.shape[1] < total:
+                token_types = torch.cat([
+                    token_types,
+                    token_types.new_zeros(token_types.shape[0], total - token_types.shape[1]),
+                ], dim=1)
+            extra["mm_token_type_ids"] = token_types[:, :total]
+            # M-RoPE derives 3D positions by indexing the attention mask as a 2D
+            # (B, L) padding mask. Ours is the 4D additive tree mask, which that
+            # code cannot read -- it raised IndexError on attention_mask[b].bool().
+            # Compute the positions here from the real padding mask and hand them
+            # over, so the encoder skips its own derivation. Position ids are
+            # per-token, so the tree mask is irrelevant to them.
+            extra["position_ids"] = self.encoder.get_rope_index(
+                batch["packed_ids"],
+                image_grid_thw=batch["image_grid_thw"],
+                attention_mask=batch["packed_mask"].long(),
+                mm_token_type_ids=extra["mm_token_type_ids"],
+            )[0]
+        hidden = self.encoder(
+            input_ids=batch["packed_ids"],
+            attention_mask=mask,
+            **extra,
+        ).last_hidden_state.float()
+        hidden = self.norm(hidden)
+
+        # Mean-pool the context span and each option span.
+        context = (hidden * batch["context_span"].unsqueeze(-1)).sum(1)
+        context = context / batch["context_span"].sum(-1, keepdim=True).clamp_min(1)
+        query = self.context_proj(context)                     # (B, r)
+
+        spans = batch["option_span"]                           # (B, F, N, L)
+        weights = spans.sum(-1, keepdim=True).clamp_min(1)
+        pooled = torch.einsum("bfnl,blw->bfnw", spans, hidden) / weights
+        keys = self.option_proj(pooled)                        # (B, F, N, r)
+
+        # The field's words are pooled from the sequence like everything else,
+        # and added to the context query. No per-field parameters exist.
+        field = torch.einsum("bfl,blw->bfw", batch["field_span"], hidden)
+        field = field / batch["field_span"].sum(-1, keepdim=True).clamp_min(1)
+        query = query[:, None, :] + self.context_proj(field)        # (B, F, r)
+        logits = (query[:, :, None, :] * keys).sum(-1) / self.rank ** 0.5
+        return logits.masked_fill(~batch["option_mask"], torch.finfo(logits.dtype).min)
+
+
+# Registering against the Auto classes, and recording auto_map in config.json, is
+# what makes a saved directory the whole model: someone with transformers and no
+# copy of this package can load it with
+# AutoModel.from_pretrained(path, trust_remote_code=True). These have to run at
+# module import in a real module -- defining the classes in __main__ silently
+# writes auto_map: null and the directory stops being portable.
+AutoConfig.register(PackedScorerConfig.model_type, PackedScorerConfig, exist_ok=True)
+AutoModel.register(PackedScorerConfig, PackedScorer, exist_ok=True)
+PackedScorerConfig.register_for_auto_class()
+PackedScorer.register_for_auto_class("AutoModel")

preprocessor_config.json

@@ -0,0 +1,21 @@
+{
+  "size": {
+    "longest_edge": 65536,
+    "shortest_edge": 65536
+  },
+  "patch_size": 16,
+  "temporal_patch_size": 2,
+  "merge_size": 2,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "processor_class": "Qwen3VLProcessor",
+  "image_processor_type": "Qwen2VLImageProcessorFast"
+}

schema.py

@@ -0,0 +1,178 @@
+"""Typed decision schemas.
+
+A schema declares, in advance, every field a query returns and every value each
+field may take. Type safety is therefore constructive: the model normalises only
+over declared options, so a returned struct cannot name an option that does not
+exist and cannot omit a declared field. Nothing is parsed or validated at
+inference time.
+
+Four field kinds cover the shapes decisions actually take:
+
+- ``choice``  exactly one of N unordered options (softmax over N)
+- ``bool``    a two-option choice, kept separate so it calibrates on its own
+- ``multi``   any subset of N options (independent sigmoid per option)
+- ``bucket``  one of N *ordered* options, scored with cumulative logits so that
+              the order is part of the model rather than an accident of labels
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+
+Kind = Literal["choice", "bool", "multi", "bucket"]
+KINDS: tuple[Kind, ...] = ("choice", "bool", "multi", "bucket")
+
+BOOL_OPTIONS = ("false", "true")
+
+
+@dataclass(frozen=True)
+class Field:
+    """One decision within a schema."""
+
+    name: str
+    kind: Kind = "choice"
+    options: tuple[str, ...] = BOOL_OPTIONS
+    description: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("field name must not be empty")
+        if self.kind not in KINDS:
+            raise ValueError(f"{self.name}: unknown kind {self.kind!r}, expected one of {KINDS}")
+        if self.kind == "bool":
+            if self.options != BOOL_OPTIONS:
+                raise ValueError(f"{self.name}: bool options are fixed to {BOOL_OPTIONS}")
+        elif len(self.options) < 2:
+            raise ValueError(f"{self.name}: {self.kind} needs at least two options")
+        if len(set(self.options)) != len(self.options):
+            raise ValueError(f"{self.name}: options must be unique")
+        if any(not option for option in self.options):
+            raise ValueError(f"{self.name}: options must not be empty strings")
+
+    @property
+    def cardinality(self) -> int:
+        return len(self.options)
+
+    @property
+    def prompt(self) -> str:
+        """The text the model reads to know what this field asks.
+
+        This is what makes a schema the model never trained on usable: the field
+        is identified by its words, not by a row index into a learned table. An
+        earlier version stored one trainable vector per field, which meant adding
+        a field to a schema raised a shape error and renaming one made the field
+        unrecognisable.
+        """
+        parts = [self.name.replace("_", " ")]
+        if self.description:
+            parts.append(self.description)
+        parts.append(f"kind: {self.kind}")
+        if self.kind != "choice" or len(self.options) <= 8:
+            parts.append("options: " + ", ".join(self.options[:8]))
+        return " | ".join(parts)
+
+    @property
+    def single(self) -> bool:
+        """True when exactly one option is correct, so the field owns a softmax."""
+        return self.kind in ("choice", "bool", "bucket")
+
+    def index(self, value: str) -> int:
+        try:
+            return self.options.index(value)
+        except ValueError:
+            raise ValueError(
+                f"{self.name}: {value!r} is not a declared option; expected one of {self.options}"
+            ) from None
+
+    def encode(self, value) -> list[int] | int:
+        """Label for one row: an option index, or a 0/1 vector for ``multi``."""
+        if self.kind == "bool":
+            if not isinstance(value, bool):
+                raise ValueError(f"{self.name}: expected a bool, got {value!r}")
+            return int(value)
+        if self.kind == "multi":
+            if isinstance(value, str) or not isinstance(value, (list, tuple, set)):
+                raise ValueError(f"{self.name}: multi expects a list of options, got {value!r}")
+            chosen = {self.index(item) for item in value}
+            return [int(index in chosen) for index in range(self.cardinality)]
+        if not isinstance(value, str):
+            raise ValueError(f"{self.name}: expected an option string, got {value!r}")
+        return self.index(value)
+
+    def decode(self, probabilities, threshold: float = 0.5):
+        """Probabilities for this field -> the typed value plus its confidence."""
+        if len(probabilities) != self.cardinality:
+            raise ValueError(
+                f"{self.name}: expected {self.cardinality} probabilities, got {len(probabilities)}"
+            )
+        if self.kind == "multi":
+            selected = [option for option, p in zip(self.options, probabilities) if p >= threshold]
+            confidence = min((max(p, 1.0 - p) for p in probabilities), default=1.0)
+            return selected, float(confidence)
+        best = max(range(self.cardinality), key=probabilities.__getitem__)
+        value = bool(best) if self.kind == "bool" else self.options[best]
+        return value, float(probabilities[best])
+
+
+@dataclass(frozen=True)
+class Schema:
+    """The full set of fields one query returns."""
+
+    fields: tuple[Field, ...]
+
+    def __post_init__(self) -> None:
+        if not self.fields:
+            raise ValueError("a schema needs at least one field")
+        names = [field.name for field in self.fields]
+        if len(set(names)) != len(names):
+            raise ValueError("field names must be unique")
+
+    def __len__(self) -> int:
+        return len(self.fields)
+
+    def __iter__(self):
+        return iter(self.fields)
+
+    def __getitem__(self, name: str) -> Field:
+        for field in self.fields:
+            if field.name == name:
+                return field
+        raise KeyError(name)
+
+    @property
+    def max_cardinality(self) -> int:
+        return max(field.cardinality for field in self.fields)
+
+    def encode(self, values: dict) -> list:
+        """One row of labels, in field order. Every declared field must be present."""
+        missing = [field.name for field in self.fields if field.name not in values]
+        if missing:
+            raise ValueError(f"missing labels for fields: {missing}")
+        extra = set(values) - {field.name for field in self.fields}
+        if extra:
+            raise ValueError(f"labels for undeclared fields: {sorted(extra)}")
+        return [field.encode(values[field.name]) for field in self.fields]
+
+    @property
+    def prompts(self) -> tuple[str, ...]:
+        return tuple(field.prompt for field in self.fields)
+
+    def to_json(self) -> dict:
+        return {
+            "fields": [
+                {"name": f.name, "kind": f.kind, "options": list(f.options),
+                 "description": f.description}
+                for f in self.fields
+            ]
+        }
+
+    @classmethod
+    def from_json(cls, payload: dict) -> "Schema":
+        return cls(
+            tuple(
+                Field(item["name"], item.get("kind", "choice"), tuple(item["options"]),
+                      item.get("description", ""))
+                for item in payload["fields"]
+            )
+        )

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523
+size 19989325

tokenizer_config.json

@@ -0,0 +1,32 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

video_preprocessor_config.json

@@ -0,0 +1,21 @@
+{
+  "size": {
+    "longest_edge": 25165824,
+    "shortest_edge": 4096
+  },
+  "patch_size": 16,
+  "temporal_patch_size": 2,
+  "merge_size": 2,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "processor_class": "Qwen3VLProcessor",
+  "video_processor_type": "Qwen3VLVideoProcessor"
+}