Add files using upload-large-folder tool

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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

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 2026 Alibaba Cloud
+
+   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,155 @@
+---
+license: apache-2.0
+library_name: transformers
+pipeline_tag: image-text-to-text
+base_model: Cloudflare/clef
+base_model_relation: quantized
+tags:
+- clef
+- systemone
+- nvfp4
+- fp8
+- compressed-tensors
+- llm-compressor
+- vllm
+- multimodal
+- structured-output
+- classification
+- custom-code
+---
+
+# Clef — NVFP4
+
+A mixed NVFP4 / FP8 quantization of [Cloudflare/clef](https://huggingface.co/Cloudflare/clef),
+the 27B multimodal decision model. **Unofficial — not affiliated with or endorsed by Cloudflare.**
+
+Clef answers typed questions about a state (text, JSON, images, video) with one probability per
+allowed option, in a single prefill pass. Its value is the probabilities, so this quant was checked
+option by option against the BF16 release, not only on accuracy.
+
+**23 GB on disk (BF16 release: 55 GB); 20.2 GiB of weights in vLLM.**
+
+## What is quantized
+
+| Part | Format |
+|---|---|
+| MLP `gate/up/down_proj`, layers 0–55 | NVFP4 (W4A4, group 16, FP8 scales, static activation global scale) |
+| MLP `gate/up/down_proj`, layers 56–63 | FP8 (per-channel weights, dynamic per-token activations) |
+| Full-attention `q/k/v/o_proj`; linear-attention `in_proj_qkv/in_proj_z/out_proj` | FP8 (as above) |
+| Linear-attention `in_proj_a/in_proj_b`, norms, conv, embeddings | BF16 |
+| Vision encoder | BF16 |
+| `lm_head` | BF16 — the joint head reads its rows directly as option embeddings |
+| Joint schema head (`joint_head.safetensors`) | BF16, unchanged from the release |
+
+The layout follows the community recipe for Qwen3.8-27B with one change: `lm_head` stays BF16.
+The last eight layers stay FP8 on purpose: comparing the release against
+[Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B), the vision encoder and early layers
+are byte-identical, and Clef's post-training lives in the upper layers.
+
+**Method:** llm-compressor `QuantizationModifier` (round-to-nearest, no GPTQ), calibrated on 374
+Clef-format records — 128 BANKING77 intent questions (77-way and 10-way schemas), 150 game-agent
+state records with a `choice` question, and 96 Flickr30k photos with `noul`/`choice`/`score`
+questions. Calibration and evaluation records are disjoint. `recipe.yaml` is the exact recipe.
+
+## Drift vs BF16
+
+Same 615 records through the BF16 release and through this checkpoint on **vLLM's real NVFP4/FP8
+kernels** (FlashInfer CUTLASS FP4 GEMM). `agreement` = top option identical to BF16. `TV` = mean
+total-variation distance between the per-question distributions (0 = identical, 1 = disjoint).
+
+| Eval set | Questions | Agreement | Mean TV | Accuracy BF16 → NVFP4 |
+|---|---:|---:|---:|---|
+| BANKING77 test, full 77-way schema | 400 | 98.5% | 0.019 | 94.25% → 94.50% |
+| Flickr30k photos, 4 mixed-type questions each | 256 | 96.9% | 0.017 | (no labels) |
+| Game-agent states, 2–4 option `choice` | 150 | 96.7% | 0.047 | 68.7% → 67.3% * |
+| README invoice example | 2 | 100% | 0.0007 | — |
+
+\* graded against synthetic labels that the BF16 model itself matches only 69% of the time; read the
+agreement column, not the accuracy, for that row.
+
+Disagreements are near-ties: in the calibration-time (fake-quant) run, the 15 flipped questions had a
+median BF16 top-1/top-2 margin of 0.13 (11 of 15 under 0.2), against 0.95 for questions that agreed.
+
+## Speed
+
+One decision at a time (batch 1, the latency case) on an NVIDIA DGX Spark (GB10, 273 GB/s unified
+memory), vLLM 0.23.1, CUDA graphs on:
+
+| Record | Input tokens | Median latency |
+|---|---:|---:|
+| text state, 1 question | 288 | 177 ms |
+| 640 px image + 4 questions | 621 | 257 ms |
+| BANKING77, 77 options | 1834 | 705 ms |
+
+The joint head adds 3–6 ms of that. On this machine the floor (~170 ms) is set by reading the
+weights once per pass; GPUs with more memory bandwidth should be considerably quicker (not measured here).
+
+## Usage
+
+The files, record format and `systemone` API are the same as the BF16 release; see the
+[Clef model card](https://huggingface.co/Cloudflare/clef) for the full input format.
+
+### vLLM (recommended — real FP4 kernels)
+
+`clef_vllm.py` runs the backbone in vLLM as a pooling model (final hidden state of every token)
+and Clef's joint head on top, in the same process. Needs a Blackwell GPU for NVFP4 and a vLLM build
+with `Qwen3_5ForConditionalGeneration` (tested: 0.23.1 nightly).
+
+```python
+import sys
+from huggingface_hub import snapshot_download
+
+path = snapshot_download("simonlehmann/clef-NVFP4")
+sys.path.insert(0, path)
+from clef_vllm import ClefVLLM
+
+clef = ClefVLLM(path, max_model_len=16384, gpu_memory_utilization=0.4)
+response = clef.systemone({
+    "model": "clef",
+    "state": "Our checkout started returning errors and orders are blocked.",
+    "questions": {
+        "department": {
+            "type": "choice",
+            "instructions": "Which team should handle the message?",
+            "criteria": {"billing": "Payments or invoices", "technical": "Bugs or outages"},
+        },
+        "urgency": {"type": "score", "criteria": ["Can wait", "This week", "Today"]},
+        "outage": {"type": "noul", "instructions": "Is a service down?"},
+    },
+})
+print(response["answers"])
+
+# Many records at once, images included (PIL), batched through vLLM:
+# clef.probabilities([record, ...]) -> [{question_id: {option_id: probability}}, ...]
+```
+
+`max_images` / `max_videos` in the constructor set vLLM's per-request media limits (default 1 image).
+
+### transformers (compatibility — decompresses to BF16)
+
+transformers' compressed-tensors integration cannot run the mixed NVFP4/FP8 layers compressed, so
+load with `run_compressed=False`. This decompresses to BF16 at load time (~57 GB of GPU memory, no
+speed-up): useful to check outputs, not to save memory.
+
+```python
+import sys
+from huggingface_hub import snapshot_download
+from transformers import CompressedTensorsConfig
+
+path = snapshot_download("simonlehmann/clef-NVFP4")
+sys.path.insert(0, path)
+from joint_schema_model import load_release_model, systemone
+
+model, processor = load_release_model(
+    path, device="cuda", quantization_config=CompressedTensorsConfig(run_compressed=False)
+)
+```
+
+Requires `compressed-tensors` in addition to `torch` and `transformers`.
+
+## License
+
+Apache-2.0, following [Cloudflare/clef](https://huggingface.co/Cloudflare/clef) and
+[Qwen/Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B). `joint_schema_model.py`,
+`joint_head.safetensors`, `LICENSE` and the tokenizer/processor files are redistributed unchanged
+from the Cloudflare release; `clef_vllm.py` and the quantized weights are new.

chat_template.jinja

@@ -0,0 +1,170 @@
+{%- 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 %}
+{%- set reasoning_instructions = '' %}
+{%- if enable_thinking is undefined or enable_thinking is true %}
+    {%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}
+    {%- if resolved_reasoning_effort not in ('xhigh', 'medium', 'low') %}
+        {{- raise_exception('Unexpected reasoning effort ' ~ reasoning_effort ~ '. Supported types are xhigh (default), medium, and low.') }}
+    {%- endif %}
+    {%- if resolved_reasoning_effort == 'xhigh' %}
+        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
+    {%- elif resolved_reasoning_effort == 'low' %}
+        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
+    {%- endif %}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {%- if reasoning_instructions %}
+        {{- reasoning_instructions + '\n\n' }}
+    {%- endif %}
+    {{- "# 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 %}
+        {%- if content %}
+            {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '')  + content + '<|im_end|>\n' }}
+        {%- elif reasoning_instructions %}
+            {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
+        {%- endif %}
+    {%- elif reasoning_instructions %}
+        {{- '<|im_start|>system\n' + reasoning_instructions + '<|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 %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if preserve_thinking is undefined or preserve_thinking is true or 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 and tool_call.arguments != '' %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | string if args_value is string else args_value | tojson | safe %}
+                        {{- 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 false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

clef_vllm.py

@@ -0,0 +1,121 @@
+"""Run Clef-NVFP4 on vLLM: the backbone as a pooling model (final hidden state of every
+token, on NVFP4/FP8 kernels), Clef's joint schema head on top in the same process.
+
+    from clef_vllm import ClefVLLM
+    clef = ClefVLLM("path/to/clef-NVFP4")
+    clef.systemone({"model": "clef", "state": "...", "questions": {...}})
+
+Tested with vLLM 0.23.1 (nightly, CUDA 13, aarch64 / Blackwell sm_121).
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+# The engine runs in this process: no __main__ guard needed, no IPC per decision.
+os.environ.setdefault("VLLM_ENABLE_V1_MULTIPROCESSING", "0")
+
+import torch  # noqa: E402
+from safetensors import safe_open  # noqa: E402
+from safetensors.torch import load_file  # noqa: E402
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from joint_schema_model import (  # noqa: E402
+    QUESTION_TYPES,
+    JointSchemaHead,
+    collate_records,
+    encode_record,
+    systemone_answer,
+)
+
+
+class ClefVLLM:
+    def __init__(self, path: str | Path, max_model_len: int = 16384, gpu_memory_utilization: float = 0.4,
+                 max_images: int = 1, max_videos: int = 0, **llm_kwargs: Any) -> None:
+        from transformers import AutoProcessor
+        from vllm import LLM
+        from vllm.config import PoolerConfig
+
+        path = Path(path)
+        self.processor = AutoProcessor.from_pretrained(path)
+        self.tokenizer = self.processor.tokenizer
+        self.media_pads = {self.tokenizer.convert_tokens_to_ids(t) for t in ("<|image_pad|>", "<|video_pad|>")}
+        self.llm = LLM(
+            model=str(path),
+            runner="pooling",
+            pooler_config=PoolerConfig(task="token_embed", tok_pooling_type="ALL", use_activation=False),
+            max_model_len=max_model_len,
+            gpu_memory_utilization=gpu_memory_utilization,
+            limit_mm_per_prompt={"image": max_images, "video": max_videos},
+            enable_prefix_caching=False,
+            **llm_kwargs,
+        )
+        self.device = torch.device("cuda")
+        head = JointSchemaHead(**json.loads((path / "joint_head_config.json").read_text()))
+        head.load_state_dict(load_file(path / "joint_head.safetensors"), strict=True)
+        self.head = head.to(self.device, torch.bfloat16).eval()
+        # The head reads lm_head rows as option embeddings; vLLM's pooling model drops lm_head.
+        weight_map = json.loads((path / "model.safetensors.index.json").read_text())["weight_map"]
+        with safe_open(str(path / weight_map["lm_head.weight"]), framework="pt", device="cuda") as f:
+            self.lm_head = f.get_tensor("lm_head.weight").to(torch.bfloat16)
+
+    def _prompt(self, record: dict[str, Any], input_ids: tuple[int, ...]) -> dict[str, Any]:
+        # Collapse each expanded image/video pad run to one token; vLLM re-expands it from the
+        # media, so the returned hidden states line up with Clef's input_ids position for position.
+        ids: list[int] = []
+        for i, token in enumerate(input_ids):
+            if token in self.media_pads and i and input_ids[i - 1] == token:
+                continue
+            ids.append(token)
+        prompt: dict[str, Any] = {"prompt_token_ids": ids}
+        media = {}
+        if record.get("images"):
+            media["image"] = record["images"] if len(record["images"]) > 1 else record["images"][0]
+        if record.get("videos"):
+            media["video"] = record["videos"] if len(record["videos"]) > 1 else record["videos"][0]
+        if media:
+            prompt["multi_modal_data"] = media
+        return prompt
+
+    @torch.inference_mode()
+    def probabilities(self, records: list[dict[str, Any]], max_length: int = 16384) -> list[dict[str, dict[str, float]]]:
+        """Per record, per question: {option_id: probability}. Records are batched through vLLM."""
+        encoded = [encode_record(self.tokenizer, r, max_length=max_length, processor=self.processor) for r in records]
+        outputs = self.llm.encode([self._prompt(r, e.input_ids) for r, e in zip(records, encoded)],
+                                  pooling_task="token_embed", use_tqdm=False)
+        results = []
+        for enc, out in zip(encoded, outputs):
+            hidden = out.outputs.data.to(self.device, torch.bfloat16)
+            if hidden.shape[0] != len(enc.input_ids):
+                raise RuntimeError(f"vLLM returned {hidden.shape[0]} positions for {len(enc.input_ids)} input tokens")
+            batch = collate_records([enc], self.tokenizer.pad_token_id, self.device)
+            logits = self.head(hidden.unsqueeze(0), batch["input_ids"], batch["attention_mask"],
+                               batch["records"], self.lm_head)[0]
+            results.append({
+                q.question_id: dict(zip(q.option_ids, l.float().softmax(-1).tolist()))
+                for q, l in zip(enc.questions, logits)
+            })
+        return results
+
+    def systemone(self, request: dict[str, Any], max_length: int = 16384) -> dict[str, Any]:
+        """Same request/response body as joint_schema_model.systemone (Jev/SystemOne /v1/systemone)."""
+        questions = request.get("questions")
+        if not isinstance(request.get("model"), str) or "state" not in request:
+            raise ValueError("model and state are required")
+        if not isinstance(questions, dict) or not questions:
+            raise ValueError("at least one question is required")
+        for question_id, question in questions.items():
+            if question.get("type") not in QUESTION_TYPES:
+                raise ValueError(f"{question_id}: type must be noul, choice, or score")
+            if question["type"] != "noul" and not question.get("criteria"):
+                raise ValueError(f"{question_id}: criteria must not be empty")
+        probs = self.probabilities([request], max_length=max_length)[0]
+        encoded_len = len(encode_record(self.tokenizer, request, max_length=max_length, processor=self.processor).input_ids)
+        return {
+            "model": request["model"],
+            "answers": {qid: systemone_answer(questions[qid], p) for qid, p in probs.items()},
+            "usage": {"input_tokens": encoded_len, "output_tokens": 0},
+        }

config.json

@@ -0,0 +1,435 @@
+{
+  "architectures": [
+    "Qwen3_5ForConditionalGeneration"
+  ],
+  "dtype": "bfloat16",
+  "image_token_id": 248056,
+  "language_model_only": false,
+  "model_type": "qwen3_5",
+  "quantization_config": {
+    "config_groups": {
+      "group_0": {
+        "format": "float-quantized",
+        "input_activations": {
+          "actorder": null,
+          "block_structure": null,
+          "dynamic": true,
+          "group_size": null,
+          "num_bits": 8,
+          "observer": null,
+          "observer_kwargs": {},
+          "scale_dtype": null,
+          "strategy": "token",
+          "symmetric": true,
+          "type": "float",
+          "zp_dtype": null
+        },
+        "output_activations": null,
+        "targets": [
+          "re:.*self_attn\\.(q|k|v|o)_proj$",
+          "re:.*linear_attn\\.(in_proj_qkv|in_proj_z|out_proj)$",
+          "re:.*layers\\.(56|57|58|59|60|61|62|63)\\.mlp\\.(gate|up|down)_proj$"
+        ],
+        "weights": {
+          "actorder": null,
+          "block_structure": null,
+          "dynamic": false,
+          "group_size": null,
+          "num_bits": 8,
+          "observer": "memoryless_minmax",
+          "observer_kwargs": {},
+          "scale_dtype": null,
+          "strategy": "channel",
+          "symmetric": true,
+          "type": "float",
+          "zp_dtype": null
+        }
+      },
+      "group_1": {
+        "format": "nvfp4-pack-quantized",
+        "input_activations": {
+          "actorder": null,
+          "block_structure": null,
+          "dynamic": "local",
+          "group_size": 16,
+          "num_bits": 4,
+          "observer": "static_minmax",
+          "observer_kwargs": {},
+          "scale_dtype": "torch.float8_e4m3fn",
+          "strategy": "tensor_group",
+          "symmetric": true,
+          "type": "float",
+          "zp_dtype": null
+        },
+        "output_activations": null,
+        "targets": [
+          "re:.*layers\\.([0-9]|[1-4][0-9]|5[0-5])\\.mlp\\.(gate|up|down)_proj$"
+        ],
+        "weights": {
+          "actorder": null,
+          "block_structure": null,
+          "dynamic": false,
+          "group_size": 16,
+          "num_bits": 4,
+          "observer": "memoryless_minmax",
+          "observer_kwargs": {},
+          "scale_dtype": "torch.float8_e4m3fn",
+          "strategy": "tensor_group",
+          "symmetric": true,
+          "type": "float",
+          "zp_dtype": null
+        }
+      }
+    },
+    "format": "mixed-precision",
+    "global_compression_ratio": null,
+    "ignore": [
+      "model.visual.blocks.0.attn.qkv",
+      "model.visual.blocks.0.attn.proj",
+      "model.visual.blocks.0.mlp.linear_fc1",
+      "model.visual.blocks.0.mlp.linear_fc2",
+      "model.visual.blocks.1.attn.qkv",
+      "model.visual.blocks.1.attn.proj",
+      "model.visual.blocks.1.mlp.linear_fc1",
+      "model.visual.blocks.1.mlp.linear_fc2",
+      "model.visual.blocks.2.attn.qkv",
+      "model.visual.blocks.2.attn.proj",
+      "model.visual.blocks.2.mlp.linear_fc1",
+      "model.visual.blocks.2.mlp.linear_fc2",
+      "model.visual.blocks.3.attn.qkv",
+      "model.visual.blocks.3.attn.proj",
+      "model.visual.blocks.3.mlp.linear_fc1",
+      "model.visual.blocks.3.mlp.linear_fc2",
+      "model.visual.blocks.4.attn.qkv",
+      "model.visual.blocks.4.attn.proj",
+      "model.visual.blocks.4.mlp.linear_fc1",
+      "model.visual.blocks.4.mlp.linear_fc2",
+      "model.visual.blocks.5.attn.qkv",
+      "model.visual.blocks.5.attn.proj",
+      "model.visual.blocks.5.mlp.linear_fc1",
+      "model.visual.blocks.5.mlp.linear_fc2",
+      "model.visual.blocks.6.attn.qkv",
+      "model.visual.blocks.6.attn.proj",
+      "model.visual.blocks.6.mlp.linear_fc1",
+      "model.visual.blocks.6.mlp.linear_fc2",
+      "model.visual.blocks.7.attn.qkv",
+      "model.visual.blocks.7.attn.proj",
+      "model.visual.blocks.7.mlp.linear_fc1",
+      "model.visual.blocks.7.mlp.linear_fc2",
+      "model.visual.blocks.8.attn.qkv",
+      "model.visual.blocks.8.attn.proj",
+      "model.visual.blocks.8.mlp.linear_fc1",
+      "model.visual.blocks.8.mlp.linear_fc2",
+      "model.visual.blocks.9.attn.qkv",
+      "model.visual.blocks.9.attn.proj",
+      "model.visual.blocks.9.mlp.linear_fc1",
+      "model.visual.blocks.9.mlp.linear_fc2",
+      "model.visual.blocks.10.attn.qkv",
+      "model.visual.blocks.10.attn.proj",
+      "model.visual.blocks.10.mlp.linear_fc1",
+      "model.visual.blocks.10.mlp.linear_fc2",
+      "model.visual.blocks.11.attn.qkv",
+      "model.visual.blocks.11.attn.proj",
+      "model.visual.blocks.11.mlp.linear_fc1",
+      "model.visual.blocks.11.mlp.linear_fc2",
+      "model.visual.blocks.12.attn.qkv",
+      "model.visual.blocks.12.attn.proj",
+      "model.visual.blocks.12.mlp.linear_fc1",
+      "model.visual.blocks.12.mlp.linear_fc2",
+      "model.visual.blocks.13.attn.qkv",
+      "model.visual.blocks.13.attn.proj",
+      "model.visual.blocks.13.mlp.linear_fc1",
+      "model.visual.blocks.13.mlp.linear_fc2",
+      "model.visual.blocks.14.attn.qkv",
+      "model.visual.blocks.14.attn.proj",
+      "model.visual.blocks.14.mlp.linear_fc1",
+      "model.visual.blocks.14.mlp.linear_fc2",
+      "model.visual.blocks.15.attn.qkv",
+      "model.visual.blocks.15.attn.proj",
+      "model.visual.blocks.15.mlp.linear_fc1",
+      "model.visual.blocks.15.mlp.linear_fc2",
+      "model.visual.blocks.16.attn.qkv",
+      "model.visual.blocks.16.attn.proj",
+      "model.visual.blocks.16.mlp.linear_fc1",
+      "model.visual.blocks.16.mlp.linear_fc2",
+      "model.visual.blocks.17.attn.qkv",
+      "model.visual.blocks.17.attn.proj",
+      "model.visual.blocks.17.mlp.linear_fc1",
+      "model.visual.blocks.17.mlp.linear_fc2",
+      "model.visual.blocks.18.attn.qkv",
+      "model.visual.blocks.18.attn.proj",
+      "model.visual.blocks.18.mlp.linear_fc1",
+      "model.visual.blocks.18.mlp.linear_fc2",
+      "model.visual.blocks.19.attn.qkv",
+      "model.visual.blocks.19.attn.proj",
+      "model.visual.blocks.19.mlp.linear_fc1",
+      "model.visual.blocks.19.mlp.linear_fc2",
+      "model.visual.blocks.20.attn.qkv",
+      "model.visual.blocks.20.attn.proj",
+      "model.visual.blocks.20.mlp.linear_fc1",
+      "model.visual.blocks.20.mlp.linear_fc2",
+      "model.visual.blocks.21.attn.qkv",
+      "model.visual.blocks.21.attn.proj",
+      "model.visual.blocks.21.mlp.linear_fc1",
+      "model.visual.blocks.21.mlp.linear_fc2",
+      "model.visual.blocks.22.attn.qkv",
+      "model.visual.blocks.22.attn.proj",
+      "model.visual.blocks.22.mlp.linear_fc1",
+      "model.visual.blocks.22.mlp.linear_fc2",
+      "model.visual.blocks.23.attn.qkv",
+      "model.visual.blocks.23.attn.proj",
+      "model.visual.blocks.23.mlp.linear_fc1",
+      "model.visual.blocks.23.mlp.linear_fc2",
+      "model.visual.blocks.24.attn.qkv",
+      "model.visual.blocks.24.attn.proj",
+      "model.visual.blocks.24.mlp.linear_fc1",
+      "model.visual.blocks.24.mlp.linear_fc2",
+      "model.visual.blocks.25.attn.qkv",
+      "model.visual.blocks.25.attn.proj",
+      "model.visual.blocks.25.mlp.linear_fc1",
+      "model.visual.blocks.25.mlp.linear_fc2",
+      "model.visual.blocks.26.attn.qkv",
+      "model.visual.blocks.26.attn.proj",
+      "model.visual.blocks.26.mlp.linear_fc1",
+      "model.visual.blocks.26.mlp.linear_fc2",
+      "model.visual.merger.linear_fc1",
+      "model.visual.merger.linear_fc2",
+      "model.language_model.layers.0.linear_attn.in_proj_b",
+      "model.language_model.layers.0.linear_attn.in_proj_a",
+      "model.language_model.layers.1.linear_attn.in_proj_b",
+      "model.language_model.layers.1.linear_attn.in_proj_a",
+      "model.language_model.layers.2.linear_attn.in_proj_b",
+      "model.language_model.layers.2.linear_attn.in_proj_a",
+      "model.language_model.layers.4.linear_attn.in_proj_b",
+      "model.language_model.layers.4.linear_attn.in_proj_a",
+      "model.language_model.layers.5.linear_attn.in_proj_b",
+      "model.language_model.layers.5.linear_attn.in_proj_a",
+      "model.language_model.layers.6.linear_attn.in_proj_b",
+      "model.language_model.layers.6.linear_attn.in_proj_a",
+      "model.language_model.layers.8.linear_attn.in_proj_b",
+      "model.language_model.layers.8.linear_attn.in_proj_a",
+      "model.language_model.layers.9.linear_attn.in_proj_b",
+      "model.language_model.layers.9.linear_attn.in_proj_a",
+      "model.language_model.layers.10.linear_attn.in_proj_b",
+      "model.language_model.layers.10.linear_attn.in_proj_a",
+      "model.language_model.layers.12.linear_attn.in_proj_b",
+      "model.language_model.layers.12.linear_attn.in_proj_a",
+      "model.language_model.layers.13.linear_attn.in_proj_b",
+      "model.language_model.layers.13.linear_attn.in_proj_a",
+      "model.language_model.layers.14.linear_attn.in_proj_b",
+      "model.language_model.layers.14.linear_attn.in_proj_a",
+      "model.language_model.layers.16.linear_attn.in_proj_b",
+      "model.language_model.layers.16.linear_attn.in_proj_a",
+      "model.language_model.layers.17.linear_attn.in_proj_b",
+      "model.language_model.layers.17.linear_attn.in_proj_a",
+      "model.language_model.layers.18.linear_attn.in_proj_b",
+      "model.language_model.layers.18.linear_attn.in_proj_a",
+      "model.language_model.layers.20.linear_attn.in_proj_b",
+      "model.language_model.layers.20.linear_attn.in_proj_a",
+      "model.language_model.layers.21.linear_attn.in_proj_b",
+      "model.language_model.layers.21.linear_attn.in_proj_a",
+      "model.language_model.layers.22.linear_attn.in_proj_b",
+      "model.language_model.layers.22.linear_attn.in_proj_a",
+      "model.language_model.layers.24.linear_attn.in_proj_b",
+      "model.language_model.layers.24.linear_attn.in_proj_a",
+      "model.language_model.layers.25.linear_attn.in_proj_b",
+      "model.language_model.layers.25.linear_attn.in_proj_a",
+      "model.language_model.layers.26.linear_attn.in_proj_b",
+      "model.language_model.layers.26.linear_attn.in_proj_a",
+      "model.language_model.layers.28.linear_attn.in_proj_b",
+      "model.language_model.layers.28.linear_attn.in_proj_a",
+      "model.language_model.layers.29.linear_attn.in_proj_b",
+      "model.language_model.layers.29.linear_attn.in_proj_a",
+      "model.language_model.layers.30.linear_attn.in_proj_b",
+      "model.language_model.layers.30.linear_attn.in_proj_a",
+      "model.language_model.layers.32.linear_attn.in_proj_b",
+      "model.language_model.layers.32.linear_attn.in_proj_a",
+      "model.language_model.layers.33.linear_attn.in_proj_b",
+      "model.language_model.layers.33.linear_attn.in_proj_a",
+      "model.language_model.layers.34.linear_attn.in_proj_b",
+      "model.language_model.layers.34.linear_attn.in_proj_a",
+      "model.language_model.layers.36.linear_attn.in_proj_b",
+      "model.language_model.layers.36.linear_attn.in_proj_a",
+      "model.language_model.layers.37.linear_attn.in_proj_b",
+      "model.language_model.layers.37.linear_attn.in_proj_a",
+      "model.language_model.layers.38.linear_attn.in_proj_b",
+      "model.language_model.layers.38.linear_attn.in_proj_a",
+      "model.language_model.layers.40.linear_attn.in_proj_b",
+      "model.language_model.layers.40.linear_attn.in_proj_a",
+      "model.language_model.layers.41.linear_attn.in_proj_b",
+      "model.language_model.layers.41.linear_attn.in_proj_a",
+      "model.language_model.layers.42.linear_attn.in_proj_b",
+      "model.language_model.layers.42.linear_attn.in_proj_a",
+      "model.language_model.layers.44.linear_attn.in_proj_b",
+      "model.language_model.layers.44.linear_attn.in_proj_a",
+      "model.language_model.layers.45.linear_attn.in_proj_b",
+      "model.language_model.layers.45.linear_attn.in_proj_a",
+      "model.language_model.layers.46.linear_attn.in_proj_b",
+      "model.language_model.layers.46.linear_attn.in_proj_a",
+      "model.language_model.layers.48.linear_attn.in_proj_b",
+      "model.language_model.layers.48.linear_attn.in_proj_a",
+      "model.language_model.layers.49.linear_attn.in_proj_b",
+      "model.language_model.layers.49.linear_attn.in_proj_a",
+      "model.language_model.layers.50.linear_attn.in_proj_b",
+      "model.language_model.layers.50.linear_attn.in_proj_a",
+      "model.language_model.layers.52.linear_attn.in_proj_b",
+      "model.language_model.layers.52.linear_attn.in_proj_a",
+      "model.language_model.layers.53.linear_attn.in_proj_b",
+      "model.language_model.layers.53.linear_attn.in_proj_a",
+      "model.language_model.layers.54.linear_attn.in_proj_b",
+      "model.language_model.layers.54.linear_attn.in_proj_a",
+      "model.language_model.layers.56.linear_attn.in_proj_b",
+      "model.language_model.layers.56.linear_attn.in_proj_a",
+      "model.language_model.layers.57.linear_attn.in_proj_b",
+      "model.language_model.layers.57.linear_attn.in_proj_a",
+      "model.language_model.layers.58.linear_attn.in_proj_b",
+      "model.language_model.layers.58.linear_attn.in_proj_a",
+      "model.language_model.layers.60.linear_attn.in_proj_b",
+      "model.language_model.layers.60.linear_attn.in_proj_a",
+      "model.language_model.layers.61.linear_attn.in_proj_b",
+      "model.language_model.layers.61.linear_attn.in_proj_a",
+      "model.language_model.layers.62.linear_attn.in_proj_b",
+      "model.language_model.layers.62.linear_attn.in_proj_a",
+      "lm_head"
+    ],
+    "kv_cache_scheme": null,
+    "quant_method": "compressed-tensors",
+    "quantization_status": "compressed",
+    "sparsity_config": {},
+    "transform_config": {},
+    "version": "0.19.0"
+  },
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attn_output_gate": true,
+    "bos_token_id": 248044,
+    "dtype": "bfloat16",
+    "eos_token_id": 248044,
+    "full_attention_interval": 4,
+    "head_dim": 256,
+    "hidden_act": "silu",
+    "hidden_size": 5120,
+    "initializer_range": 0.02,
+    "intermediate_size": 17408,
+    "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_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_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": 48,
+    "linear_value_head_dim": 128,
+    "mamba_ssm_dtype": "float32",
+    "max_position_embeddings": 262144,
+    "model_type": "qwen3_5_text",
+    "mtp_num_hidden_layers": 0,
+    "mtp_use_dedicated_embeddings": false,
+    "num_attention_heads": 24,
+    "num_hidden_layers": 64,
+    "num_key_value_heads": 4,
+    "output_gate_type": "swish",
+    "pad_token_id": null,
+    "partial_rotary_factor": 0.25,
+    "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": false,
+    "use_cache": true,
+    "vocab_size": 248320
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "5.10.2",
+  "video_token_id": 248057,
+  "vision_config": {
+    "deepstack_visual_indexes": [],
+    "depth": 27,
+    "dtype": "bfloat16",
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 4304,
+    "model_type": "qwen3_5_vision",
+    "num_heads": 16,
+    "num_position_embeddings": 2304,
+    "out_hidden_size": 5120,
+    "patch_size": 16,
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  },
+  "vision_end_token_id": 248054,
+  "vision_start_token_id": 248053
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 248044,
+  "do_sample": true,
+  "eos_token_id": [
+    248046,
+    248044
+  ],
+  "pad_token_id": 248044,
+  "temperature": 1.0,
+  "top_k": 20,
+  "top_p": 0.95,
+  "transformers_version": "5.10.2"
+}

joint_head.safetensors

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

joint_head_config.json

@@ -0,0 +1,8 @@
+{
+  "hidden_size": 5120,
+  "width": 1024,
+  "routing_layers": 2,
+  "layers": 4,
+  "heads": 16,
+  "feedforward": 4096
+}

joint_schema_model.py

@@ -0,0 +1,576 @@
+"""Clef: a multimodal Qwen backbone with a joint schema head for typed decisions.
+
+A record provides a ``state`` (any JSON value), optional ``images`` and ``videos``,
+and ``questions``. Each question has a ``type`` (``noul``, ``choice``, or ``score``),
+``instructions``, and, for ``choice`` and ``score``, ``criteria`` describing the
+allowed options. The model returns one logit per allowed option for every question.
+``systemone`` answers a Jev/SystemOne ``/v1/systemone`` request body with the same
+response body.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
+from pathlib import Path
+from typing import Any
+
+import torch
+import torch.nn.functional as functional
+
+
+SYSTEM_PROMPT = (
+    "Read the complete state and schema. Decide every field jointly. Each answer "
+    "must be exactly one of that field's allowed options."
+)
+IMAGE_PLACEHOLDER = "<|vision_start|><|image_pad|><|vision_end|>"
+VIDEO_PLACEHOLDER = "<|vision_start|><|video_pad|><|vision_end|>"
+MEDIA_BATCH_KEYS = ("pixel_values", "image_grid_thw", "pixel_values_videos", "video_grid_thw")
+MEDIA_TOKEN_KEYS = ("mm_token_type_ids",)
+QUESTION_TYPES = {"noul": 0, "choice": 1, "score": 2}
+
+
+def render(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        separators=(",", ":"),
+        sort_keys=True,
+    )
+
+
+def question_options(question: dict[str, Any]) -> list[tuple[str, Any]]:
+    question_type = str(question["type"])
+    if question_type == "noul":
+        criteria = {
+            "true": "The proposition is true or the answer is yes.",
+            "false": "The proposition is false or the answer is no.",
+        }
+        criteria.update(question.get("criteria") or {})
+        return [(key, criteria[key]) for key in ("true", "false")]
+    if question_type == "choice":
+        return sorted((str(key), value) for key, value in question["criteria"].items())
+    return [(str(index), value) for index, value in enumerate(question["criteria"])]
+
+
+@dataclass(frozen=True)
+class EncodedQuestion:
+    question_id: str
+    question_type: int
+    question_span: tuple[int, int]
+    option_spans: tuple[tuple[int, int], ...]
+    option_ids: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class EncodedRecord:
+    input_ids: tuple[int, ...]
+    questions: tuple[EncodedQuestion, ...]
+    record_id: str
+    media: dict[str, Any] | None = dataclass_field(default=None, compare=False, repr=False)
+
+
+def _tokens(tokenizer: Any, text: str) -> list[int]:
+    return tokenizer(text, add_special_tokens=False).input_ids
+
+
+def _encode_media(processor: Any, record: dict[str, Any]) -> tuple[list[int], dict[str, Any] | None]:
+    images = list(record.get("images") or [])
+    videos = list(record.get("videos") or [])
+    if not images and not videos:
+        return [], None
+    if processor is None:
+        raise ValueError("records with images or videos require a processor")
+    text = IMAGE_PLACEHOLDER * len(images) + VIDEO_PLACEHOLDER * len(videos) + "\n"
+    encoded = processor(
+        text=[text],
+        images=images or None,
+        videos=videos or None,
+        return_tensors="pt",
+        **(record.get("media_kwargs") or {}),
+    )
+    media = {key: encoded[key] for key in MEDIA_BATCH_KEYS if key in encoded}
+    for key in MEDIA_TOKEN_KEYS:
+        if key in encoded:
+            media[key] = encoded[key][0].tolist()
+    return encoded["input_ids"][0].tolist(), media
+
+
+def encode_record(
+    tokenizer: Any,
+    record: dict[str, Any],
+    max_length: int = 16384,
+    max_state_tokens: int | None = None,
+    processor: Any | None = None,
+) -> EncodedRecord:
+    schema_ids = _tokens(tokenizer, "\n\nSCHEMA FIELDS:\n")
+    questions: list[EncodedQuestion] = []
+    for question_index, (question_id, question) in enumerate(record["questions"].items()):
+        schema_ids.extend(
+            _tokens(
+                tokenizer,
+                f"\nFIELD {question_index + 1}\nID: {question_id}\nTYPE: {question['type']}\nINSTRUCTION: ",
+            )
+        )
+        question_start = len(schema_ids)
+        instructions = question.get("instructions")
+        if instructions is None or instructions == "":
+            instructions = str(question_id)
+        schema_ids.extend(_tokens(tokenizer, render(instructions)))
+        question_end = len(schema_ids)
+        schema_ids.extend(_tokens(tokenizer, "\nALLOWED OPTIONS:\n"))
+
+        option_spans: list[tuple[int, int]] = []
+        option_ids: list[str] = []
+        for option_index, (option_id, description) in enumerate(question_options(question)):
+            schema_ids.extend(_tokens(tokenizer, f"OPTION {option_index + 1}: "))
+            option_start = len(schema_ids)
+            semantics = {"option_id": option_id}
+            if description is not None:
+                semantics["description"] = description
+            schema_ids.extend(_tokens(tokenizer, render(semantics)))
+            option_spans.append((option_start, len(schema_ids)))
+            option_ids.append(option_id)
+            schema_ids.extend(_tokens(tokenizer, "\n"))
+        schema_ids.extend(_tokens(tokenizer, "END FIELD\n"))
+        questions.append(
+            EncodedQuestion(
+                question_id=str(question_id),
+                question_type=QUESTION_TYPES[str(question["type"])],
+                question_span=(question_start, question_end),
+                option_spans=tuple(option_spans),
+                option_ids=tuple(option_ids),
+            )
+        )
+
+    prefix_ids = _tokens(
+        tokenizer,
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n<|im_start|>user\nSTATE:\n",
+    )
+    suffix_ids = _tokens(
+        tokenizer,
+        "\n<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\nJOINT SCHEMA DECISIONS:",
+    )
+    media_ids, media = _encode_media(processor, record)
+    if media is not None:
+        media["token_offset"] = len(prefix_ids)
+        prefix_ids = prefix_ids + media_ids
+    state_ids = _tokens(tokenizer, render(record["state"]))
+    if max_state_tokens is not None:
+        state_ids = state_ids[:max_state_tokens]
+    fixed_length = len(prefix_ids) + len(schema_ids) + len(suffix_ids)
+    if fixed_length > max_length:
+        raise ValueError(
+            f"schema requires {fixed_length} tokens before state; maximum is {max_length}"
+        )
+    state_ids = state_ids[: max_length - fixed_length]
+    schema_offset = len(prefix_ids) + len(state_ids)
+    shifted_questions = tuple(
+        EncodedQuestion(
+            question_id=question.question_id,
+            question_type=question.question_type,
+            question_span=(
+                question.question_span[0] + schema_offset,
+                question.question_span[1] + schema_offset,
+            ),
+            option_spans=tuple(
+                (start + schema_offset, end + schema_offset)
+                for start, end in question.option_spans
+            ),
+            option_ids=question.option_ids,
+        )
+        for question in questions
+    )
+    input_ids = tuple(prefix_ids + state_ids + schema_ids + suffix_ids)
+    if not input_ids or not shifted_questions:
+        raise ValueError("record produced no model input or questions")
+    return EncodedRecord(
+        input_ids=input_ids,
+        questions=shifted_questions,
+        record_id=str(record.get("id", "unknown")),
+        media=media,
+    )
+
+
+def collate_records(
+    records: list[EncodedRecord],
+    pad_token_id: int,
+    device: torch.device,
+) -> dict[str, Any]:
+    maximum_length = max(len(record.input_ids) for record in records)
+    input_ids = torch.full(
+        (len(records), maximum_length),
+        pad_token_id,
+        dtype=torch.long,
+        device=device,
+    )
+    attention_mask = torch.zeros(
+        (len(records), maximum_length),
+        dtype=torch.long,
+        device=device,
+    )
+    for index, record in enumerate(records):
+        length = len(record.input_ids)
+        input_ids[index, :length] = torch.tensor(record.input_ids, device=device)
+        attention_mask[index, :length] = 1
+    media: dict[str, torch.Tensor] = {}
+    for key in MEDIA_BATCH_KEYS:
+        values = [record.media[key] for record in records if record.media and key in record.media]
+        if values:
+            media[key] = torch.cat(values, dim=0).to(device)
+    for key in MEDIA_TOKEN_KEYS:
+        if any(record.media and key in record.media for record in records):
+            token_values = torch.zeros((len(records), maximum_length), dtype=torch.long, device=device)
+            for index, record in enumerate(records):
+                if record.media and key in record.media:
+                    offset = record.media["token_offset"]
+                    values = torch.tensor(record.media[key], dtype=torch.long, device=device)
+                    token_values[index, offset : offset + len(values)] = values
+            media[key] = token_values
+    return {
+        "input_ids": input_ids,
+        "attention_mask": attention_mask,
+        "records": records,
+        "media": media,
+    }
+
+
+class EvidenceRoutingLayer(torch.nn.Module):
+    def __init__(
+        self,
+        width: int,
+        heads: int,
+        feedforward: int,
+        dropout: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.query_norm = torch.nn.LayerNorm(width)
+        self.memory_norm = torch.nn.LayerNorm(width)
+        self.attention = torch.nn.MultiheadAttention(
+            width,
+            heads,
+            dropout=dropout,
+            batch_first=True,
+        )
+        self.attention_dropout = torch.nn.Dropout(dropout)
+        self.feedforward_norm = torch.nn.LayerNorm(width)
+        self.feedforward = torch.nn.Sequential(
+            torch.nn.Linear(width, feedforward),
+            torch.nn.GELU(),
+            torch.nn.Dropout(dropout),
+            torch.nn.Linear(feedforward, width),
+            torch.nn.Dropout(dropout),
+        )
+
+    def forward(self, queries: torch.Tensor, memory: torch.Tensor) -> torch.Tensor:
+        normalized_queries = self.query_norm(queries)
+        routed, _ = self.attention(
+            normalized_queries,
+            self.memory_norm(memory),
+            self.memory_norm(memory),
+            need_weights=False,
+        )
+        queries = queries + self.attention_dropout(routed)
+        return queries + self.feedforward(self.feedforward_norm(queries))
+
+
+class JointSchemaHead(torch.nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        width: int,
+        routing_layers: int,
+        layers: int,
+        heads: int,
+        feedforward: int,
+        dropout: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.hidden_norm = torch.nn.LayerNorm(hidden_size)
+        self.memory_projection = torch.nn.Linear(hidden_size, width, bias=False)
+        self.question_projection = torch.nn.Linear(hidden_size, width, bias=False)
+        self.option_question_projection = torch.nn.Linear(hidden_size, width, bias=False)
+        self.global_projection = torch.nn.Linear(hidden_size, width, bias=False)
+        self.option_context_projection = torch.nn.Linear(hidden_size, width, bias=False)
+        self.option_lexical_projection = torch.nn.Linear(hidden_size, width, bias=False)
+        self.type_embedding = torch.nn.Embedding(3, width)
+        self.evidence_layers = torch.nn.ModuleList(
+            [
+                EvidenceRoutingLayer(
+                    width=width,
+                    heads=heads,
+                    feedforward=feedforward,
+                    dropout=dropout,
+                )
+                for _ in range(routing_layers)
+            ]
+        )
+        self.option_summary_norm = torch.nn.LayerNorm(width)
+        self.layers = torch.nn.ModuleList(
+            [
+                torch.nn.TransformerDecoderLayer(
+                    d_model=width,
+                    nhead=heads,
+                    dim_feedforward=feedforward,
+                    dropout=dropout,
+                    activation="gelu",
+                    batch_first=True,
+                    norm_first=True,
+                )
+                for _ in range(layers)
+            ]
+        )
+        self.field_norm = torch.nn.LayerNorm(width)
+        self.option_norm = torch.nn.LayerNorm(width)
+        self.residual_scorer = torch.nn.Sequential(
+            torch.nn.Linear(width * 4, width),
+            torch.nn.GELU(),
+            torch.nn.Dropout(dropout),
+            torch.nn.Linear(width, 1),
+        )
+        self.prior_logit_scale = torch.nn.Parameter(torch.zeros(()))
+        self.joint_logit_scale = torch.nn.Parameter(torch.zeros(()))
+        self.residual_gate = torch.nn.Parameter(torch.zeros(()))
+
+    @staticmethod
+    def _mean_span(values: torch.Tensor, span: tuple[int, int]) -> torch.Tensor:
+        start, end = span
+        return values[start:end].mean(dim=0)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        records: list[EncodedRecord],
+        output_embedding_weight: torch.Tensor,
+    ) -> list[list[torch.Tensor]]:
+        results: list[list[torch.Tensor]] = []
+        normalized_hidden = self.hidden_norm(hidden_states)
+        for batch_index, record in enumerate(records):
+            sequence_length = int(attention_mask[batch_index].sum().item())
+            sequence_hidden = normalized_hidden[batch_index, :sequence_length]
+            memory = self.memory_projection(sequence_hidden).unsqueeze(0)
+            global_vector = sequence_hidden[-1]
+            question_vectors = torch.stack(
+                [
+                    self._mean_span(sequence_hidden, question.question_span)
+                    for question in record.questions
+                ]
+            )
+            type_ids = torch.tensor(
+                [question.question_type for question in record.questions],
+                device=hidden_states.device,
+            )
+            option_contexts: list[torch.Tensor] = []
+            lexical_options: list[torch.Tensor] = []
+            option_counts = []
+            for question in record.questions:
+                context_vectors = torch.stack(
+                    [
+                        self._mean_span(sequence_hidden, span)
+                        for span in question.option_spans
+                    ]
+                )
+                lexical_vectors = []
+                for start, end in question.option_spans:
+                    token_ids = input_ids[batch_index, start:end]
+                    lexical_vectors.append(output_embedding_weight[token_ids].mean(dim=0))
+                lexical = torch.stack(lexical_vectors)
+                option_contexts.append(context_vectors)
+                lexical_options.append(lexical)
+                option_counts.append(len(question.option_spans))
+
+            option_queries = []
+            for question_index, (context_vectors, lexical) in enumerate(
+                zip(option_contexts, lexical_options)
+            ):
+                option_queries.append(
+                    self.option_context_projection(context_vectors)
+                    + self.option_lexical_projection(lexical)
+                    + self.option_question_projection(
+                        question_vectors[question_index]
+                    ).unsqueeze(0)
+                )
+            routed_options = torch.cat(option_queries, dim=0).unsqueeze(0)
+            for layer in self.evidence_layers:
+                routed_options = layer(routed_options, memory)
+            routed_options = routed_options[0]
+            split_options = list(torch.split(routed_options, option_counts, dim=0))
+
+            base_fields = self.question_projection(question_vectors)
+            option_summaries = []
+            for field, options in zip(base_fields, split_options):
+                routing_weights = torch.softmax(
+                    torch.matmul(options, field) / math.sqrt(options.shape[-1]),
+                    dim=0,
+                )
+                option_summaries.append(
+                    torch.sum(routing_weights.unsqueeze(-1) * options, dim=0)
+                )
+            fields = (
+                base_fields
+                + self.option_summary_norm(torch.stack(option_summaries))
+                + self.global_projection(global_vector).unsqueeze(0)
+                + self.type_embedding(type_ids)
+            )
+            fields = fields.unsqueeze(0)
+            for layer in self.layers:
+                fields = layer(fields, memory)
+            fields = self.field_norm(fields[0])
+
+            record_logits: list[torch.Tensor] = []
+            for field, question, lexical, routed in zip(
+                fields,
+                record.questions,
+                lexical_options,
+                split_options,
+            ):
+                anchor = functional.normalize(
+                    question_vectors[len(record_logits)] + global_vector,
+                    dim=-1,
+                )
+                lexical_anchor = functional.normalize(lexical, dim=-1)
+                prior_scale = self.prior_logit_scale.clamp(max=math.log(100.0)).exp()
+                prior = prior_scale * torch.matmul(lexical_anchor, anchor)
+                options = self.option_norm(routed)
+                repeated_field = field.unsqueeze(0).expand_as(options)
+                cosine = functional.cosine_similarity(repeated_field, options, dim=-1)
+                features = torch.cat(
+                    [
+                        repeated_field,
+                        options,
+                        repeated_field * options,
+                        torch.abs(repeated_field - options),
+                    ],
+                    dim=-1,
+                )
+                residual = self.residual_scorer(features).squeeze(-1)
+                joint_scale = self.joint_logit_scale.clamp(max=math.log(100.0)).exp()
+                joint = joint_scale * cosine + residual
+                record_logits.append(
+                    prior + torch.sigmoid(self.residual_gate) * joint
+                )
+            results.append(record_logits)
+        return results
+
+
+class ClefModel(torch.nn.Module):
+    def __init__(self, language_model: Any, head: JointSchemaHead) -> None:
+        super().__init__()
+        self.language_model = language_model
+        self.head = head
+
+    def forward(self, batch: dict[str, Any]) -> list[list[torch.Tensor]]:
+        base_model = (
+            self.language_model.get_base_model()
+            if hasattr(self.language_model, "get_base_model")
+            else self.language_model
+        )
+        media = batch.get("media") or {}
+        text_model = base_model.model
+        if not media and hasattr(text_model, "language_model"):
+            text_model = text_model.language_model
+        outputs = text_model(
+            input_ids=batch["input_ids"],
+            attention_mask=batch["attention_mask"],
+            use_cache=False,
+            return_dict=True,
+            **media,
+        )
+        return self.head(
+            outputs.last_hidden_state,
+            batch["input_ids"],
+            batch["attention_mask"],
+            batch["records"],
+            base_model.get_output_embeddings().weight,
+        )
+
+
+def load_release_model(
+    model_path: str | Path,
+    device: str | torch.device = "cuda",
+    dtype: torch.dtype = torch.bfloat16,
+    **from_pretrained_kwargs: Any,
+) -> tuple[ClefModel, Any]:
+    """Load a Clef release (merged backbone, joint schema head, and processor)."""
+    from huggingface_hub import snapshot_download
+    from safetensors.torch import load_file
+    from transformers import AutoProcessor, Qwen3_5ForConditionalGeneration
+
+    path = Path(model_path)
+    if not path.is_dir():
+        path = Path(snapshot_download(str(model_path)))
+    backbone = Qwen3_5ForConditionalGeneration.from_pretrained(
+        path,
+        dtype=dtype,
+        device_map={"": str(device)},
+        **from_pretrained_kwargs,
+    )
+    backbone.config.use_cache = False
+    head_config = json.loads((path / "joint_head_config.json").read_text())
+    head = JointSchemaHead(**head_config)
+    head.load_state_dict(load_file(path / "joint_head.safetensors"), strict=True)
+    head = head.to(device=device, dtype=dtype)
+    processor = AutoProcessor.from_pretrained(path)
+    return ClefModel(backbone, head).eval(), processor
+
+
+def systemone_answer(question: dict[str, Any], probabilities: dict[str, float]) -> dict[str, Any]:
+    """Convert per-option probabilities for one question into a SystemOne answer."""
+    if question["type"] == "noul":
+        return {"type": "noul", "noul": round(probabilities["true"], 4)}
+    if question["type"] == "choice":
+        options = [str(option) for option in question["criteria"]]
+        choice = max(options, key=probabilities.__getitem__)
+        return {
+            "type": "choice",
+            "choice": choice,
+            "confidence": round(probabilities[choice], 4),
+            "probabilities": {option: round(probabilities[option], 4) for option in options},
+        }
+    levels = [str(index) for index in range(len(question["criteria"]))]
+    return {
+        "type": "score",
+        "score": round(sum(index * probabilities[level] for index, level in enumerate(levels)), 4),
+        "confidence": round(max(probabilities[level] for level in levels), 4),
+        "legend": dict(zip(levels, question["criteria"])),
+        "probabilities": {level: round(probabilities[level], 4) for level in levels},
+    }
+
+
+@torch.inference_mode()
+def systemone(model: ClefModel, processor: Any, request: dict[str, Any], max_length: int = 16384) -> dict[str, Any]:
+    """Answer a Jev/SystemOne ``/v1/systemone`` request body with a SystemOne response body.
+
+    The request has ``model``, ``state``, and ``questions``, plus optional ``images`` and ``videos``.
+    """
+    questions = request.get("questions")
+    if not isinstance(request.get("model"), str) or "state" not in request:
+        raise ValueError("model and state are required")
+    if not isinstance(questions, dict) or not questions:
+        raise ValueError("at least one question is required")
+    for question_id, question in questions.items():
+        if question.get("type") not in QUESTION_TYPES:
+            raise ValueError(f"{question_id}: type must be noul, choice, or score")
+        if question["type"] != "noul" and not question.get("criteria"):
+            raise ValueError(f"{question_id}: criteria must not be empty")
+    encoded = encode_record(processor.tokenizer, request, max_length=max_length, processor=processor)
+    device = next(model.parameters()).device
+    logits = model(collate_records([encoded], processor.tokenizer.pad_token_id, device))[0]
+    answers = {
+        question.question_id: systemone_answer(
+            questions[question.question_id],
+            dict(zip(question.option_ids, question_logits.float().softmax(-1).tolist())),
+        )
+        for question, question_logits in zip(encoded.questions, logits)
+    }
+    return {
+        "model": request["model"],
+        "answers": answers,
+        "usage": {"input_tokens": len(encoded.input_ids), "output_tokens": 0},
+    }

model-00001-of-00002.safetensors

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

model-00002-of-00002.safetensors

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

processor_config.json

@@ -0,0 +1,60 @@
+{
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_processor_type": "Qwen2VLImageProcessor",
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "merge_size": 2,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 16777216,
+      "shortest_edge": 65536
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Qwen3VLProcessor",
+  "video_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "fps": 2,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "max_frames": 768,
+    "merge_size": 2,
+    "min_frames": 4,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 25165824,
+      "shortest_edge": 4096
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Qwen3VLVideoProcessor"
+  }
+}

recipe.yaml

@@ -0,0 +1,69 @@
+default_stage:
+  default_modifiers:
+    QuantizationModifier:
+      config_groups:
+        group_0:
+          targets: ['re:.*self_attn\.(q|k|v|o)_proj$', 're:.*linear_attn\.(in_proj_qkv|in_proj_z|out_proj)$',
+            're:.*layers\.(56|57|58|59|60|61|62|63)\.mlp\.(gate|up|down)_proj$']
+          weights:
+            num_bits: 8
+            type: float
+            symmetric: true
+            group_size: null
+            strategy: channel
+            block_structure: null
+            dynamic: false
+            actorder: null
+            scale_dtype: null
+            zp_dtype: null
+            observer: memoryless_minmax
+            observer_kwargs: {}
+          input_activations:
+            num_bits: 8
+            type: float
+            symmetric: true
+            group_size: null
+            strategy: token
+            block_structure: null
+            dynamic: true
+            actorder: null
+            scale_dtype: null
+            zp_dtype: null
+            observer: null
+            observer_kwargs: {}
+          output_activations: null
+          format: null
+        group_1:
+          targets: ['re:.*layers\.([0-9]|[1-4][0-9]|5[0-5])\.mlp\.(gate|up|down)_proj$']
+          weights:
+            num_bits: 4
+            type: float
+            symmetric: true
+            group_size: 16
+            strategy: tensor_group
+            block_structure: null
+            dynamic: false
+            actorder: null
+            scale_dtype: torch.float8_e4m3fn
+            zp_dtype: null
+            observer: memoryless_minmax
+            observer_kwargs: {}
+          input_activations:
+            num_bits: 4
+            type: float
+            symmetric: true
+            group_size: 16
+            strategy: tensor_group
+            block_structure: null
+            dynamic: local
+            actorder: null
+            scale_dtype: torch.float8_e4m3fn
+            zp_dtype: null
+            observer: static_minmax
+            observer_kwargs: {}
+          output_activations: null
+          format: null
+      targets: [Linear]
+      ignore: [lm_head, 're:.*visual.*']
+      bypass_divisibility_checks: false
+      requires_calibration_data: true

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,30 @@
+{
+  "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|>",
+  "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|>"
+}