Publish task-agnostic 4L base, separate SemEval model, and 24L-to-4L distillation platform

.gitattributes

@@ -1,35 +1,2 @@
-*.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

LICENSE

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

README.md

@@ -0,0 +1,140 @@
+---
+license: apache-2.0
+base_model: Qwen/Qwen3.5-0.8B
+pipeline_tag: feature-extraction
+library_name: transformers
+language:
+  - en
+tags:
+  - qwen3.5
+  - classification-backbone
+  - knowledge-distillation
+  - model-compression
+  - edge-ai
+---
+
+# Qwen3.5 Standalone 4L Classification Base
+
+This repository publishes a **headless, classification-ready four-layer
+Qwen3.5 text backbone**. The root model has no task labels and no classification
+head. It is intended as a compact starting point for single-label or multilabel
+classifiers, not as a chat model or a ready-made universal classifier.
+
+The repository follows one integrated 1-1-1 layout:
+
+- **Root model:** task-agnostic four-layer base trained on unlabeled general
+  text.
+- **`models/semeval-propaganda/`:** the existing SemEval-derived propaganda
+  classifier as a separate task-specific lineage.
+- **`distillation/`:** a reusable 24L→8L→6L→4L platform for your own data.
+
+## Load the headless base
+
+```python
+from transformers import AutoModel, AutoTokenizer
+
+model_id = "mp-juuuns/qwen35-standalone4l-classification-base"
+tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=False)
+backbone = AutoModel.from_pretrained(model_id, trust_remote_code=False)
+```
+
+The root uses `Qwen3_5TextModel` in Transformers 5.13.0. It has four text
+layers in the sequence `linear → full → linear → full`, hidden size 1,024, and
+the full upstream Qwen3.5 tokenizer. The published weight file contains no
+`score.weight`.
+
+## Make your own classifier
+
+```bash
+git clone https://huggingface.co/mp-juuuns/qwen35-standalone4l-classification-base
+cd qwen35-standalone4l-classification-base/distillation
+python -m pip install -e .
+
+qwen35-distill finetune \
+  --checkpoint .. \
+  --train examples/multilabel_train.jsonl \
+  --labels examples/labels.json \
+  --mode multilabel \
+  --output my-classifier-4l
+```
+
+For a full task-specific compression run, first fine-tune a 24-layer teacher,
+then repeat `materialize-classifier` and `distill-classifier` for `24to8`,
+`8to6`, and `6to4`. Exact JSONL formats and commands are in
+[`distillation/README.md`](distillation/README.md).
+
+## How the root weights were made
+
+The text backbone and full tokenizer were extracted from
+[`Qwen/Qwen3.5-0.8B`](https://huggingface.co/Qwen/Qwen3.5-0.8B). Students were
+trained sequentially through 24→8→6→4 using hidden-boundary and final
+representation matching on unlabeled text.
+
+The task-free training set was exactly 4,096 deterministically shuffled,
+non-empty rows from the first locally cached WikiText-103 raw training shard.
+No SemEval examples, labels, logits, thresholds, or evidence/span objectives
+were read while training these root weights.
+
+WikiText is not redistributed here. Its current Hugging Face page has a license
+wording discrepancy: metadata lists CC BY-SA 3.0 and GFDL, while the prose says
+CC BY-SA 4.0. Users should review the
+[`Salesforce/wikitext`](https://huggingface.co/datasets/Salesforce/wikitext)
+terms directly.
+
+## One-task transfer check
+
+We attached a fresh 14-label head and used the frozen SemEval-derived
+article-level protocol only as a transfer probe.
+
+| Initialization | Opened-test Macro-F1, mean ± sample SD |
+|---|---:|
+| Task-agnostic 4L base | **0.58748 ± 0.01579** |
+| Same 4L structural copy without task-free KD | 0.51809 ± 0.01631 |
+| Existing separate specialized 4L lineage | 0.58757 ± 0.00717 |
+
+Results use seeds 41/42/43 and a previously opened 55-article public test split.
+They are exploratory, not untouched confirmatory evidence. The derived task
+measures article-level presence of 14 techniques and is not identical to the
+official SemEval span- or fragment-level task. Three seed values are not a
+confidence interval.
+
+This check supports transfer on one English classification task only. It does
+not establish universal classification quality, multilingual generalization,
+calibration, safety, or production suitability.
+
+## Separate SemEval model
+
+The ready-to-use propaganda model is under
+[`models/semeval-propaganda/`](models/semeval-propaganda/). It preserves the
+currently published seed-41/42/43 checkpoints and links to the original
+repository at immutable revision
+[`e7e0ff1`](https://huggingface.co/mp-juuuns/qwen35-standalone4l-propaganda-classifier/tree/e7e0ff16828052687d2e8dd7849e7a521629cf38).
+
+That specialized model is **not** claimed to descend from this new task-free
+base. It has its own SemEval task-specific shrink/distillation and fine-tuning
+history and a reduced 128k vocabulary, while the root base retains the full
+upstream tokenizer.
+
+## Limitations
+
+- A classification head and labeled training are required before root-model
+  predictions have task meaning.
+- The task-free corpus is small: 4,096 rows from one WikiText shard.
+- Only one downstream transfer task was measured.
+- Default layer maps are documented structural choices, not universal optima.
+- Long-context, multilingual, calibration, robustness, fairness, and device
+  performance of the new root base have not been established.
+- Do not use either model as a fact checker, safety oracle, or autonomous
+  decision maker.
+
+## License and attribution
+
+The released code and model artifacts use Apache-2.0, subject to upstream model
+and data terms. Qwen3.5 is attributed to Qwen. Transformers, PyTorch,
+Hugging Face Hub, WikiText, and SemEval remain the work of their respective
+authors. No WikiText or SemEval source records are redistributed.
+
+Machine-readable training manifests, transfer summaries, hashes, and the
+release inventory are included under `provenance/`, `benchmark/`, and
+`release_manifest.json`.
+

SHA256SUMS

@@ -0,0 +1,66 @@
+ee05350c7fda0af4da116020dd7b976d731de3beed4f5e717d5bcc95ead24550  .gitattributes
+77fd4710def9ec3c0f6225800e0235f15a425abd4a8b03559127fcd782612049  LICENSE
+4f5af67b76f19fca88e242298fa501aa6aa811b4f1f51b481d17abb46e0d39cf  README.md
+816c3249d3ec281ef73d34dc3ab7576a48415d250c32977eb94ca37f73b0b810  benchmark/reports/structural_control-seed41.json
+0b19eabe1e31d0012c754db3b31173f8a6fcdee30973f1a1bebd3a370d11064c  benchmark/reports/structural_control-seed42.json
+6dde34173462eac50141ff082c18194f3233f8c06853532d9b12756562e69e2e  benchmark/reports/structural_control-seed43.json
+6b3a2e0372a83e1e71c2eca9596efc8cd1a3e39c28e25e3373f195431b5858a4  benchmark/reports/task_agnostic-seed41.json
+42dc788983716be0e9847aad87ff79c7e7297884f2635a8d098639be77326639  benchmark/reports/task_agnostic-seed42.json
+7ee52dc94a152a2f767dcff171f3c9cc1072fabd3ebc7b14db53617b7b1d33d5  benchmark/reports/task_agnostic-seed43.json
+18c8d840dd2290ca25c517d52cbcf1ad6c6ae8d9c32c545236e96bd5ada7dab2  benchmark/semeval-transfer-summary.json
+04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978  chat_template.jinja
+bb33f3a52d787e15db7d516c6de36a7ddd2c675e7964d5b9309131c4e5d365f0  config.json
+f5b7248f7781412e8b5d8f2fb3b0c309568e4e75baf55029b26a6fa985d9d608  distillation/README.md
+adf8b6e3f0f5a5dfe042dcc09a7a8e7ef8cd1146462b089c5f6c9393e9a3131f  distillation/configs/task_agnostic_base.yaml
+8b528ab38eb2e9f53f9ec2c50d4a0c860d87594067dc9b064b4bb47ef51f8f50  distillation/examples/labels.json
+daf5859bb93c474d766ecb0681a2585a6a8ed3cb5efcdd476c845727a0c3583c  distillation/examples/multilabel_train.jsonl
+918490e8db364c6e601cfdcb09e28c272eafc8359ffe190645a4cbecdf06aed3  distillation/examples/single_label_train.jsonl
+7a1db673674a003ef749b1fa90a99eff6db70c3189411b9cee574cc23d084860  distillation/examples/unlabeled.jsonl
+3c5a0f9b48849381307a6b3c258729d4079bf5d42bb6ab5d28edbdda4a1a3592  distillation/pyproject.toml
+2965e662310bf4197d1cbd4f9b3fcf3f383950dbfc4f033729a286d026709f3a  distillation/qwen35_distill/__init__.py
+d67bf7ed3bfb6cb622d6d35a99a4292f1191395270264e81a7d19283d206e5dc  distillation/qwen35_distill/checkpoint.py
+ea06bec682622addc426def4f7e315b3d12f7f595af44f714cc811588cf64782  distillation/qwen35_distill/classification.py
+d8fb1584484596f9c35db9c2c296dab08b2dd9bb1b7910a115710feee7562771  distillation/qwen35_distill/cli.py
+a9c49af0ee14b307a08c096bcd1ae55fa9bc67bdb807fa9383fc313246e7edd7  distillation/qwen35_distill/layer_maps.py
+d9b135cf5b0adf4bbfc321200395fbd6112e49fd1a027b30262bcff1c4c0b654  distillation/qwen35_distill/losses.py
+00731ae7838317105f9fff960e3da210b2a55954feb37b3ac793bcfc81fdab2d  distillation/qwen35_distill/schema.py
+4dc432acb70e03848d2e5964e8550065490fda3857aac32fe3b79895ef72026f  distillation/qwen35_distill/training.py
+5a1d9e939cd0f350770bcc2a116bc427bb9971bc4fbbbda17ce568e9127185ef  docs/RELEASE_CONTRACT.md
+a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d  merges.txt
+2732c616772fe320cdea228ab4554981418b1b2bf615c4183fb1ac8e6e2168d3  model.safetensors
+77fd4710def9ec3c0f6225800e0235f15a425abd4a8b03559127fcd782612049  models/semeval-propaganda/LICENSE
+8dbc2e641280c471b78064808ced7fffcb81c639784a5936b57175975a718f6f  models/semeval-propaganda/README.md
+0bae347bb54f8089a5fa5450f8366b5c56eb3e598beaf9a87f4385363a402bcb  models/semeval-propaganda/benchmark/final4l_aggregate.json
+c1bd379680abcf50b47b7d23e4aafbc8b5e7f40a0b0e9700bde21a8ce49af803  models/semeval-propaganda/benchmark/seed41.json
+a30e38433d008db4aa7e5fbfd477ab80a0daf50e970f8e7b04397efc1a47843a  models/semeval-propaganda/benchmark/seed42.json
+96466290d09d27b8bc044a9f9a95765ce12b4d7b02dfb0123e436e7535623353  models/semeval-propaganda/benchmark/seed43.json
+04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978  models/semeval-propaganda/chat_template.jinja
+1c09956cc5d3553eed0b5f64c20c81064df4373ccfaf4fec26929b8f4819773a  models/semeval-propaganda/classify.py
+9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0  models/semeval-propaganda/config.json
+946fed4fe4c3d320fd113ec8e5776b10f2707b936f857341bb5443d7a9038248  models/semeval-propaganda/labels.json
+0352da6e4717a2e6f3a9d643d034be2cb1c39632d1bce0ced339ddb62acedb37  models/semeval-propaganda/model.safetensors
+ef64dc628fe9bb4efd2a0b6a739f0c842c6fd4586b1803707e7a071e439cdf69  models/semeval-propaganda/release_manifest.json
+2994886af208a0120c051745f9c14036e6f2caae8c4af863e5965d5a5bd68fdf  models/semeval-propaganda/requirements.txt
+04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978  models/semeval-propaganda/seeds/seed42/chat_template.jinja
+9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0  models/semeval-propaganda/seeds/seed42/config.json
+2db5f4be391d9dee64458cb5865530f39747019e7a219443b5f7850befbce697  models/semeval-propaganda/seeds/seed42/model.safetensors
+dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8  models/semeval-propaganda/seeds/seed42/tokenizer.json
+2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35  models/semeval-propaganda/seeds/seed42/tokenizer_config.json
+04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978  models/semeval-propaganda/seeds/seed43/chat_template.jinja
+9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0  models/semeval-propaganda/seeds/seed43/config.json
+81a56d497df758e8a292eea528438cfc4d5a847cd37d3a7e1107fefa7c500640  models/semeval-propaganda/seeds/seed43/model.safetensors
+dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8  models/semeval-propaganda/seeds/seed43/tokenizer.json
+2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35  models/semeval-propaganda/seeds/seed43/tokenizer_config.json
+737c4e145a5b51660c4c45a8acea4c32219cbbbc0706abe235e36b2ad430f17d  models/semeval-propaganda/thresholds.json
+dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8  models/semeval-propaganda/tokenizer.json
+2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35  models/semeval-propaganda/tokenizer_config.json
+e831b8a121fe896bb9f033287a5b82a0bffad1037a45bbb1ec913fed261add92  provenance/base/finalization_manifest.json
+ec734855870758cbfef99031dac2ded85b54c496532e5c514a9a4f63287c3493  provenance/base/training_manifest.json
+b9ce99b993c4f4563bc2521fc731bfd82f5e8149c141133599fbd8f982ba43d9  provenance/task_agnostic_stages/24to8.json
+ec734855870758cbfef99031dac2ded85b54c496532e5c514a9a4f63287c3493  provenance/task_agnostic_stages/6to4.json
+65e5383afbbcfe0b7dd78a5411c319ed6bf2586659fb1892aca9ecbd5dfd4993  provenance/task_agnostic_stages/8to6.json
+143945a19235351e00048a99c74799e362eefec3b5e3f3a2ad4c8b64611034a4  release_manifest.json
+7b48e7811e56e552fc4aef44189e1d7c9b1352c85d2b3f10ff0bdd1ea5cdd824  requirements.txt
+06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523  tokenizer.json
+5ab9bed0a4d27949672f65ba1141d6dd5b0514fb9091d3426506ecebb5d5e294  tokenizer_config.json
+ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003  vocab.json

benchmark/semeval-transfer-summary.json

@@ -0,0 +1,47 @@
+{
+  "schema": "standalone4l-transfer-summary-v1",
+  "claim_scope": "Exploratory one-task transfer evidence on a previously opened 55-article SemEval-derived test split; not confirmatory.",
+  "metric": "article-level multilabel Macro-F1",
+  "seeds": [
+    41,
+    42,
+    43
+  ],
+  "task_agnostic_base": {
+    "values": [
+      0.5883093293517536,
+      0.6028379036218096,
+      0.5712816197954101
+    ],
+    "mean": 0.5874762842563245,
+    "sample_sd": 0.01579462678670608
+  },
+  "structural_copy_control": {
+    "values": [
+      0.5169424579262757,
+      0.5349405779540175,
+      0.5023778364496152
+    ],
+    "mean": 0.5180869574433028,
+    "sample_sd": 0.016311512588628545
+  },
+  "same_seed_deltas": [
+    0.07136687142547793,
+    0.06789732566779205,
+    0.06890378334579494
+  ],
+  "mean_delta": 0.06938932681302164,
+  "publication_gate_passed": true,
+  "existing_specialized_separate_lineage": {
+    "values": [
+      0.5832848452288824,
+      0.5958405181160762,
+      0.5835785045218137
+    ],
+    "mean": 0.5875679559555907,
+    "sample_sd": 0.007165593191426643
+  },
+  "test_articles": 55,
+  "test_previously_opened": true,
+  "three_seed_sd_is_not_confidence_interval": true
+}

chat_template.jinja

@@ -0,0 +1,120 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- else %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- 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 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 }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+{%- endmacro %}
+{%- if tools is defined and tools is iterable and tools | length > 0 %}
+    {{- '<|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' and messages[0].content | trim %}
+        {%- set content = render_content(messages[0].content, false) %}
+        {{- '\n\n' + content.lstrip('\n') }}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + render_content(messages[0].content, false) + '<|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) %}
+        {%- 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 %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true) %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
+            {%- 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 %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- set content = content.rstrip('\n') %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- 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 %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n<think>\n' }}
+{%- endif %}

config.json

@@ -0,0 +1,80 @@
+{
+  "architectures": [
+    "Qwen3_5TextModel"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_output_gate": true,
+  "bos_token_id": null,
+  "dtype": "bfloat16",
+  "eos_token_id": 248046,
+  "full_attention_interval": 4,
+  "head_dim": 256,
+  "hidden_act": "silu",
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 3584,
+  "layer_types": [
+    "linear_attention",
+    "full_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": 4,
+  "num_key_value_heads": 2,
+  "pad_token_id": 248044,
+  "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"
+  },
+  "standalone4l_distillation": {
+    "schema_version": "qwen35-stage-map-v1",
+    "selected_layers": [
+      0,
+      2,
+      3,
+      5
+    ],
+    "selection_basis": "predeclared_architecture_only_default",
+    "source_depth": 6,
+    "stage": "6to4",
+    "target_depth": 4,
+    "task_labels_used_for_weight_materialization": false
+  },
+  "standalone4l_role": "task_agnostic_classification_base_4l",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.13.0",
+  "use_cache": false,
+  "vocab_size": 248320,
+  "standalone4l_base": {
+    "schema_version": "standalone4l-task-agnostic-base-v1",
+    "role": "classification_ready_headless_text_backbone",
+    "task_labels_used_in_base_training": false,
+    "semeval_used_in_base_training": false,
+    "tokenizer": "upstream_full_qwen35",
+    "training_corpus_rows": 4096,
+    "training_objective": "hidden_and_interface_representation_distillation",
+    "published_classification_head": false
+  }
+}

distillation/README.md

@@ -0,0 +1,108 @@
+# Qwen3.5 Classification Distillation
+
+This package turns the text backbone of `Qwen/Qwen3.5-0.8B` into smaller
+classification-ready backbones and task-specific classifiers.
+
+Two workflows are intentionally separate:
+
+1. **Task-agnostic base:** hidden/interface distillation on unlabeled text.
+   It produces a headless text backbone and never reads task labels.
+2. **Task-specific classifier:** attach a single-label or multilabel head,
+   train a 24-layer teacher on a user dataset, then transfer hard labels,
+   teacher logits, and hidden/interface representations through
+   `24L → 8L → 6L → 4L`.
+
+The published default maps are structural defaults, not a claim that they are
+universally optimal:
+
+| Stage | Source layers retained | Target layer types |
+|---|---|---|
+| 24L → 8L | `0,4,6,11,13,16,20,23` | `L,L,L,F,L,L,L,F` |
+| 8L → 6L | `0,1,3,4,6,7` | `L,L,F,L,L,F` |
+| 6L → 4L | `0,2,3,5` | `L,F,L,F` |
+
+The final 6L→4L numeric map overlaps the earlier SemEval experiment, but the
+task-agnostic base uses the fixed structural contract above and no SemEval
+labels, examples, logits, thresholds, or span objectives. Architecture choice
+and task-free weight training are reported as separate provenance claims.
+
+## Dataset formats
+
+Unlabeled:
+
+```json
+{"id":"u-1","text":"Unlabeled text used only for representation distillation."}
+```
+
+Single-label:
+
+```json
+{"id":"s-1","text":"Example text.","label":"class_a"}
+```
+
+Multilabel:
+
+```json
+{"id":"m-1","text":"Example text.","labels":["class_a","class_c"]}
+```
+
+Each split is a separate JSONL file. `id` must be unique across all splits.
+An optional `group_id` is checked for cross-split leakage.
+
+## Initial commands
+
+```bash
+python -m qwen35_distill.cli validate-dataset \
+  --mode unlabeled --train examples/unlabeled.jsonl
+
+python -m qwen35_distill.cli extract-text \
+  --source /path/to/Qwen3.5-0.8B \
+  --output /path/to/text-24l
+
+python -m qwen35_distill.cli materialize \
+  --source /path/to/text-24l \
+  --output /path/to/text-8l \
+  --stage 24to8
+
+python -m qwen35_distill.cli distill \
+  --teacher /path/to/text-24l \
+  --student /path/to/text-8l \
+  --data /path/to/unlabeled.parquet \
+  --output /path/to/text-8l-kd \
+  --stage 24to8 --device cuda --dtype bfloat16
+```
+
+Every output is exclusive: existing directories are never overwritten.
+
+## Build a classifier from your own labels
+
+Put the exact label order in `labels.json`, then train a teacher or attach a
+head directly to the published 4-layer base:
+
+```bash
+qwen35-distill finetune \
+  --checkpoint /path/to/text-24l \
+  --train train.jsonl --validation validation.jsonl \
+  --labels labels.json --mode multilabel \
+  --output classifier-24l
+```
+
+To preserve the classifier head while following the full compression chain,
+repeat these two commands for `24to8`, `8to6`, and `6to4`:
+
+```bash
+qwen35-distill materialize-classifier \
+  --source classifier-24l --stage 24to8 \
+  --output classifier-8l-init
+
+qwen35-distill distill-classifier \
+  --teacher classifier-24l --checkpoint classifier-8l-init \
+  --stage 24to8 --train train.jsonl --validation validation.jsonl \
+  --labels labels.json --mode multilabel \
+  --output classifier-8l
+```
+
+The task-specific distillation objective combines the user labels, teacher
+logits, and aligned hidden boundaries. The teacher hashes, dataset hashes,
+label order, environment, loss history, and fresh-reload check are written to
+each output manifest.

distillation/configs/task_agnostic_base.yaml

@@ -0,0 +1,19 @@
+schema_version: qwen35-distill-config-v1
+mode: task_agnostic
+tokenizer: upstream_full
+stages:
+  - 24to8
+  - 8to6
+  - 6to4
+training:
+  seed: 41
+  epochs: 1
+  max_rows: 50000
+  max_length: 128
+  batch_size: 1
+  gradient_accumulation: 8
+  learning_rate: 0.00002
+claims:
+  task_labels_used: false
+  semeval_used: false
+  universal_generalization_claimed: false

distillation/examples/labels.json

@@ -0,0 +1,5 @@
+[
+  "tag_a",
+  "tag_b",
+  "tag_c"
+]

distillation/examples/multilabel_train.jsonl

@@ -0,0 +1,2 @@
+{"id":"m-1","text":"A short example with two tags.","labels":["tag_a","tag_b"],"group_id":"g-1"}
+{"id":"m-2","text":"A second example with one tag.","labels":["tag_c"],"group_id":"g-2"}

distillation/examples/single_label_train.jsonl

@@ -0,0 +1,2 @@
+{"id":"s-1","text":"The package arrived early.","label":"positive","group_id":"g-1"}
+{"id":"s-2","text":"The package did not arrive.","label":"negative","group_id":"g-2"}

distillation/examples/unlabeled.jsonl

@@ -0,0 +1,2 @@
+{"id":"u-1","text":"A small public example for task-agnostic representation distillation."}
+{"id":"u-2","text":"Users should replace these rows with their own licensed text corpus."}

distillation/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qwen35-classification-distill"
+version = "0.1.0"
+description = "Auditable Qwen3.5 24L→8L→6L→4L classification distillation"
+requires-python = ">=3.11"
+dependencies = [
+  "torch>=2.4",
+  "transformers==5.13.0",
+  "safetensors>=0.4",
+  "PyYAML>=6",
+  "pyarrow>=16",
+]
+
+[project.scripts]
+qwen35-distill = "qwen35_distill.cli:main"
+
+[tool.setuptools]
+packages = ["qwen35_distill"]

distillation/qwen35_distill/__init__.py

@@ -0,0 +1,6 @@
+"""Auditable Qwen3.5 classification distillation."""
+
+from .layer_maps import DEFAULT_STAGE_MAPS, StageMap
+
+__all__ = ["DEFAULT_STAGE_MAPS", "StageMap"]
+__version__ = "0.1.0"

distillation/qwen35_distill/checkpoint.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import shutil
+from pathlib import Path
+from typing import Any, Iterable
+
+import torch
+from safetensors import safe_open
+
+from .layer_maps import StageMap
+from .schema import sha256_file
+
+
+def _weight_files(path: Path) -> list[Path]:
+    index = path / "model.safetensors.index.json"
+    if index.is_file():
+        document = json.loads(index.read_text(encoding="utf-8"))
+        names = sorted(set(document["weight_map"].values()))
+        files = [path / name for name in names]
+    else:
+        files = sorted(path.glob("*.safetensors"))
+    if not files:
+        raise FileNotFoundError(f"no safetensors weights in {path}")
+    for file in files:
+        if not file.is_file():
+            raise FileNotFoundError(file)
+    return files
+
+
+def checkpoint_hashes(path: Path) -> dict[str, str]:
+    names = [
+        "config.json",
+        "tokenizer.json",
+        "tokenizer_config.json",
+        "vocab.json",
+        "merges.txt",
+    ]
+    files = _weight_files(path) + [path / name for name in names if (path / name).is_file()]
+    return {file.name: sha256_file(file) for file in files}
+
+
+def _load_source_tensors(
+    files: Iterable[Path], *, prefix: str
+) -> dict[str, torch.Tensor]:
+    state: dict[str, torch.Tensor] = {}
+    for file in files:
+        with safe_open(file, framework="pt", device="cpu") as handle:
+            for name in handle.keys():
+                if prefix and not name.startswith(prefix):
+                    continue
+                target_name = name.removeprefix(prefix)
+                if target_name in state:
+                    raise ValueError(f"duplicate tensor {target_name}")
+                state[target_name] = handle.get_tensor(name)
+    return state
+
+
+def _copy_tokenizer_files(source: Path, output: Path) -> None:
+    for name in (
+        "tokenizer.json",
+        "tokenizer_config.json",
+        "vocab.json",
+        "merges.txt",
+        "chat_template.jinja",
+        "special_tokens_map.json",
+    ):
+        path = source / name
+        if path.is_file():
+            shutil.copy2(path, output / name)
+
+
+def extract_text_checkpoint(source: Path, output: Path) -> dict[str, Any]:
+    """Extract the 24-layer text backbone from the official multimodal checkpoint."""
+    from transformers.models.qwen3_5.configuration_qwen3_5 import Qwen3_5TextConfig
+    from transformers.models.qwen3_5.modeling_qwen3_5 import (
+        Qwen3_5TextModel,
+        Qwen3_5TextRotaryEmbedding,
+    )
+
+    source = source.resolve()
+    output = output.resolve()
+    if output.exists():
+        raise FileExistsError(output)
+    document = json.loads((source / "config.json").read_text(encoding="utf-8"))
+    if "text_config" not in document:
+        raise ValueError("source is not the official multimodal Qwen3.5 layout")
+    config_document = copy.deepcopy(document["text_config"])
+    if int(config_document["num_hidden_layers"]) != 24:
+        raise ValueError("expected a 24-layer text backbone")
+    config_document["architectures"] = ["Qwen3_5TextModel"]
+    config_document["use_cache"] = False
+    config_document["standalone4l_role"] = "task_agnostic_teacher_24l"
+    config = Qwen3_5TextConfig(**config_document)
+    with torch.device("meta"):
+        model = Qwen3_5TextModel(config)
+    mapped = _load_source_tensors(
+        _weight_files(source), prefix="model.language_model."
+    )
+    expected = set(model.state_dict())
+    if set(mapped) != expected:
+        raise ValueError(
+            f"text extraction mismatch: missing={sorted(expected-set(mapped))[:10]}, "
+            f"unexpected={sorted(set(mapped)-expected)[:10]}"
+        )
+    model.load_state_dict(mapped, strict=True, assign=True)
+    fresh_rotary = Qwen3_5TextRotaryEmbedding(config, device="cpu")
+    model.rotary_emb.inv_freq = fresh_rotary.inv_freq
+    model.rotary_emb.original_inv_freq = fresh_rotary.original_inv_freq
+    output.mkdir(parents=True, exist_ok=False)
+    model.eval().save_pretrained(output, safe_serialization=True)
+    _copy_tokenizer_files(source, output)
+    report = {
+        "schema_version": "qwen35-text-extraction-v1",
+        "source": str(source),
+        "output": str(output),
+        "source_hashes": checkpoint_hashes(source),
+        "output_hashes": checkpoint_hashes(output),
+        "tensor_count": len(mapped),
+        "semeval_or_task_labels_used": False,
+    }
+    (output / "extraction_manifest.json").write_text(
+        json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    return report
+
+
+def map_layer_tensor_name(name: str, selected_layers: tuple[int, ...]) -> str | None:
+    prefix = "layers."
+    if not name.startswith(prefix):
+        return name
+    suffix = name.removeprefix(prefix)
+    parts = suffix.split(".", 1)
+    if len(parts) != 2:
+        raise ValueError(f"invalid layer tensor name: {name}")
+    source_index = int(parts[0])
+    try:
+        target_index = selected_layers.index(source_index)
+    except ValueError:
+        return None
+    return f"layers.{target_index}.{parts[1]}"
+
+
+def materialize_student(
+    source: Path, output: Path, stage: StageMap
+) -> dict[str, Any]:
+    from transformers import AutoConfig
+    from transformers.models.qwen3_5.modeling_qwen3_5 import (
+        Qwen3_5TextModel,
+        Qwen3_5TextRotaryEmbedding,
+    )
+
+    source = source.resolve()
+    output = output.resolve()
+    if output.exists():
+        raise FileExistsError(output)
+    source_config = AutoConfig.from_pretrained(source, local_files_only=True)
+    target_types = stage.validate(source_config.layer_types)
+    target_config = copy.deepcopy(source_config)
+    target_config.num_hidden_layers = stage.target_depth
+    target_config.layer_types = list(target_types)
+    target_config.architectures = ["Qwen3_5TextModel"]
+    target_config.use_cache = False
+    target_config.standalone4l_distillation = {
+        "schema_version": "qwen35-stage-map-v1",
+        "stage": stage.name,
+        "source_depth": stage.source_depth,
+        "target_depth": stage.target_depth,
+        "selected_layers": list(stage.selected_layers),
+        "selection_basis": "predeclared_architecture_only_default",
+        "task_labels_used_for_weight_materialization": False,
+    }
+    with torch.device("meta"):
+        model = Qwen3_5TextModel(target_config)
+    source_state = _load_source_tensors(_weight_files(source), prefix="")
+    mapped: dict[str, torch.Tensor] = {}
+    for source_name, tensor in source_state.items():
+        target_name = map_layer_tensor_name(source_name, stage.selected_layers)
+        if target_name is None:
+            continue
+        if target_name in mapped:
+            raise ValueError(f"duplicate mapped tensor {target_name}")
+        mapped[target_name] = tensor
+    expected = set(model.state_dict())
+    if set(mapped) != expected:
+        raise ValueError(
+            f"student mapping mismatch: missing={sorted(expected-set(mapped))[:10]}, "
+            f"unexpected={sorted(set(mapped)-expected)[:10]}"
+        )
+    model.load_state_dict(mapped, strict=True, assign=True)
+    fresh_rotary = Qwen3_5TextRotaryEmbedding(target_config, device="cpu")
+    model.rotary_emb.inv_freq = fresh_rotary.inv_freq
+    model.rotary_emb.original_inv_freq = fresh_rotary.original_inv_freq
+    output.mkdir(parents=True, exist_ok=False)
+    model.eval().save_pretrained(output, safe_serialization=True)
+    _copy_tokenizer_files(source, output)
+    report = {
+        "schema_version": "qwen35-student-materialization-v1",
+        "stage": stage.name,
+        "source": str(source),
+        "output": str(output),
+        "selected_layers": list(stage.selected_layers),
+        "source_hashes": checkpoint_hashes(source),
+        "output_hashes": checkpoint_hashes(output),
+        "mapped_tensor_count": len(mapped),
+        "task_labels_used": False,
+    }
+    (output / "materialization_manifest.json").write_text(
+        json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    return report
+
+
+def finalize_base_checkpoint(
+    source: Path,
+    output: Path,
+    *,
+    training_corpus_rows: int = 4096,
+    training_objective: str = "hidden_and_interface_representation_distillation",
+) -> dict[str, Any]:
+    """Create a classification-ready, headless canonical base without changing weights."""
+    from transformers import AutoModel, AutoModelForSequenceClassification, AutoTokenizer
+
+    if training_corpus_rows < 0:
+        raise ValueError("training_corpus_rows must be non-negative")
+    if not training_objective.strip():
+        raise ValueError("training_objective must be non-empty")
+    source = source.resolve()
+    output = output.resolve()
+    if output.exists():
+        raise FileExistsError(output)
+    source_hashes = checkpoint_hashes(source)
+    config_path = source / "config.json"
+    document = json.loads(config_path.read_text(encoding="utf-8"))
+    tokenizer = AutoTokenizer.from_pretrained(
+        source, local_files_only=True, trust_remote_code=False
+    )
+    if tokenizer.eos_token_id is None:
+        raise ValueError("tokenizer has no EOS token for classification padding")
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    document["architectures"] = ["Qwen3_5TextModel"]
+    document["pad_token_id"] = int(tokenizer.pad_token_id)
+    document["eos_token_id"] = int(tokenizer.eos_token_id)
+    document["use_cache"] = False
+    document["standalone4l_role"] = "task_agnostic_classification_base_4l"
+    document.pop("id2label", None)
+    document.pop("label2id", None)
+    document.pop("num_labels", None)
+    document.pop("problem_type", None)
+    document["standalone4l_base"] = {
+        "schema_version": "standalone4l-task-agnostic-base-v1",
+        "role": "classification_ready_headless_text_backbone",
+        "task_labels_used_in_base_training": False,
+        "semeval_used_in_base_training": False,
+        "tokenizer": "upstream_full_qwen35",
+        "training_corpus_rows": training_corpus_rows,
+        "training_objective": training_objective,
+        "published_classification_head": False,
+    }
+    shutil.copytree(source, output)
+    (output / "config.json").write_text(
+        json.dumps(document, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    tokenizer.save_pretrained(output)
+    weight_hashes_before = {
+        name: value
+        for name, value in source_hashes.items()
+        if name.endswith(".safetensors")
+    }
+    weight_hashes_after = {
+        name: value
+        for name, value in checkpoint_hashes(output).items()
+        if name.endswith(".safetensors")
+    }
+    if weight_hashes_before != weight_hashes_after:
+        raise RuntimeError("canonical finalization changed model weight bytes")
+    base = AutoModel.from_pretrained(
+        output, local_files_only=True, trust_remote_code=False, dtype=torch.bfloat16
+    ).eval()
+    batch = tokenizer(
+        ["A short classification input.", "A second input."],
+        return_tensors="pt",
+        padding=True,
+    )
+    with torch.inference_mode():
+        hidden = base(**batch, use_cache=False).last_hidden_state
+    if not bool(torch.isfinite(hidden).all()):
+        raise RuntimeError("canonical base reload produced non-finite hidden states")
+    classifier = AutoModelForSequenceClassification.from_pretrained(
+        output,
+        local_files_only=True,
+        trust_remote_code=False,
+        num_labels=3,
+        ignore_mismatched_sizes=True,
+        dtype=torch.bfloat16,
+    ).eval()
+    with torch.inference_mode():
+        logits = classifier(**batch).logits
+    if logits.shape != (2, 3) or not bool(torch.isfinite(logits).all()):
+        raise RuntimeError("classification-head attachment validation failed")
+    report = {
+        "schema_version": "standalone4l-base-finalization-v1",
+        "source": str(source),
+        "output": str(output),
+        "source_hashes": source_hashes,
+        "output_hashes": checkpoint_hashes(output),
+        "weight_bytes_preserved": True,
+        "pad_token_id": int(tokenizer.pad_token_id),
+        "eos_token_id": int(tokenizer.eos_token_id),
+        "base_reload_finite": True,
+        "classification_head_attachment": {
+            "validated": True,
+            "test_num_labels": 3,
+            "test_batch_size": 2,
+            "published_head": False,
+        },
+    }
+    (output / "finalization_manifest.json").write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    return report

distillation/qwen35_distill/classification.py

@@ -0,0 +1,386 @@
+from __future__ import annotations
+
+import copy
+import json
+import math
+import platform
+import random
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+import torch
+from torch.optim import AdamW
+from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer
+from transformers.models.qwen3_5.modeling_qwen3_5 import (
+    Qwen3_5TextForSequenceClassification,
+    Qwen3_5TextRotaryEmbedding,
+)
+
+from .checkpoint import (
+    _copy_tokenizer_files,
+    _load_source_tensors,
+    _weight_files,
+    checkpoint_hashes,
+    map_layer_tensor_name,
+)
+from .layer_maps import StageMap
+from .losses import classification_distillation_loss, task_agnostic_boundary_loss
+from .schema import TaskMode, read_jsonl, validate_dataset
+from .training import _dtype
+
+
+def labels_from_file(path: Path) -> list[str]:
+    labels = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(labels, list) or any(
+        not isinstance(label, str) or not label for label in labels
+    ):
+        raise ValueError("labels file must be a JSON string list")
+    if len(set(labels)) != len(labels) or len(labels) < 2:
+        raise ValueError("labels must contain at least two unique values")
+    return labels
+
+
+def encode_targets(
+    rows: list[dict[str, Any]], *, mode: TaskMode, labels: list[str]
+) -> torch.Tensor:
+    label_to_id = {label: index for index, label in enumerate(labels)}
+    if mode == "single_label":
+        return torch.tensor([label_to_id[row["label"]] for row in rows], dtype=torch.long)
+    if mode == "multilabel":
+        target = torch.zeros((len(rows), len(labels)), dtype=torch.float32)
+        for row_index, row in enumerate(rows):
+            for label in row["labels"]:
+                target[row_index, label_to_id[label]] = 1.0
+        return target
+    raise ValueError("classification requires single_label or multilabel mode")
+
+
+def materialize_classifier(
+    source: Path, output: Path, stage: StageMap
+) -> dict[str, Any]:
+    """Copy a trained classifier head and the selected backbone layers."""
+    source = source.resolve()
+    output = output.resolve()
+    if output.exists():
+        raise FileExistsError(output)
+    config = AutoConfig.from_pretrained(source, local_files_only=True)
+    target_types = stage.validate(config.layer_types)
+    target_config = copy.deepcopy(config)
+    target_config.num_hidden_layers = stage.target_depth
+    target_config.layer_types = list(target_types)
+    target_config.architectures = ["Qwen3_5TextForSequenceClassification"]
+    target_config.use_cache = False
+    target_config.standalone4l_distillation = {
+        "schema_version": "qwen35-classifier-stage-map-v1",
+        "stage": stage.name,
+        "selected_layers": list(stage.selected_layers),
+        "classification_head_copied": True,
+    }
+    with torch.device("meta"):
+        model = Qwen3_5TextForSequenceClassification(target_config)
+    source_state = _load_source_tensors(_weight_files(source), prefix="")
+    mapped: dict[str, torch.Tensor] = {}
+    for source_name, tensor in source_state.items():
+        if source_name.startswith("model.layers."):
+            target_name = "model." + (
+                map_layer_tensor_name(
+                    source_name.removeprefix("model."), stage.selected_layers
+                )
+                or ""
+            )
+            if target_name == "model.":
+                continue
+        else:
+            target_name = source_name
+        if target_name in mapped:
+            raise ValueError(f"duplicate mapped tensor {target_name}")
+        mapped[target_name] = tensor
+    expected = set(model.state_dict())
+    if set(mapped) != expected:
+        raise ValueError(
+            f"classifier mapping mismatch: missing={sorted(expected-set(mapped))[:10]}, "
+            f"unexpected={sorted(set(mapped)-expected)[:10]}"
+        )
+    model.load_state_dict(mapped, strict=True, assign=True)
+    fresh_rotary = Qwen3_5TextRotaryEmbedding(target_config, device="cpu")
+    model.model.rotary_emb.inv_freq = fresh_rotary.inv_freq
+    model.model.rotary_emb.original_inv_freq = fresh_rotary.original_inv_freq
+    output.mkdir(parents=True, exist_ok=False)
+    model.eval().save_pretrained(output, safe_serialization=True)
+    _copy_tokenizer_files(source, output)
+    report = {
+        "schema_version": "qwen35-classifier-materialization-v1",
+        "stage": stage.name,
+        "source": str(source),
+        "output": str(output),
+        "selected_layers": list(stage.selected_layers),
+        "head_copied": True,
+        "source_hashes": checkpoint_hashes(source),
+        "output_hashes": checkpoint_hashes(output),
+    }
+    (output / "materialization_manifest.json").write_text(
+        json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    return report
+
+
+def _batch_rows(
+    rows: list[dict[str, Any]], batch_size: int, seed: int
+) -> list[list[dict[str, Any]]]:
+    shuffled = list(rows)
+    random.Random(seed).shuffle(shuffled)
+    return [shuffled[i : i + batch_size] for i in range(0, len(shuffled), batch_size)]
+
+
+def _prepare_model(
+    checkpoint: Path,
+    *,
+    labels: list[str],
+    mode: TaskMode,
+    dtype: torch.dtype,
+    attach_head: bool,
+) -> Qwen3_5TextForSequenceClassification:
+    kwargs = {
+        "local_files_only": True,
+        "dtype": dtype,
+        "num_labels": len(labels),
+        "id2label": {index: label for index, label in enumerate(labels)},
+        "label2id": {label: index for index, label in enumerate(labels)},
+        "problem_type": (
+            "single_label_classification"
+            if mode == "single_label"
+            else "multi_label_classification"
+        ),
+    }
+    if attach_head:
+        kwargs["ignore_mismatched_sizes"] = True
+    model = AutoModelForSequenceClassification.from_pretrained(checkpoint, **kwargs)
+    if not isinstance(model, Qwen3_5TextForSequenceClassification):
+        raise TypeError("checkpoint did not load as Qwen3_5TextForSequenceClassification")
+    return model
+
+
+def _train_classifier(
+    *,
+    model: Qwen3_5TextForSequenceClassification,
+    tokenizer: Any,
+    train_rows: list[dict[str, Any]],
+    labels: list[str],
+    mode: TaskMode,
+    device: torch.device,
+    max_length: int,
+    epochs: int,
+    batch_size: int,
+    gradient_accumulation: int,
+    learning_rate: float,
+    seed: int,
+    teacher: Qwen3_5TextForSequenceClassification | None = None,
+    stage: StageMap | None = None,
+    temperature: float = 2.0,
+    hard_weight: float = 1.0,
+    logit_weight: float = 1.0,
+    hidden_weight: float = 1.0,
+) -> list[dict[str, Any]]:
+    model.train()
+    model.gradient_checkpointing_enable()
+    optimizer = AdamW(model.parameters(), lr=learning_rate, weight_decay=0.01)
+    history: list[dict[str, Any]] = []
+    optimizer.zero_grad(set_to_none=True)
+    for epoch in range(1, epochs + 1):
+        total = 0.0
+        batches = _batch_rows(train_rows, batch_size, seed + epoch)
+        for batch_index, rows in enumerate(batches, start=1):
+            encoded = tokenizer(
+                [row["text"] for row in rows],
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=max_length,
+            )
+            encoded = {key: value.to(device) for key, value in encoded.items()}
+            targets = encode_targets(rows, mode=mode, labels=labels).to(device)
+            output = model(**encoded, output_hidden_states=True, use_cache=False)
+            if teacher is None:
+                if mode == "single_label":
+                    loss = torch.nn.functional.cross_entropy(
+                        output.logits.float(), targets
+                    )
+                else:
+                    loss = torch.nn.functional.binary_cross_entropy_with_logits(
+                        output.logits.float(), targets.float()
+                    )
+            else:
+                assert stage is not None
+                with torch.inference_mode():
+                    teacher_output = teacher(
+                        **encoded, output_hidden_states=True, use_cache=False
+                    )
+                classification_loss, _ = classification_distillation_loss(
+                    output.logits,
+                    teacher_output.logits,
+                    targets,
+                    mode=mode,
+                    temperature=temperature,
+                    hard_weight=hard_weight,
+                    logit_weight=logit_weight,
+                )
+                hidden_loss, _ = task_agnostic_boundary_loss(
+                    output.hidden_states,
+                    teacher_output.hidden_states,
+                    stage.teacher_boundary_indices(),
+                    encoded["attention_mask"],
+                )
+                loss = classification_loss + hidden_weight * hidden_loss
+            if not bool(torch.isfinite(loss)):
+                raise FloatingPointError(f"non-finite loss at epoch {epoch} batch {batch_index}")
+            (loss / gradient_accumulation).backward()
+            total += float(loss.detach())
+            if (
+                batch_index % gradient_accumulation == 0
+                or batch_index == len(batches)
+            ):
+                norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+                if not math.isfinite(float(norm)):
+                    raise FloatingPointError("non-finite gradient norm")
+                optimizer.step()
+                optimizer.zero_grad(set_to_none=True)
+        value = total / len(batches)
+        history.append({"epoch": epoch, "batches": len(batches), "mean_loss": value})
+        print(
+            json.dumps(
+                {"event": "classifier_epoch", "epoch": epoch, "mean_loss": value},
+                ensure_ascii=False,
+            ),
+            flush=True,
+        )
+    return history
+
+
+def train_classifier(
+    *,
+    checkpoint: Path,
+    train_path: Path,
+    validation_path: Path | None,
+    labels_path: Path,
+    output_path: Path,
+    mode: TaskMode,
+    device_name: str,
+    dtype_name: str,
+    max_length: int,
+    epochs: int,
+    batch_size: int,
+    gradient_accumulation: int,
+    learning_rate: float,
+    seed: int,
+    teacher_path: Path | None = None,
+    stage: StageMap | None = None,
+) -> dict[str, Any]:
+    if output_path.exists():
+        raise FileExistsError(output_path)
+    if mode not in ("single_label", "multilabel"):
+        raise ValueError("mode must be single_label or multilabel")
+    labels = labels_from_file(labels_path)
+    split_paths = {"train": train_path}
+    if validation_path:
+        split_paths["validation"] = validation_path
+    audit = validate_dataset(split_paths, mode=mode, labels=labels)
+    rows = read_jsonl(train_path)
+    device = torch.device(device_name)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA requested but unavailable")
+    dtype = _dtype(dtype_name)
+    tokenizer = AutoTokenizer.from_pretrained(
+        checkpoint, local_files_only=True, trust_remote_code=False
+    )
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    model = _prepare_model(
+        checkpoint,
+        labels=labels,
+        mode=mode,
+        dtype=dtype,
+        attach_head=teacher_path is None,
+    ).to(device)
+    model.config.pad_token_id = tokenizer.pad_token_id
+    teacher = None
+    teacher_hashes = None
+    if teacher_path is not None:
+        if stage is None:
+            raise ValueError("distillation requires a stage")
+        teacher_hashes = checkpoint_hashes(teacher_path)
+        teacher = _prepare_model(
+            teacher_path,
+            labels=labels,
+            mode=mode,
+            dtype=dtype,
+            attach_head=False,
+        ).to(device).eval()
+        stage.validate(teacher.config.layer_types)
+        for parameter in teacher.parameters():
+            parameter.requires_grad_(False)
+    history = _train_classifier(
+        model=model,
+        tokenizer=tokenizer,
+        train_rows=rows,
+        labels=labels,
+        mode=mode,
+        device=device,
+        max_length=max_length,
+        epochs=epochs,
+        batch_size=batch_size,
+        gradient_accumulation=gradient_accumulation,
+        learning_rate=learning_rate,
+        seed=seed,
+        teacher=teacher,
+        stage=stage,
+    )
+    if teacher_path is not None and checkpoint_hashes(teacher_path) != teacher_hashes:
+        raise RuntimeError("teacher checkpoint changed during classifier distillation")
+    output_path.mkdir(parents=True, exist_ok=False)
+    model.eval().save_pretrained(output_path, safe_serialization=True)
+    tokenizer.save_pretrained(output_path)
+    reloaded = AutoModelForSequenceClassification.from_pretrained(
+        output_path, local_files_only=True, dtype=dtype
+    ).to(device).eval()
+    sample = tokenizer(rows[0]["text"], return_tensors="pt", truncation=True, max_length=max_length)
+    sample = {key: value.to(device) for key, value in sample.items()}
+    with torch.inference_mode():
+        logits = reloaded(**sample).logits
+    if logits.shape != (1, len(labels)) or not bool(torch.isfinite(logits).all()):
+        raise RuntimeError("fresh classifier reload failed")
+    report = {
+        "schema_version": "qwen35-classifier-training-v1",
+        "status": "completed",
+        "timestamp_kst": datetime.now(ZoneInfo("Asia/Seoul")).isoformat(),
+        "workflow": "task_specific_distillation" if teacher_path else "supervised_finetune",
+        "mode": mode,
+        "labels": labels,
+        "checkpoint": str(checkpoint.resolve()),
+        "teacher": str(teacher_path.resolve()) if teacher_path else None,
+        "stage": stage.name if stage else None,
+        "dataset_audit": audit,
+        "training": {
+            "seed": seed,
+            "epochs": epochs,
+            "batch_size": batch_size,
+            "gradient_accumulation": gradient_accumulation,
+            "max_length": max_length,
+            "learning_rate": learning_rate,
+            "history": history,
+        },
+        "environment": {
+            "python": platform.python_version(),
+            "torch": torch.__version__,
+            "device": str(device),
+            "dtype": dtype_name,
+        },
+        "fresh_reload_finite": True,
+        "output_hashes": checkpoint_hashes(output_path),
+    }
+    (output_path / "training_manifest.json").write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    return report

distillation/qwen35_distill/cli.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from .checkpoint import (
+    extract_text_checkpoint,
+    finalize_base_checkpoint,
+    materialize_student,
+)
+from .classification import materialize_classifier, train_classifier
+from .layer_maps import get_stage
+from .schema import validate_dataset
+from .training import task_agnostic_distill
+
+
+def _print(value: object) -> None:
+    print(json.dumps(value, ensure_ascii=False, indent=2), flush=True)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="qwen35-distill")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate = subparsers.add_parser("validate-dataset")
+    validate.add_argument(
+        "--mode", choices=("unlabeled", "single_label", "multilabel"), required=True
+    )
+    validate.add_argument("--train", type=Path, required=True)
+    validate.add_argument("--validation", type=Path)
+    validate.add_argument("--test", type=Path)
+    validate.add_argument("--labels", type=Path)
+
+    extract = subparsers.add_parser("extract-text")
+    extract.add_argument("--source", type=Path, required=True)
+    extract.add_argument("--output", type=Path, required=True)
+
+    materialize = subparsers.add_parser("materialize")
+    materialize.add_argument("--source", type=Path, required=True)
+    materialize.add_argument("--output", type=Path, required=True)
+    materialize.add_argument(
+        "--stage", choices=("24to8", "8to6", "6to4"), required=True
+    )
+
+    materialize_head = subparsers.add_parser("materialize-classifier")
+    materialize_head.add_argument("--source", type=Path, required=True)
+    materialize_head.add_argument("--output", type=Path, required=True)
+    materialize_head.add_argument(
+        "--stage", choices=("24to8", "8to6", "6to4"), required=True
+    )
+
+    finalize = subparsers.add_parser("finalize-base")
+    finalize.add_argument("--source", type=Path, required=True)
+    finalize.add_argument("--output", type=Path, required=True)
+    finalize.add_argument("--training-corpus-rows", type=int, default=4096)
+    finalize.add_argument(
+        "--training-objective",
+        default="hidden_and_interface_representation_distillation",
+    )
+
+    distill = subparsers.add_parser("distill")
+    distill.add_argument("--teacher", type=Path, required=True)
+    distill.add_argument("--student", type=Path, required=True)
+    distill.add_argument("--data", type=Path, required=True)
+    distill.add_argument("--output", type=Path, required=True)
+    distill.add_argument(
+        "--stage", choices=("24to8", "8to6", "6to4"), required=True
+    )
+    distill.add_argument("--device", default="cuda")
+    distill.add_argument(
+        "--dtype", choices=("float32", "float16", "bfloat16"), default="bfloat16"
+    )
+    distill.add_argument("--max-rows", type=int, default=50000)
+    distill.add_argument("--max-length", type=int, default=128)
+    distill.add_argument("--epochs", type=int, default=1)
+    distill.add_argument("--batch-size", type=int, default=1)
+    distill.add_argument("--gradient-accumulation", type=int, default=8)
+    distill.add_argument("--learning-rate", type=float, default=2e-5)
+    distill.add_argument("--seed", type=int, default=41)
+    distill.add_argument("--progress-every", type=int, default=100)
+
+    for name in ("finetune", "distill-classifier"):
+        command = subparsers.add_parser(name)
+        command.add_argument("--checkpoint", type=Path, required=True)
+        command.add_argument("--train", type=Path, required=True)
+        command.add_argument("--validation", type=Path)
+        command.add_argument("--labels", type=Path, required=True)
+        command.add_argument("--output", type=Path, required=True)
+        command.add_argument(
+            "--mode", choices=("single_label", "multilabel"), required=True
+        )
+        command.add_argument("--device", default="cuda")
+        command.add_argument(
+            "--dtype",
+            choices=("float32", "float16", "bfloat16"),
+            default="bfloat16",
+        )
+        command.add_argument("--max-length", type=int, default=256)
+        command.add_argument("--epochs", type=int, default=3)
+        command.add_argument("--batch-size", type=int, default=1)
+        command.add_argument("--gradient-accumulation", type=int, default=8)
+        command.add_argument("--learning-rate", type=float, default=2e-5)
+        command.add_argument("--seed", type=int, default=41)
+        if name == "distill-classifier":
+            command.add_argument("--teacher", type=Path, required=True)
+            command.add_argument(
+                "--stage", choices=("24to8", "8to6", "6to4"), required=True
+            )
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    if args.command == "validate-dataset":
+        paths = {"train": args.train}
+        if args.validation:
+            paths["validation"] = args.validation
+        if args.test:
+            paths["test"] = args.test
+        labels = None
+        if args.labels:
+            value = json.loads(args.labels.read_text(encoding="utf-8"))
+            if not isinstance(value, list) or any(
+                not isinstance(label, str) for label in value
+            ):
+                raise ValueError("--labels must contain a JSON string list")
+            labels = value
+        _print(validate_dataset(paths, mode=args.mode, labels=labels))
+    elif args.command == "extract-text":
+        _print(extract_text_checkpoint(args.source, args.output))
+    elif args.command == "materialize":
+        _print(materialize_student(args.source, args.output, get_stage(args.stage)))
+    elif args.command == "materialize-classifier":
+        _print(materialize_classifier(args.source, args.output, get_stage(args.stage)))
+    elif args.command == "finalize-base":
+        _print(
+            finalize_base_checkpoint(
+                args.source,
+                args.output,
+                training_corpus_rows=args.training_corpus_rows,
+                training_objective=args.training_objective,
+            )
+        )
+    elif args.command == "distill":
+        _print(
+            task_agnostic_distill(
+                teacher_path=args.teacher,
+                student_path=args.student,
+                data_path=args.data,
+                output_path=args.output,
+                stage=get_stage(args.stage),
+                device_name=args.device,
+                dtype_name=args.dtype,
+                max_rows=args.max_rows,
+                max_length=args.max_length,
+                epochs=args.epochs,
+                batch_size=args.batch_size,
+                gradient_accumulation=args.gradient_accumulation,
+                learning_rate=args.learning_rate,
+                seed=args.seed,
+                progress_every=args.progress_every,
+            )
+        )
+    elif args.command in ("finetune", "distill-classifier"):
+        _print(
+            train_classifier(
+                checkpoint=args.checkpoint,
+                train_path=args.train,
+                validation_path=args.validation,
+                labels_path=args.labels,
+                output_path=args.output,
+                mode=args.mode,
+                device_name=args.device,
+                dtype_name=args.dtype,
+                max_length=args.max_length,
+                epochs=args.epochs,
+                batch_size=args.batch_size,
+                gradient_accumulation=args.gradient_accumulation,
+                learning_rate=args.learning_rate,
+                seed=args.seed,
+                teacher_path=(
+                    args.teacher if args.command == "distill-classifier" else None
+                ),
+                stage=(
+                    get_stage(args.stage)
+                    if args.command == "distill-classifier"
+                    else None
+                ),
+            )
+        )
+    else:
+        raise AssertionError(args.command)
+
+
+if __name__ == "__main__":
+    main()

distillation/qwen35_distill/layer_maps.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Sequence
+
+
+LINEAR = "linear_attention"
+FULL = "full_attention"
+
+
+@dataclass(frozen=True)
+class StageMap:
+    name: str
+    source_depth: int
+    target_depth: int
+    selected_layers: tuple[int, ...]
+    expected_source_types: tuple[str, ...]
+    expected_target_types: tuple[str, ...]
+
+    def validate(self, source_types: Sequence[str]) -> tuple[str, ...]:
+        observed = tuple(str(value) for value in source_types)
+        if len(observed) != self.source_depth:
+            raise ValueError(
+                f"{self.name}: source depth {len(observed)} != {self.source_depth}"
+            )
+        if observed != self.expected_source_types:
+            raise ValueError(f"{self.name}: source layer-type contract mismatch")
+        if len(self.selected_layers) != self.target_depth:
+            raise ValueError(f"{self.name}: selected-layer count mismatch")
+        if self.selected_layers[0] != 0:
+            raise ValueError(f"{self.name}: first source layer must be retained")
+        if self.selected_layers[-1] != self.source_depth - 1:
+            raise ValueError(f"{self.name}: final source layer must be retained")
+        if tuple(sorted(set(self.selected_layers))) != self.selected_layers:
+            raise ValueError(f"{self.name}: selected layers must be sorted and unique")
+        target = tuple(observed[index] for index in self.selected_layers)
+        if target != self.expected_target_types:
+            raise ValueError(
+                f"{self.name}: target types {target} != {self.expected_target_types}"
+            )
+        return target
+
+    def teacher_boundary_indices(self) -> tuple[int, ...]:
+        """Teacher hidden-state indices aligned to every student boundary."""
+        return self.selected_layers + (self.source_depth,)
+
+
+QWEN35_24_TYPES = (LINEAR, LINEAR, LINEAR, FULL) * 6
+QWEN35_8_TYPES = (LINEAR, LINEAR, LINEAR, FULL, LINEAR, LINEAR, LINEAR, FULL)
+QWEN35_6_TYPES = (LINEAR, LINEAR, FULL, LINEAR, LINEAR, FULL)
+QWEN35_4_TYPES = (LINEAR, FULL, LINEAR, FULL)
+
+DEFAULT_STAGE_MAPS: dict[str, StageMap] = {
+    "24to8": StageMap(
+        name="24to8",
+        source_depth=24,
+        target_depth=8,
+        selected_layers=(0, 4, 6, 11, 13, 16, 20, 23),
+        expected_source_types=QWEN35_24_TYPES,
+        expected_target_types=QWEN35_8_TYPES,
+    ),
+    "8to6": StageMap(
+        name="8to6",
+        source_depth=8,
+        target_depth=6,
+        selected_layers=(0, 1, 3, 4, 6, 7),
+        expected_source_types=QWEN35_8_TYPES,
+        expected_target_types=QWEN35_6_TYPES,
+    ),
+    "6to4": StageMap(
+        name="6to4",
+        source_depth=6,
+        target_depth=4,
+        selected_layers=(0, 2, 3, 5),
+        expected_source_types=QWEN35_6_TYPES,
+        expected_target_types=QWEN35_4_TYPES,
+    ),
+}
+
+
+def get_stage(name: str) -> StageMap:
+    try:
+        return DEFAULT_STAGE_MAPS[name]
+    except KeyError as exc:
+        raise ValueError(
+            f"unknown stage {name!r}; expected one of {sorted(DEFAULT_STAGE_MAPS)}"
+        ) from exc

distillation/qwen35_distill/losses.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import torch
+from torch import Tensor
+from torch.nn import functional as F
+
+
+def masked_normalized_hidden_loss(
+    student: Tensor, teacher: Tensor, attention_mask: Tensor
+) -> Tensor:
+    if student.shape != teacher.shape:
+        raise ValueError(f"hidden shape mismatch: {student.shape} vs {teacher.shape}")
+    if student.ndim not in (3, 4):
+        raise ValueError("hidden tensors must be [B,S,H] or [B,K,S,H]")
+    if attention_mask.ndim != 2 or attention_mask.shape != student.shape[:1] + student.shape[-2:-1]:
+        raise ValueError("attention mask shape mismatch")
+    student_norm = F.normalize(student.float(), dim=-1)
+    teacher_norm = F.normalize(teacher.float(), dim=-1)
+    token_loss = 1.0 - (student_norm * teacher_norm).sum(dim=-1)
+    mask = attention_mask.to(dtype=token_loss.dtype)
+    if token_loss.ndim == 3:
+        mask = mask[:, None, :]
+    denominator = mask.sum() * (token_loss.shape[1] if token_loss.ndim == 3 else 1)
+    if float(denominator) <= 0:
+        raise ValueError("attention mask has no valid tokens")
+    return (token_loss * mask).sum() / denominator
+
+
+def gather_boundaries(
+    hidden_states: Sequence[Tensor], indices: Sequence[int]
+) -> Tensor:
+    if not indices:
+        raise ValueError("boundary indices are empty")
+    if max(indices) >= len(hidden_states):
+        raise ValueError("boundary index outside hidden-state tuple")
+    return torch.stack([hidden_states[index] for index in indices], dim=1)
+
+
+def task_agnostic_boundary_loss(
+    student_hidden_states: Sequence[Tensor],
+    teacher_hidden_states: Sequence[Tensor],
+    teacher_indices: Sequence[int],
+    attention_mask: Tensor,
+) -> tuple[Tensor, dict[str, Tensor]]:
+    student_indices = tuple(range(len(student_hidden_states)))
+    student = gather_boundaries(student_hidden_states, student_indices)
+    teacher = gather_boundaries(teacher_hidden_states, teacher_indices)
+    if student.shape != teacher.shape:
+        raise ValueError(
+            f"student/teacher boundary shape mismatch: {student.shape} vs {teacher.shape}"
+        )
+    all_loss = masked_normalized_hidden_loss(student, teacher, attention_mask)
+    final_loss = masked_normalized_hidden_loss(
+        student[:, -1], teacher[:, -1], attention_mask
+    )
+    interface_loss = masked_normalized_hidden_loss(
+        student[:, 1:-1], teacher[:, 1:-1], attention_mask
+    )
+    return 0.5 * (all_loss + final_loss), {
+        "all_boundaries": all_loss,
+        "interfaces": interface_loss,
+        "final": final_loss,
+    }
+
+
+def classification_distillation_loss(
+    student_logits: Tensor,
+    teacher_logits: Tensor,
+    labels: Tensor,
+    *,
+    mode: str,
+    temperature: float,
+    hard_weight: float,
+    logit_weight: float,
+) -> tuple[Tensor, dict[str, Tensor]]:
+    if temperature <= 0:
+        raise ValueError("temperature must be positive")
+    if mode == "single_label":
+        hard = F.cross_entropy(student_logits.float(), labels.long())
+        soft = F.kl_div(
+            F.log_softmax(student_logits.float() / temperature, dim=-1),
+            F.softmax(teacher_logits.float() / temperature, dim=-1),
+            reduction="batchmean",
+        ) * temperature**2
+    elif mode == "multilabel":
+        hard = F.binary_cross_entropy_with_logits(
+            student_logits.float(), labels.float()
+        )
+        soft_targets = torch.sigmoid(teacher_logits.float() / temperature)
+        soft = F.binary_cross_entropy_with_logits(
+            student_logits.float() / temperature, soft_targets
+        ) * temperature**2
+    else:
+        raise ValueError(f"unsupported classification mode: {mode}")
+    total = hard_weight * hard + logit_weight * soft
+    return total, {"hard": hard, "logit": soft}

distillation/qwen35_distill/schema.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any, Iterable, Literal
+
+
+TaskMode = Literal["unlabeled", "single_label", "multilabel"]
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            if not line.strip():
+                continue
+            value = json.loads(line)
+            if not isinstance(value, dict):
+                raise ValueError(f"{path}:{line_number}: row must be an object")
+            rows.append(value)
+    if not rows:
+        raise ValueError(f"{path}: dataset is empty")
+    return rows
+
+
+def validate_rows(
+    rows: Iterable[dict[str, Any]],
+    *,
+    mode: TaskMode,
+    split: str,
+    known_labels: set[str] | None = None,
+) -> dict[str, Any]:
+    ids: set[str] = set()
+    groups: set[str] = set()
+    observed_labels: set[str] = set()
+    count = 0
+    for index, row in enumerate(rows, start=1):
+        count += 1
+        sample_id = row.get("id")
+        text = row.get("text")
+        if not isinstance(sample_id, str) or not sample_id.strip():
+            raise ValueError(f"{split} row {index}: id must be a non-empty string")
+        if sample_id in ids:
+            raise ValueError(f"{split}: duplicate id {sample_id!r}")
+        ids.add(sample_id)
+        if not isinstance(text, str) or not text.strip():
+            raise ValueError(f"{split} row {index}: text must be a non-empty string")
+        group = row.get("group_id")
+        if group is not None:
+            if not isinstance(group, str) or not group.strip():
+                raise ValueError(f"{split} row {index}: invalid group_id")
+            groups.add(group)
+        if mode == "unlabeled":
+            if "label" in row or "labels" in row:
+                raise ValueError(f"{split} row {index}: unlabeled data contains labels")
+        elif mode == "single_label":
+            label = row.get("label")
+            if not isinstance(label, str) or not label:
+                raise ValueError(f"{split} row {index}: missing single label")
+            if "labels" in row:
+                raise ValueError(f"{split} row {index}: both label and labels present")
+            observed_labels.add(label)
+        elif mode == "multilabel":
+            labels = row.get("labels")
+            if not isinstance(labels, list) or not labels:
+                raise ValueError(f"{split} row {index}: labels must be a non-empty list")
+            if "label" in row:
+                raise ValueError(f"{split} row {index}: both label and labels present")
+            if any(not isinstance(label, str) or not label for label in labels):
+                raise ValueError(f"{split} row {index}: invalid multilabel value")
+            if len(set(labels)) != len(labels):
+                raise ValueError(f"{split} row {index}: duplicate label")
+            observed_labels.update(labels)
+        else:
+            raise ValueError(f"unsupported mode: {mode}")
+    if known_labels is not None:
+        unknown = observed_labels - known_labels
+        if unknown:
+            raise ValueError(f"{split}: unknown labels {sorted(unknown)}")
+    return {
+        "split": split,
+        "rows": count,
+        "ids": ids,
+        "groups": groups,
+        "observed_labels": observed_labels,
+    }
+
+
+def validate_dataset(
+    split_paths: dict[str, Path],
+    *,
+    mode: TaskMode,
+    labels: list[str] | None = None,
+) -> dict[str, Any]:
+    if not split_paths or "train" not in split_paths:
+        raise ValueError("a train split is required")
+    if labels is not None:
+        if mode == "unlabeled":
+            raise ValueError("unlabeled mode must not define labels")
+        if not labels or len(set(labels)) != len(labels):
+            raise ValueError("labels must be non-empty and unique")
+        known_labels = set(labels)
+    else:
+        known_labels = None
+    reports: dict[str, dict[str, Any]] = {}
+    all_ids: set[str] = set()
+    split_groups: dict[str, set[str]] = {}
+    for split, path in split_paths.items():
+        path = path.resolve()
+        rows = read_jsonl(path)
+        report = validate_rows(
+            rows, mode=mode, split=split, known_labels=known_labels
+        )
+        overlap = all_ids & report["ids"]
+        if overlap:
+            raise ValueError(f"cross-split duplicate IDs: {sorted(overlap)[:10]}")
+        all_ids.update(report["ids"])
+        split_groups[split] = report["groups"]
+        reports[split] = {
+            "path": str(path),
+            "sha256": sha256_file(path),
+            "rows": report["rows"],
+            "observed_labels": sorted(report["observed_labels"]),
+        }
+    split_names = list(split_groups)
+    for left_index, left in enumerate(split_names):
+        for right in split_names[left_index + 1 :]:
+            overlap = split_groups[left] & split_groups[right]
+            if overlap:
+                raise ValueError(
+                    f"group leakage between {left} and {right}: {sorted(overlap)[:10]}"
+                )
+    return {
+        "schema_version": "qwen35-classification-dataset-audit-v1",
+        "mode": mode,
+        "label_order": labels,
+        "splits": reports,
+        "cross_split_id_overlap": 0,
+        "cross_split_group_overlap": 0,
+    }

distillation/qwen35_distill/training.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+import json
+import math
+import platform
+import random
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+import pyarrow.parquet as pq
+import torch
+from torch.optim import AdamW
+from transformers import AutoTokenizer
+from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5TextModel
+
+from .checkpoint import checkpoint_hashes
+from .layer_maps import StageMap
+from .losses import task_agnostic_boundary_loss
+from .schema import read_jsonl, sha256_file
+
+
+def _read_unlabeled_texts(path: Path) -> list[str]:
+    if path.suffix == ".jsonl":
+        rows = read_jsonl(path)
+        texts = []
+        for index, row in enumerate(rows, start=1):
+            if "label" in row or "labels" in row:
+                raise ValueError(f"unlabeled input contains labels at row {index}")
+            text = row.get("text")
+            if isinstance(text, str) and text.strip():
+                texts.append(text)
+        return texts
+    if path.suffix == ".parquet":
+        table = pq.read_table(path, columns=["text"])
+        return [
+            text
+            for text in table.column("text").to_pylist()
+            if isinstance(text, str) and text.strip()
+        ]
+    raise ValueError("unlabeled data must be .jsonl or .parquet")
+
+
+def _dtype(name: str) -> torch.dtype:
+    choices = {
+        "float32": torch.float32,
+        "float16": torch.float16,
+        "bfloat16": torch.bfloat16,
+    }
+    try:
+        return choices[name]
+    except KeyError as exc:
+        raise ValueError(f"unsupported dtype {name}") from exc
+
+
+def _copy_non_weight_files(source: Path, output: Path) -> None:
+    for name in (
+        "tokenizer.json",
+        "tokenizer_config.json",
+        "vocab.json",
+        "merges.txt",
+        "chat_template.jinja",
+        "special_tokens_map.json",
+    ):
+        path = source / name
+        if path.is_file():
+            shutil.copy2(path, output / name)
+
+
+def task_agnostic_distill(
+    *,
+    teacher_path: Path,
+    student_path: Path,
+    data_path: Path,
+    output_path: Path,
+    stage: StageMap,
+    device_name: str,
+    dtype_name: str,
+    max_rows: int,
+    max_length: int,
+    epochs: int,
+    batch_size: int,
+    gradient_accumulation: int,
+    learning_rate: float,
+    seed: int,
+    progress_every: int,
+) -> dict[str, Any]:
+    if output_path.exists():
+        raise FileExistsError(output_path)
+    if min(max_rows, max_length, epochs, batch_size, gradient_accumulation) < 1:
+        raise ValueError("row/length/epoch/batch/accumulation values must be positive")
+    if progress_every < 1:
+        raise ValueError("progress_every must be positive")
+    random.seed(seed)
+    torch.manual_seed(seed)
+    device = torch.device(device_name)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA requested but unavailable")
+    dtype = _dtype(dtype_name)
+    teacher_hashes_before = checkpoint_hashes(teacher_path)
+    student_hashes_before = checkpoint_hashes(student_path)
+    texts = _read_unlabeled_texts(data_path)
+    random.Random(seed).shuffle(texts)
+    texts = texts[:max_rows]
+    if not texts:
+        raise ValueError("no non-empty training texts")
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        student_path, local_files_only=True, trust_remote_code=False
+    )
+    if tokenizer.pad_token_id is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    teacher = Qwen3_5TextModel.from_pretrained(
+        teacher_path, local_files_only=True, torch_dtype=dtype
+    ).to(device)
+    student = Qwen3_5TextModel.from_pretrained(
+        student_path, local_files_only=True, torch_dtype=dtype
+    ).to(device)
+    stage.validate(teacher.config.layer_types)
+    if int(student.config.num_hidden_layers) != stage.target_depth:
+        raise ValueError("student depth does not match stage")
+    for parameter in teacher.parameters():
+        parameter.requires_grad_(False)
+    teacher.eval()
+    student.train()
+    student.config.pad_token_id = tokenizer.pad_token_id
+    student.gradient_checkpointing_enable()
+    optimizer = AdamW(student.parameters(), lr=learning_rate, weight_decay=0.01)
+    history: list[dict[str, Any]] = []
+    optimizer.zero_grad(set_to_none=True)
+    global_step = 0
+    optimizer_steps = 0
+
+    for epoch in range(1, epochs + 1):
+        epoch_total = 0.0
+        epoch_interface = 0.0
+        epoch_final = 0.0
+        epoch_batches = 0
+        for offset in range(0, len(texts), batch_size):
+            batch_texts = texts[offset : offset + batch_size]
+            encoded = tokenizer(
+                batch_texts,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=max_length,
+            )
+            encoded = {key: value.to(device) for key, value in encoded.items()}
+            with torch.inference_mode():
+                teacher_output = teacher(
+                    **encoded, output_hidden_states=True, use_cache=False
+                )
+            student_output = student(
+                **encoded, output_hidden_states=True, use_cache=False
+            )
+            loss, components = task_agnostic_boundary_loss(
+                student_output.hidden_states,
+                teacher_output.hidden_states,
+                stage.teacher_boundary_indices(),
+                encoded["attention_mask"],
+            )
+            if not bool(torch.isfinite(loss)):
+                raise FloatingPointError(f"non-finite loss at step {global_step}")
+            (loss / gradient_accumulation).backward()
+            global_step += 1
+            epoch_batches += 1
+            epoch_total += float(loss.detach())
+            epoch_interface += float(components["interfaces"].detach())
+            epoch_final += float(components["final"].detach())
+            if global_step % gradient_accumulation == 0 or offset + batch_size >= len(texts):
+                grad_norm = torch.nn.utils.clip_grad_norm_(student.parameters(), 1.0)
+                if not math.isfinite(float(grad_norm)):
+                    raise FloatingPointError("non-finite gradient norm")
+                optimizer.step()
+                optimizer.zero_grad(set_to_none=True)
+                optimizer_steps += 1
+            if global_step == 1 or global_step % progress_every == 0:
+                print(
+                    json.dumps(
+                        {
+                            "event": "distill_progress",
+                            "stage": stage.name,
+                            "epoch": epoch,
+                            "batch": epoch_batches,
+                            "batches_per_epoch": math.ceil(len(texts) / batch_size),
+                            "global_step": global_step,
+                            "optimizer_steps": optimizer_steps,
+                            "mean_loss_so_far": epoch_total / epoch_batches,
+                        },
+                        ensure_ascii=False,
+                    ),
+                    flush=True,
+                )
+        history.append(
+            {
+                "epoch": epoch,
+                "batches": epoch_batches,
+                "mean_total_loss": epoch_total / epoch_batches,
+                "mean_interface_loss": epoch_interface / epoch_batches,
+                "mean_final_loss": epoch_final / epoch_batches,
+                "optimizer_steps_total": optimizer_steps,
+            }
+        )
+
+    teacher_hashes_after = checkpoint_hashes(teacher_path)
+    if teacher_hashes_after != teacher_hashes_before:
+        raise RuntimeError("teacher checkpoint changed during distillation")
+    student.eval()
+    output_path.mkdir(parents=True, exist_ok=False)
+    student.save_pretrained(output_path, safe_serialization=True)
+    _copy_non_weight_files(student_path, output_path)
+    sample = tokenizer(
+        texts[0], return_tensors="pt", truncation=True, max_length=max_length
+    )
+    sample = {key: value.to(device) for key, value in sample.items()}
+    with torch.inference_mode():
+        forward = student(**sample, use_cache=False).last_hidden_state
+    if not bool(torch.isfinite(forward).all()):
+        raise RuntimeError("saved student produced non-finite forward before reload")
+    del student
+    if device.type == "cuda":
+        torch.cuda.empty_cache()
+    reloaded = Qwen3_5TextModel.from_pretrained(
+        output_path, local_files_only=True, torch_dtype=dtype
+    ).to(device).eval()
+    with torch.inference_mode():
+        reload_forward = reloaded(**sample, use_cache=False).last_hidden_state
+    if not bool(torch.isfinite(reload_forward).all()):
+        raise RuntimeError("fresh-reloaded student produced non-finite forward")
+    max_abs_reload = float((forward.float() - reload_forward.float()).abs().max())
+    report = {
+        "schema_version": "qwen35-task-agnostic-kd-v1",
+        "status": "completed",
+        "timestamp_kst": datetime.now(ZoneInfo("Asia/Seoul")).isoformat(),
+        "stage": stage.name,
+        "teacher": str(teacher_path.resolve()),
+        "student_initial": str(student_path.resolve()),
+        "output": str(output_path.resolve()),
+        "data": {
+            "path": str(data_path.resolve()),
+            "sha256": sha256_file(data_path),
+            "rows_used": len(texts),
+            "labels_read": False,
+            "semeval_used": False,
+        },
+        "training": {
+            "seed": seed,
+            "epochs": epochs,
+            "batch_size": batch_size,
+            "gradient_accumulation": gradient_accumulation,
+            "max_length": max_length,
+            "learning_rate": learning_rate,
+            "progress_every": progress_every,
+            "history": history,
+        },
+        "environment": {
+            "python": platform.python_version(),
+            "torch": torch.__version__,
+            "device": str(device),
+            "dtype": dtype_name,
+        },
+        "teacher_hashes_before": teacher_hashes_before,
+        "teacher_hashes_after": teacher_hashes_after,
+        "student_initial_hashes": student_hashes_before,
+        "output_hashes": checkpoint_hashes(output_path),
+        "teacher_immutable": True,
+        "fresh_reload_finite": True,
+        "fresh_reload_max_abs": max_abs_reload,
+    }
+    (output_path / "training_manifest.json").write_text(
+        json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    return report

docs/RELEASE_CONTRACT.md

@@ -0,0 +1,73 @@
+# Unified 1-1-1 Hugging Face release contract
+
+## Repository identity
+
+- New repository: `mp-juuuns/qwen35-standalone4l-classification-base`
+- Existing repository preserved without mutation:
+  `mp-juuuns/qwen35-standalone4l-propaganda-classifier`
+- Existing specialized fixed revision:
+  `e7e0ff16828052687d2e8dd7849e7a521629cf38`
+
+## The three public surfaces
+
+1. Repository root: a headless four-layer Qwen3.5 text backbone trained without
+   SemEval examples, labels, logits, thresholds, or evidence objectives.
+2. `models/semeval-propaganda/`: the existing three-seed task-specific
+   classifier copied byte-for-byte as a separate historical lineage. It is not
+   described as a fine-tuned child of the new root base.
+3. `distillation/`: the reusable 24L→8L→6L→4L platform for unlabeled
+   representation distillation and user-owned single-label or multilabel
+   classification data.
+
+## Base training contract
+
+- Source: the text backbone and full tokenizer of `Qwen/Qwen3.5-0.8B`.
+- Structural defaults:
+  - 24→8: `0,4,6,11,13,16,20,23`
+  - 8→6: `0,1,3,4,6,7`
+  - 6→4: `0,2,3,5`
+- Task-free data: 4,096 deterministically shuffled non-empty rows from the
+  first locally cached WikiText-103 raw training shard.
+- Objective: aligned hidden-boundary and final-representation distillation.
+- One epoch per stage, seed 41, maximum length 128, batch size 1, gradient
+  accumulation 8, learning rate 2e-5, BF16 CUDA.
+- No classification head is published at the root.
+
+The WikiText dataset page currently has inconsistent license wording: metadata
+lists CC BY-SA 3.0 and GFDL, while the prose says CC BY-SA 4.0. The release
+redistributes no WikiText text and discloses both statements rather than
+silently selecting one.
+
+## Transfer gate
+
+The only downstream validation task is an article-level multilabel task derived
+from SemEval-2020 Task 11. It is not the official span- or fragment-level task.
+The public test split contains 55 previously opened articles, so results are
+exploratory rather than confirmatory.
+
+| Initialization | Seed 41 | Seed 42 | Seed 43 | Mean ± sample SD |
+|---|---:|---:|---:|---:|
+| Task-agnostic KD base | 0.58831 | 0.60284 | 0.57128 | 0.58748 ± 0.01579 |
+| Structural 4L copy, no task-free KD | 0.51694 | 0.53494 | 0.50238 | 0.51809 ± 0.01631 |
+
+The preregistered publication gate was that the task-agnostic base must not be
+worse than the structural-copy control by more than 0.01 mean Macro-F1. The
+observed mean difference was +0.06939, so the gate passed. Three training seeds
+are not a confidence interval and no significance claim is made.
+
+## Release gates
+
+- Root `model.safetensors` contains no `score.weight`.
+- Root loads with `AutoModel`, and a temporary classification head can be
+  attached with `AutoModelForSequenceClassification`.
+- Root weight SHA-256 is
+  `2732c616772fe320cdea228ab4554981418b1b2bf615c4183fb1ac8e6e2168d3`.
+- Base manifests say `labels_read=false` and `semeval_used=false`.
+- Nested specialized checkpoint hashes equal the already published release.
+- The platform validates label order and ID/group split leakage, never
+  overwrites output directories, hashes inputs/outputs, verifies immutable
+  teachers, and reloads fresh checkpoints.
+- The release contains no SemEval or WikiText source data.
+- The old specialized repository revision and inventory are checked before and
+  after creation of the new repository.
+

model.safetensors

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

models/semeval-propaganda/LICENSE

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

models/semeval-propaganda/README.md

@@ -0,0 +1,27 @@
+# SemEval-derived propaganda classifier
+
+This subfolder preserves the already published three-seed task-specific model.
+It is a separate lineage and is **not** a fine-tuned child of the headless base
+at this repository root.
+
+- Original repository: https://huggingface.co/mp-juuuns/qwen35-standalone4l-propaganda-classifier
+- Preserved revision: `e7e0ff16828052687d2e8dd7849e7a521629cf38`
+- Task: article-level multilabel presence of 14 propaganda techniques derived
+  from SemEval-2020 Task 11 annotations.
+- Scope: not the official span- or fragment-level task; not a fact checker.
+- Root of this subfolder: seed 41. Seeds 42 and 43 are under `seeds/`.
+
+```python
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+repo = "mp-juuuns/qwen35-standalone4l-classification-base"
+subfolder = "models/semeval-propaganda"
+tokenizer = AutoTokenizer.from_pretrained(repo, subfolder=subfolder)
+model = AutoModelForSequenceClassification.from_pretrained(
+    repo, subfolder=subfolder
+).eval()
+```
+
+The files below are byte-identical copies of the current release bundle. The
+original release manifest and locked thresholds are included for provenance.
+No SemEval source article or annotation file is redistributed.

models/semeval-propaganda/benchmark/final4l_aggregate.json

@@ -0,0 +1,289 @@
+{
+  "schema_version": "final-broad-arm-aggregate-v1",
+  "status": "completed_three_seed_audited",
+  "created_at": "2026-07-30T12:49:56+09:00",
+  "arm_id": "qwen35-standalone4l-commonhead",
+  "experiment_id": "S-20260729-final-broad-benchmark-v1",
+  "model": {
+    "description": "Qwen3.5 independently distilled standalone 4-layer L-F-L-F sequence classifier with shared 14-class head",
+    "source_checkpoint": "results/layer_shrink_v6/20260728-v6-r23-standalone4l-kd-seed41-v1/student-4l-final-bf16",
+    "source_audit_sha256": "6c53ed491d5c1d8d18610c7f68105691a12d2a999eafd0b471f2b373f92b1298",
+    "source_config_sha256": "f2e2b9547696963a08a1b9403b4ea7973b8c9626c6d0a119dfdee2713e3dfdd9",
+    "source_model_sha256": "8b3959f6326c75f557b781caa3930478d0b112faf7db8ff59ec5c6c7c444edcf",
+    "excluded_historical_joint_heads_sha256": "db886bfab8b827a17062c1fa4057641d2c77aa265e83f5fe07aa731f0de06fd1",
+    "tokenizer_sha256": "2106c29a0c7de1308e536b9f8a01833b9ff9bd0b34a526019f478bc53b6da81d",
+    "tokenizer_config_sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+    "teacher_depth": 6,
+    "student_depth": 4,
+    "selected_teacher_layers": [
+      0,
+      2,
+      3,
+      5
+    ],
+    "layer_types": [
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "full_attention"
+    ],
+    "hidden_size": 1024,
+    "vocabulary_size": 128000,
+    "parameters": 210903360,
+    "head_policy": "Historical 3-class score weight replaced with a freshly initialized shared 14-class score weight; separate historical joint_heads.safetensors not loaded."
+  },
+  "dataset": {
+    "name": "SemEval-2020 Task 11 public professional human gold v2",
+    "train_sha256": "d5e3307374565a4bffba47c02da850c73f5616d3bace99b08f7b689bf8ce2bdf",
+    "calibration_sha256": "80911ff094cf300644e43a2baf57029cc0527d34af7881c787f0b898c2e83acd",
+    "test_sha256": "ed224269dc0a386dfefff2a8cb8cafb8b9bb0a2d8495c616f8365892b4709463",
+    "task_spec_sha256": "8ce5df61b17c1f7819b161f84f7c1e21415b0c6014abc9ce3c5c2fa4120715ff",
+    "test_articles": 55,
+    "test_previously_opened_public_gold": true
+  },
+  "protocol": {
+    "seeds": [
+      41,
+      42,
+      43
+    ],
+    "epochs": 5,
+    "train_windows_per_epoch": 2428,
+    "early_stopping": false,
+    "max_length": 256,
+    "stride": 128,
+    "micro_batch_size": 1,
+    "eval_batch_size": 2,
+    "gradient_accumulation": 32,
+    "effective_batch_size": 32,
+    "learning_rate": 2e-05,
+    "weight_decay": 0.01,
+    "gradient_clip": 1.0,
+    "dtype": "bfloat16",
+    "test_access": "once_per_seed_after_epoch5_calibration_lock"
+  },
+  "seed_artifacts": [
+    {
+      "seed": 41,
+      "report": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/report.json",
+        "sha256": "ec5314140fff0bdd46e87ee00ad67bee7e61d82c7cfa34add1510dd7d5bdb3c0"
+      },
+      "manifest": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41.run-manifest.json",
+        "sha256": "9c9de086a0679611f9ffa99a8e3b01b30889d80a859fad1b80fffb7fa3d08ea9"
+      },
+      "predictions": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/test_predictions.jsonl",
+        "sha256": "6564a34da352ee3808b00c24e69010144fef5947af8b4913656a13547c693f1e"
+      },
+      "checkpoint": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/checkpoint/model.safetensors",
+        "sha256": "0352da6e4717a2e6f3a9d643d034be2cb1c39632d1bce0ced339ddb62acedb37"
+      },
+      "reload_exact": true,
+      "max_probability_delta": 0.0
+    },
+    {
+      "seed": 42,
+      "report": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/report.json",
+        "sha256": "e5c45a7dc41bebf4550da7c5763d0759c6d0922da9efda4048564c11c6d2f3af"
+      },
+      "manifest": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42.run-manifest.json",
+        "sha256": "6e61bb7ab1731c138301acf3d9877c8b18cc3750b856fecba4042099f14fa538"
+      },
+      "predictions": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/test_predictions.jsonl",
+        "sha256": "2a1a22583b6a32860b744f7c8022379816417f09ebe4a71f34de3462e5c5e597"
+      },
+      "checkpoint": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/checkpoint/model.safetensors",
+        "sha256": "2db5f4be391d9dee64458cb5865530f39747019e7a219443b5f7850befbce697"
+      },
+      "reload_exact": true,
+      "max_probability_delta": 0.0
+    },
+    {
+      "seed": 43,
+      "report": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/report.json",
+        "sha256": "e05bc2146d720706780fc45a1fb05911d5c2926caa0bcb12ffead946028eef0d"
+      },
+      "manifest": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43.run-manifest.json",
+        "sha256": "092244cf229081b20eee52cbb10889f98889f486366c440a409fe1845a888905"
+      },
+      "predictions": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/test_predictions.jsonl",
+        "sha256": "d6bb001f9cff810810ba17dce1e93edfea7c155a7b18fbf2e31c05a5eb1f16d9"
+      },
+      "checkpoint": {
+        "path": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/checkpoint/model.safetensors",
+        "sha256": "81a56d497df758e8a292eea528438cfc4d5a847cd37d3a7e1107fefa7c500640"
+      },
+      "reload_exact": true,
+      "max_probability_delta": 0.0
+    }
+  ],
+  "quality": {
+    "test_macro_f1": {
+      "values": [
+        0.5832848452288824,
+        0.5958405181160762,
+        0.5835785045218137
+      ],
+      "mean": 0.5875679559555907,
+      "sample_sd": 0.007165753447433348
+    },
+    "test_micro_f1": {
+      "values": [
+        0.6494252873563218,
+        0.6458616010854816,
+        0.6486486486486486
+      ],
+      "mean": 0.647978512363484,
+      "sample_sd": 0.0018739735696546695
+    },
+    "final_calibration_macro_f1": {
+      "values": [
+        0.5555148573005716,
+        0.5351509002776785,
+        0.5298118328152787
+      ],
+      "mean": 0.540159196797843,
+      "sample_sd": 0.01356368837920977
+    },
+    "locked_thresholds": [
+      0.1,
+      0.05,
+      0.05
+    ],
+    "stability_warning": "All seeds showed late-epoch calibration decline and large threshold movement; two of three final thresholds hit the lower edge of the preregistered grid even though test F1 remained high.",
+    "small_test_warning": "The shared test split contains only 55 previously opened public-gold articles; high F1 and paired-seed consistency require confirmation on distinct public human-gold datasets."
+  },
+  "resources": {
+    "wall_seconds": {
+      "values": [
+        1634.488557530014,
+        1652.9397718419787,
+        1643.488202479988
+      ],
+      "mean": 1643.6388439506602,
+      "sample_sd": 9.226529522850198
+    },
+    "peak_cuda_allocated_bytes": {
+      "values": [
+        2143655936,
+        2143655936,
+        2143655936
+      ],
+      "mean": 2143655936.0,
+      "sample_sd": 0.0
+    },
+    "peak_cuda_reserved_bytes": {
+      "values": [
+        2281701376,
+        2281701376,
+        2273312768
+      ],
+      "mean": 2278905173.3333335,
+      "sample_sd": 4843165.086926248
+    },
+    "ambient_gpu_context": {
+      "nvml_pid_at_preflight": 197568,
+      "visible_in_wsl_process_namespace": false,
+      "baseline_used_mib_range": [
+        3707,
+        3729
+      ],
+      "baseline_free_mib_range": [
+        12267,
+        12289
+      ],
+      "baseline_utilization_percent": 1,
+      "stopped_for_benchmark": false,
+      "runner_peak_metrics_process_local": true
+    }
+  },
+  "raw_comparisons": {
+    "qwen35_full24l": {
+      "other_macro_f1_mean": 0.5642638295960175,
+      "macro_mean_delta_this_minus_other": 0.02330412635957324,
+      "paired_seed_macro_deltas": [
+        0.011832078826701897,
+        0.03452762812104826,
+        0.023552672130969676
+      ],
+      "wall_reduction_fraction": 0.8720113142644486,
+      "peak_cuda_allocated_reduction_fraction": 0.7192454897050662,
+      "parameter_reduction_fraction": 0.7196952459369882
+    },
+    "qwen35_c8q8l": {
+      "other_macro_f1_mean": 0.5366873350531403,
+      "macro_mean_delta_this_minus_other": 0.05088062090245049,
+      "paired_seed_macro_deltas": [
+        0.06653285611641446,
+        0.04916191142573212,
+        0.03694709516520478
+      ],
+      "wall_reduction_fraction": 0.6170087121951836,
+      "peak_cuda_allocated_reduction_fraction": 0.4965455376253577,
+      "parameter_reduction_fraction": 0.4982463406111276
+    },
+    "xlmr_base": {
+      "other_macro_f1_mean": 0.5483113137371987,
+      "macro_mean_delta_this_minus_other": 0.03925664221839209,
+      "paired_seed_macro_deltas": [
+        0.04717846633760603,
+        0.050893521484219884,
+        0.01969793883335047
+      ]
+    },
+    "qwen25_fixed8l": {
+      "other_macro_f1_mean": 0.513131621013363,
+      "macro_mean_delta_this_minus_other": 0.07443633494222779,
+      "paired_seed_macro_deltas": [
+        0.056130719634202686,
+        0.09312943034491972,
+        0.07404885484756096
+      ]
+    },
+    "mbert": {
+      "other_macro_f1_mean": 0.5319538028157794,
+      "macro_mean_delta_this_minus_other": 0.05561415313981133,
+      "paired_seed_macro_deltas": [
+        0.03516462711549406,
+        0.07017577990032031,
+        0.06150205240361961
+      ]
+    },
+    "minilm_multilingual": {
+      "other_macro_f1_mean": 0.5078871917240945,
+      "macro_mean_delta_this_minus_other": 0.07968076423149628,
+      "paired_seed_macro_deltas": [
+        0.09316945437553353,
+        0.08396188337177446,
+        0.061910954947180796
+      ]
+    },
+    "claim_boundary": "Raw descriptive shared-protocol comparisons only. Three paired seeds and one 55-article opened public-gold test split do not establish population-level superiority, deployment superiority, or an overall systems winner."
+  },
+  "environment": {
+    "optional_fast_linear_attention_installed": false,
+    "optional_causal_convolution_installed": false,
+    "execution_path": "Transformers PyTorch fallback",
+    "tensorboard_added_mid_matrix": false
+  },
+  "exclusions": {
+    "historical_opened_calibration_diagnostic_used_as_result": false,
+    "historical_joint_heads_loaded": false,
+    "semeval2023_task3_private_or_final_data_used": false,
+    "mac_used": false,
+    "new_human_gold_created": false,
+    "uno_service_disrupted": false
+  },
+  "independent_audit": "passed",
+  "derived_research_indexes_rebuilt": false
+}

models/semeval-propaganda/chat_template.jinja

@@ -0,0 +1,120 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- else %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- 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 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 }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+{%- endmacro %}
+{%- if tools is defined and tools is iterable and tools | length > 0 %}
+    {{- '<|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' and messages[0].content | trim %}
+        {%- set content = render_content(messages[0].content, false) %}
+        {{- '\n\n' + content.lstrip('\n') }}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + render_content(messages[0].content, false) + '<|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) %}
+        {%- 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 %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true) %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
+            {%- 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 %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- set content = content.rstrip('\n') %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- 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 %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n<think>\n' }}
+{%- endif %}

models/semeval-propaganda/classify.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Run the public Qwen3.5 standalone-4L multilabel classifier.
+
+The script is intentionally self-contained so the same file can be uploaded as
+``classify.py`` to Hugging Face. Long articles are split into the frozen
+256-token / 128-token-overlap windows and combined with a label-wise maximum.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+from pathlib import Path
+from typing import Any, Sequence
+
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+
+DEFAULT_MODEL = "mp-juuuns/qwen35-standalone4l-propaganda-classifier"
+LOCKED_THRESHOLDS = {41: 0.10, 42: 0.05, 43: 0.05}
+MAX_LENGTH = 256
+STRIDE = 128
+
+
+def seed_subfolder(model_id: str, seed: int) -> str | None:
+    """Resolve the public repo layout while allowing direct local checkpoints."""
+
+    if seed == 41:
+        return None
+    local = Path(model_id)
+    if local.exists():
+        candidate = local / "seeds" / f"seed{seed}"
+        return f"seeds/seed{seed}" if candidate.is_dir() else None
+    return f"seeds/seed{seed}"
+
+
+def resolve_device(requested: str) -> torch.device:
+    if requested == "auto":
+        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    device = torch.device(requested)
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("CUDA was requested but is not available")
+    return device
+
+
+def load_runtime(
+    model_id: str,
+    *,
+    seed: int,
+    device: torch.device,
+    revision: str | None = None,
+    local_files_only: bool = False,
+) -> tuple[Any, Any, list[str]]:
+    subfolder = seed_subfolder(model_id, seed)
+    shared: dict[str, Any] = {
+        "revision": revision,
+        "local_files_only": local_files_only,
+        "trust_remote_code": False,
+    }
+    if subfolder:
+        shared["subfolder"] = subfolder
+    tokenizer = AutoTokenizer.from_pretrained(model_id, **shared)
+    if tokenizer.pad_token_id is None:
+        if tokenizer.eos_token_id is None:
+            raise RuntimeError("tokenizer has neither pad_token_id nor eos_token_id")
+        tokenizer.pad_token = tokenizer.eos_token
+    dtype = torch.bfloat16 if device.type == "cuda" and torch.cuda.is_bf16_supported() else (
+        torch.float16 if device.type == "cuda" else torch.float32
+    )
+    model = AutoModelForSequenceClassification.from_pretrained(
+        model_id,
+        dtype=dtype,
+        **shared,
+    ).to(device)
+    model.eval()
+    if hasattr(model.config, "use_cache"):
+        model.config.use_cache = False
+    id2label = getattr(model.config, "id2label", {})
+    labels = [str(id2label.get(index, id2label.get(str(index), f"LABEL_{index}"))) for index in range(14)]
+    if len(labels) != 14 or any(label.startswith("LABEL_") for label in labels):
+        raise RuntimeError("checkpoint does not expose the fixed 14-label order")
+    return tokenizer, model, labels
+
+
+def classify_texts(
+    texts: Sequence[str],
+    *,
+    tokenizer: Any,
+    model: Any,
+    labels: Sequence[str],
+    threshold: float,
+    device: torch.device,
+    batch_size: int = 8,
+) -> list[dict[str, Any]]:
+    if not texts or any(not isinstance(text, str) or not text.strip() for text in texts):
+        raise ValueError("at least one non-empty text is required")
+    if len(labels) != 14:
+        raise ValueError("expected the fixed 14-label order")
+    if not 0 < threshold < 1:
+        raise ValueError("threshold must be in (0, 1)")
+    encoded = tokenizer(
+        list(texts),
+        truncation=True,
+        max_length=MAX_LENGTH,
+        stride=STRIDE,
+        return_overflowing_tokens=True,
+        padding=True,
+        return_tensors="pt",
+    )
+    mapping = encoded.pop("overflow_to_sample_mapping")
+    model_inputs = {
+        key: value
+        for key, value in encoded.items()
+        if key in {"input_ids", "attention_mask", "token_type_ids"}
+    }
+    window_probabilities: list[torch.Tensor] = []
+    with torch.inference_mode():
+        for start in range(0, int(mapping.numel()), batch_size):
+            batch = {
+                key: value[start : start + batch_size].to(device)
+                for key, value in model_inputs.items()
+            }
+            logits = model(**batch).logits
+            if logits.ndim != 2 or logits.shape[1] != 14:
+                raise RuntimeError(f"unexpected classifier output shape: {tuple(logits.shape)}")
+            window_probabilities.append(torch.sigmoid(logits.float()).cpu())
+    probabilities = torch.cat(window_probabilities, dim=0)
+    if probabilities.shape != (mapping.numel(), 14) or not torch.isfinite(probabilities).all():
+        raise RuntimeError("non-finite or malformed probability matrix")
+    outputs: list[dict[str, Any]] = []
+    mapping_list = mapping.tolist()
+    for article_index, _ in enumerate(texts):
+        indices = [index for index, mapped in enumerate(mapping_list) if mapped == article_index]
+        if not indices:
+            raise RuntimeError(f"tokenizer produced no window for input {article_index}")
+        article_scores = probabilities[indices].amax(dim=0).tolist()
+        if not all(math.isfinite(value) for value in article_scores):
+            raise RuntimeError("non-finite article score")
+        predicted_ids = [index for index, score in enumerate(article_scores) if score >= threshold]
+        outputs.append(
+            {
+                "input_index": article_index,
+                "windows": len(indices),
+                "predicted_ids": predicted_ids,
+                "predicted_labels": [labels[index] for index in predicted_ids],
+                "threshold": threshold,
+                "scores": [
+                    {"id": index, "label": label, "probability": article_scores[index]}
+                    for index, label in enumerate(labels)
+                ],
+            }
+        )
+    return outputs
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", default=DEFAULT_MODEL)
+    parser.add_argument("--revision")
+    parser.add_argument("--seed", type=int, choices=sorted(LOCKED_THRESHOLDS), default=41)
+    parser.add_argument("--text", action="append", default=[])
+    parser.add_argument("--text-file", type=Path, action="append", default=[])
+    parser.add_argument("--threshold", type=float)
+    parser.add_argument("--device", choices=("auto", "cpu", "cuda"), default="auto")
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--local-files-only", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    texts = list(args.text)
+    texts.extend(path.read_text(encoding="utf-8") for path in args.text_file)
+    if not texts:
+        raise SystemExit("provide --text or --text-file")
+    if args.batch_size < 1:
+        raise SystemExit("--batch-size must be positive")
+    threshold = LOCKED_THRESHOLDS[args.seed] if args.threshold is None else args.threshold
+    device = resolve_device(args.device)
+    tokenizer, model, labels = load_runtime(
+        args.model,
+        seed=args.seed,
+        device=device,
+        revision=args.revision,
+        local_files_only=args.local_files_only,
+    )
+    outputs = classify_texts(
+        texts,
+        tokenizer=tokenizer,
+        model=model,
+        labels=labels,
+        threshold=threshold,
+        device=device,
+        batch_size=args.batch_size,
+    )
+    payload = {
+        "model": args.model,
+        "seed": args.seed,
+        "threshold": threshold,
+        "device": str(device),
+        "contract": {
+            "task": "14-label multilabel propaganda-technique classification",
+            "max_length": MAX_LENGTH,
+            "stride": STRIDE,
+            "article_aggregation": "labelwise maximum probability across windows",
+            "trust_remote_code": False,
+        },
+        "outputs": outputs,
+    }
+    print(json.dumps(payload, ensure_ascii=False, indent=2, allow_nan=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

models/semeval-propaganda/config.json

@@ -0,0 +1,122 @@
+{
+  "architectures": [
+    "Qwen3_5TextForSequenceClassification"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_output_gate": true,
+  "bos_token_id": null,
+  "dtype": "bfloat16",
+  "eos_token_id": 127967,
+  "full_attention_interval": 4,
+  "head_dim": 256,
+  "hidden_act": "silu",
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "Appeal_to_Authority",
+    "1": "Appeal_to_fear-prejudice",
+    "2": "Bandwagon,Reductio_ad_hitlerum",
+    "3": "Black-and-White_Fallacy",
+    "4": "Causal_Oversimplification",
+    "5": "Doubt",
+    "6": "Exaggeration,Minimisation",
+    "7": "Flag-Waving",
+    "8": "Loaded_Language",
+    "9": "Name_Calling,Labeling",
+    "10": "Repetition",
+    "11": "Slogans",
+    "12": "Thought-terminating_Cliches",
+    "13": "Whataboutism,Straw_Men,Red_Herring"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3584,
+  "label2id": {
+    "Appeal_to_Authority": 0,
+    "Appeal_to_fear-prejudice": 1,
+    "Bandwagon,Reductio_ad_hitlerum": 2,
+    "Black-and-White_Fallacy": 3,
+    "Causal_Oversimplification": 4,
+    "Doubt": 5,
+    "Exaggeration,Minimisation": 6,
+    "Flag-Waving": 7,
+    "Loaded_Language": 8,
+    "Name_Calling,Labeling": 9,
+    "Repetition": 10,
+    "Slogans": 11,
+    "Thought-terminating_Cliches": 12,
+    "Whataboutism,Straw_Men,Red_Herring": 13
+  },
+  "layer_types": [
+    "linear_attention",
+    "full_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": 4,
+  "num_key_value_heads": 2,
+  "pad_token_id": 127967,
+  "partial_rotary_factor": 0.25,
+  "phase_v6_map_selection_rank": 1,
+  "phase_v6_map_selection_split": "public_gold_train",
+  "phase_v6_materialized_role": "student6l-r3-final-teacher",
+  "phase_v6_materialized_trainable_state": "results/layer_shrink_v6/20260726-v6-r3-student6l-map013457-kd-seed41-pilot-v2/student-6l-kd-trainable.safetensors",
+  "phase_v6_selected_original_8l_layers": [
+    0,
+    3,
+    4,
+    7
+  ],
+  "phase_v6_selected_source_layers": [
+    0,
+    1,
+    3,
+    4,
+    5,
+    7
+  ],
+  "phase_v6_selected_source_layers_6l": [
+    0,
+    2,
+    3,
+    5
+  ],
+  "phase_v6_source_teacher": "student6l-r3-final",
+  "phase_v6_standalone4l_kd": {
+    "canonical_materialization_dtype": "bfloat16",
+    "canonical_training_state_preservation": true,
+    "epochs": 3,
+    "legacy_float16_checkpoint": "results/layer_shrink_v6/20260728-v6-r23-standalone4l-kd-seed41-v1/student-4l-final",
+    "opened_calibration_used_for_model_selection": false,
+    "seed": 41,
+    "teacher": "results/layer_shrink_v6/20260728-v6-r22-standalone4l-map-probe-seed41-v1/teacher-6l-r3-final"
+  },
+  "problem_type": "multi_label_classification",
+  "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,
+  "transformers_version": "5.13.0",
+  "use_cache": false,
+  "vocab_size": 128000
+}

models/semeval-propaganda/labels.json

@@ -0,0 +1,34 @@
+{
+  "labels": [
+    "Appeal_to_Authority",
+    "Appeal_to_fear-prejudice",
+    "Bandwagon,Reductio_ad_hitlerum",
+    "Black-and-White_Fallacy",
+    "Causal_Oversimplification",
+    "Doubt",
+    "Exaggeration,Minimisation",
+    "Flag-Waving",
+    "Loaded_Language",
+    "Name_Calling,Labeling",
+    "Repetition",
+    "Slogans",
+    "Thought-terminating_Cliches",
+    "Whataboutism,Straw_Men,Red_Herring"
+  ],
+  "id2label": {
+    "0": "Appeal_to_Authority",
+    "1": "Appeal_to_fear-prejudice",
+    "2": "Bandwagon,Reductio_ad_hitlerum",
+    "3": "Black-and-White_Fallacy",
+    "4": "Causal_Oversimplification",
+    "5": "Doubt",
+    "6": "Exaggeration,Minimisation",
+    "7": "Flag-Waving",
+    "8": "Loaded_Language",
+    "9": "Name_Calling,Labeling",
+    "10": "Repetition",
+    "11": "Slogans",
+    "12": "Thought-terminating_Cliches",
+    "13": "Whataboutism,Straw_Men,Red_Herring"
+  }
+}

models/semeval-propaganda/model.safetensors

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

models/semeval-propaganda/release_manifest.json

@@ -0,0 +1,637 @@
+{
+  "schema": "qwen35-standalone4l-huggingface-release-manifest-v2",
+  "status": "complete",
+  "repo_id": "mp-juuuns/qwen35-standalone4l-propaganda-classifier",
+  "root_checkpoint_seed": 41,
+  "seed_metadata": [
+    {
+      "seed": 41,
+      "threshold": 0.1,
+      "macro_f1": 0.5832848452288824,
+      "micro_f1": 0.6494252873563218,
+      "report_sha256": "ec5314140fff0bdd46e87ee00ad67bee7e61d82c7cfa34add1510dd7d5bdb3c0",
+      "checkpoint_hashes": {
+        "model.safetensors": "0352da6e4717a2e6f3a9d643d034be2cb1c39632d1bce0ced339ddb62acedb37",
+        "config.json": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0",
+        "tokenizer.json": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8",
+        "tokenizer_config.json": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+        "chat_template.jinja": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978"
+      }
+    },
+    {
+      "seed": 42,
+      "threshold": 0.05,
+      "macro_f1": 0.5958405181160762,
+      "micro_f1": 0.6458616010854816,
+      "report_sha256": "e5c45a7dc41bebf4550da7c5763d0759c6d0922da9efda4048564c11c6d2f3af",
+      "checkpoint_hashes": {
+        "model.safetensors": "2db5f4be391d9dee64458cb5865530f39747019e7a219443b5f7850befbce697",
+        "config.json": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0",
+        "tokenizer.json": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8",
+        "tokenizer_config.json": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+        "chat_template.jinja": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978"
+      }
+    },
+    {
+      "seed": 43,
+      "threshold": 0.05,
+      "macro_f1": 0.5835785045218137,
+      "micro_f1": 0.6486486486486486,
+      "report_sha256": "e05bc2146d720706780fc45a1fb05911d5c2926caa0bcb12ffead946028eef0d",
+      "checkpoint_hashes": {
+        "model.safetensors": "81a56d497df758e8a292eea528438cfc4d5a847cd37d3a7e1107fefa7c500640",
+        "config.json": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0",
+        "tokenizer.json": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8",
+        "tokenizer_config.json": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+        "chat_template.jinja": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978"
+      }
+    }
+  ],
+  "files_before_manifest": [
+    {
+      "path": ".gitattributes",
+      "role": "Hugging Face large-file policy",
+      "bytes": 1243,
+      "sha256": "cb9f787a7d5053ba7b8a4c7d6938a85ad902321fafd923cfbbab160eaf6b33fd",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "LICENSE",
+      "role": "Apache-2.0 license text",
+      "bytes": 11418,
+      "sha256": "77fd4710def9ec3c0f6225800e0235f15a425abd4a8b03559127fcd782612049",
+      "source": "references/software/transformers-5.13.0/LICENSE",
+      "source_sha256": "77fd4710def9ec3c0f6225800e0235f15a425abd4a8b03559127fcd782612049"
+    },
+    {
+      "path": "README.md",
+      "role": "Hugging Face model card",
+      "bytes": 26722,
+      "sha256": "951d304189735d79403abde007b88992a0c7c6f60b8a01cb066596f703d6ed89",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "benchmark/MODEL_CARD_EVIDENCE.md",
+      "role": "claim-by-claim model-card evidence ledger",
+      "bytes": 14498,
+      "sha256": "80ae7e7fc6ef834188d2a02bcaa5dcc657d88b8b007b9904182fec8b5d555e61",
+      "source": "docs/huggingface/STANDALONE4L_MODEL_CARD_EVIDENCE.md",
+      "source_sha256": "80ae7e7fc6ef834188d2a02bcaa5dcc657d88b8b007b9904182fec8b5d555e61"
+    },
+    {
+      "path": "benchmark/SEALED_REPORT.md",
+      "role": "sealed benchmark narrative",
+      "bytes": 7049,
+      "sha256": "f74f85f43c3d18c836a74cb325d9cd1d6174a7932a2bf6f3664b5849eededc69",
+      "source": "results/final_broad_benchmark/20260729-v1/report/REPORT.md",
+      "source_sha256": "f74f85f43c3d18c836a74cb325d9cd1d6174a7932a2bf6f3664b5849eededc69"
+    },
+    {
+      "path": "benchmark/SEALED_REPORT_SHA256SUMS.txt",
+      "role": "sealed benchmark evidence",
+      "bytes": 2399,
+      "sha256": "f2c05574d9c89a5e6fbc2cd94ab313e533a1315cd813739fa80fd0f38df8274a",
+      "source": "docs/benchmarks/final_broad_20260730/SEALED_REPORT_SHA256SUMS.txt",
+      "source_sha256": "f2c05574d9c89a5e6fbc2cd94ab313e533a1315cd813739fa80fd0f38df8274a"
+    },
+    {
+      "path": "benchmark/availability.csv",
+      "role": "sealed benchmark evidence",
+      "bytes": 1081,
+      "sha256": "6dc0633d6c3512638754c73dabfa49603abdc1d51de36a3cc9f529332d1497de",
+      "source": "docs/benchmarks/final_broad_20260730/availability.csv",
+      "source_sha256": "6dc0633d6c3512638754c73dabfa49603abdc1d51de36a3cc9f529332d1497de"
+    },
+    {
+      "path": "benchmark/edge_systems.csv",
+      "role": "sealed benchmark evidence",
+      "bytes": 679,
+      "sha256": "8ff11a3d57e0af3ae4836a85a56cf6bcafd62801d5c851b8178918bc4e67912f",
+      "source": "docs/benchmarks/final_broad_20260730/edge_systems.csv",
+      "source_sha256": "8ff11a3d57e0af3ae4836a85a56cf6bcafd62801d5c851b8178918bc4e67912f"
+    },
+    {
+      "path": "benchmark/examples/final_release_training_examples.audit.json",
+      "role": "independent release-example audit",
+      "bytes": 7534,
+      "sha256": "9f2869c905733a125a42128726acbb55f6f0aeeb7d8a9f40ea254f6d49e9f79c",
+      "source": "docs/benchmarks/examples/final_release_training_examples.audit.json",
+      "source_sha256": "9f2869c905733a125a42128726acbb55f6f0aeeb7d8a9f40ea254f6d49e9f79c",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/examples/final_release_training_examples.json",
+      "role": "bounded training examples and per-model outputs",
+      "bytes": 101271,
+      "sha256": "97d292125709277a5023afa012a6bdaa61d1effc3ea58633d95188f07d69831a",
+      "source": "docs/benchmarks/examples/final_release_training_examples.json",
+      "source_sha256": "97d292125709277a5023afa012a6bdaa61d1effc3ea58633d95188f07d69831a",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/figures/00_report_overview.png",
+      "role": "benchmark figure",
+      "bytes": 295438,
+      "sha256": "10c458787ad0cc19745bde47a3c2b94e229cff00d92a24c6a128d05e0a72b4e3",
+      "source": "docs/assets/final_broad_benchmark/00_report_overview.png",
+      "source_sha256": "10c458787ad0cc19745bde47a3c2b94e229cff00d92a24c6a128d05e0a72b4e3"
+    },
+    {
+      "path": "benchmark/figures/01_quality_macro_micro.png",
+      "role": "benchmark figure",
+      "bytes": 159292,
+      "sha256": "c7c8c42a69dd9eaa42c5805656c051e3fa3fd2e9f1dc3a737c463f77dd0010ce",
+      "source": "docs/assets/final_broad_benchmark/01_quality_macro_micro.png",
+      "source_sha256": "c7c8c42a69dd9eaa42c5805656c051e3fa3fd2e9f1dc3a737c463f77dd0010ce"
+    },
+    {
+      "path": "benchmark/figures/02_cuda_latency_cold.png",
+      "role": "benchmark figure",
+      "bytes": 192134,
+      "sha256": "ef7cf15fe1b980261f046c6b810f7bac715415407ec259ee1d0f32728e400409",
+      "source": "docs/assets/final_broad_benchmark/02_cuda_latency_cold.png",
+      "source_sha256": "ef7cf15fe1b980261f046c6b810f7bac715415407ec259ee1d0f32728e400409"
+    },
+    {
+      "path": "benchmark/figures/03_cuda_memory_telemetry.png",
+      "role": "benchmark figure",
+      "bytes": 264045,
+      "sha256": "5ecbfd18aa67b453bd77c6eadf84abe3bdfcf5cba1469111a1c6053605305538",
+      "source": "docs/assets/final_broad_benchmark/03_cuda_memory_telemetry.png",
+      "source_sha256": "5ecbfd18aa67b453bd77c6eadf84abe3bdfcf5cba1469111a1c6053605305538"
+    },
+    {
+      "path": "benchmark/figures/04_edge_x86_unoq.png",
+      "role": "benchmark figure",
+      "bytes": 171643,
+      "sha256": "520518e678b7e7f8e35680d84e254c3a630ede66b9eede5ed72efc73b5c0cc5a",
+      "source": "docs/assets/final_broad_benchmark/04_edge_x86_unoq.png",
+      "source_sha256": "520518e678b7e7f8e35680d84e254c3a630ede66b9eede5ed72efc73b5c0cc5a"
+    },
+    {
+      "path": "benchmark/figures/05_pareto_quality_latency_memory.png",
+      "role": "benchmark figure",
+      "bytes": 182234,
+      "sha256": "52884ce31ecf4a309e2af8401fc9a8ec498601aee38f0ff040dacb74fd7d7442",
+      "source": "docs/assets/final_broad_benchmark/05_pareto_quality_latency_memory.png",
+      "source_sha256": "52884ce31ecf4a309e2af8401fc9a8ec498601aee38f0ff040dacb74fd7d7442"
+    },
+    {
+      "path": "benchmark/figures/06_prompt_generation_diagnostic.png",
+      "role": "benchmark figure",
+      "bytes": 180996,
+      "sha256": "0bbd9f72b151d88b0913f72a36845042bb018930fc51d08a941e88acbd1dc500",
+      "source": "docs/assets/final_broad_benchmark/06_prompt_generation_diagnostic.png",
+      "source_sha256": "0bbd9f72b151d88b0913f72a36845042bb018930fc51d08a941e88acbd1dc500"
+    },
+    {
+      "path": "benchmark/figures/07_availability_missingness.png",
+      "role": "benchmark figure",
+      "bytes": 246078,
+      "sha256": "f6ac419ac13e29a59ebf93fb1cce7c3cd783ba26f72b9387b84aa3110ec2d77e",
+      "source": "docs/assets/final_broad_benchmark/07_availability_missingness.png",
+      "source_sha256": "f6ac419ac13e29a59ebf93fb1cce7c3cd783ba26f72b9387b84aa3110ec2d77e"
+    },
+    {
+      "path": "benchmark/figures/08_depth_quality_latency_scaling.json",
+      "role": "depth chart machine-readable analysis",
+      "bytes": 2819,
+      "sha256": "9f05bccc9d8e0b6a62ab2f2d89bdc6e9007c4abaaac464dd5e8b1a492ef204de",
+      "source": "docs/assets/final_broad_benchmark/08_depth_quality_latency_scaling.json",
+      "source_sha256": "9f05bccc9d8e0b6a62ab2f2d89bdc6e9007c4abaaac464dd5e8b1a492ef204de",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/figures/08_depth_quality_latency_scaling.png",
+      "role": "benchmark figure",
+      "bytes": 256039,
+      "sha256": "164c6269fe1aed00733366d0f88b31494e6c1f4d9d7c975f6d36cc1254336e24",
+      "source": "docs/assets/final_broad_benchmark/08_depth_quality_latency_scaling.png",
+      "source_sha256": "164c6269fe1aed00733366d0f88b31494e6c1f4d9d7c975f6d36cc1254336e24"
+    },
+    {
+      "path": "benchmark/final4l_aggregate.json",
+      "role": "three-seed aggregate",
+      "bytes": 10882,
+      "sha256": "0bae347bb54f8089a5fa5450f8366b5c56eb3e598beaf9a87f4385363a402bcb",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/aggregate.json",
+      "source_sha256": "02d66036227403c9713e7c1f364f3444dfe0f17ad7b68785a8bee4adc482e2eb",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/independent_audit.json",
+      "role": "sealed benchmark evidence",
+      "bytes": 2838,
+      "sha256": "613517f2bea2313592a3ce8955afd9d5f365784f3a875a8f7057b6697fee8da9",
+      "source": "docs/benchmarks/final_broad_20260730/independent_audit.json",
+      "source_sha256": "613517f2bea2313592a3ce8955afd9d5f365784f3a875a8f7057b6697fee8da9",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/quality_matrix.csv",
+      "role": "sealed benchmark evidence",
+      "bytes": 3144,
+      "sha256": "c6e316f7081e2a6dcda1ec4e95b57cdcc357ae49ed8b3f5a876c5b51e0df722f",
+      "source": "docs/benchmarks/final_broad_20260730/quality_matrix.csv",
+      "source_sha256": "c6e316f7081e2a6dcda1ec4e95b57cdcc357ae49ed8b3f5a876c5b51e0df722f"
+    },
+    {
+      "path": "benchmark/seed_reports/seed41.json",
+      "role": "seed-41 frozen report",
+      "bytes": 115793,
+      "sha256": "c1bd379680abcf50b47b7d23e4aafbc8b5e7f40a0b0e9700bde21a8ce49af803",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/report.json",
+      "source_sha256": "ec5314140fff0bdd46e87ee00ad67bee7e61d82c7cfa34add1510dd7d5bdb3c0",
+      "normalization": "project-root paths made repository-relative"
+    },
+    {
+      "path": "benchmark/seed_reports/seed42.json",
+      "role": "seed-42 frozen report",
+      "bytes": 115780,
+      "sha256": "a30e38433d008db4aa7e5fbfd477ab80a0daf50e970f8e7b04397efc1a47843a",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/report.json",
+      "source_sha256": "e5c45a7dc41bebf4550da7c5763d0759c6d0922da9efda4048564c11c6d2f3af",
+      "normalization": "project-root paths made repository-relative"
+    },
+    {
+      "path": "benchmark/seed_reports/seed43.json",
+      "role": "seed-43 frozen report",
+      "bytes": 115985,
+      "sha256": "96466290d09d27b8bc044a9f9a95765ce12b4d7b02dfb0123e436e7535623353",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/report.json",
+      "source_sha256": "e05bc2146d720706780fc45a1fb05911d5c2926caa0bcb12ffead946028eef0d",
+      "normalization": "project-root paths made repository-relative"
+    },
+    {
+      "path": "benchmark/summary.json",
+      "role": "sealed benchmark evidence",
+      "bytes": 5765,
+      "sha256": "0f7002222e3757052ad9f19f95b5e7fc86f119bd7e7e16c60a018d3560f76e09",
+      "source": "docs/benchmarks/final_broad_20260730/summary.json",
+      "source_sha256": "0f7002222e3757052ad9f19f95b5e7fc86f119bd7e7e16c60a018d3560f76e09",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/unoq_lineage/01_all_models_latency_memory.png",
+      "role": "physical UNO Q lineage figure",
+      "bytes": 285503,
+      "sha256": "33a50de3de92c958978a979ceba165f491a11b9c3509aa903f794c4baf71ee97",
+      "source": "docs/assets/unoq_lineage_matrix/01_all_models_latency_memory.png",
+      "source_sha256": "33a50de3de92c958978a979ceba165f491a11b9c3509aa903f794c4baf71ee97"
+    },
+    {
+      "path": "benchmark/unoq_lineage/02_layer_reduction_efficiency.png",
+      "role": "physical UNO Q lineage figure",
+      "bytes": 211761,
+      "sha256": "38c54566de25cad0b8c34389736f7f42f73e2d96757901ecd570804238598067",
+      "source": "docs/assets/unoq_lineage_matrix/02_layer_reduction_efficiency.png",
+      "source_sha256": "38c54566de25cad0b8c34389736f7f42f73e2d96757901ecd570804238598067"
+    },
+    {
+      "path": "benchmark/unoq_lineage/03_vocab_embedding_reduction.png",
+      "role": "physical UNO Q lineage figure",
+      "bytes": 201019,
+      "sha256": "9265bfc1e41b0777022aee7bb862979908d5e722f7e01baf40fe87a1fd8f00f4",
+      "source": "docs/assets/unoq_lineage_matrix/03_vocab_embedding_reduction.png",
+      "source_sha256": "9265bfc1e41b0777022aee7bb862979908d5e722f7e01baf40fe87a1fd8f00f4"
+    },
+    {
+      "path": "benchmark/unoq_lineage/REPORT.md",
+      "role": "physical UNO Q lineage narrative",
+      "bytes": 6664,
+      "sha256": "dc09c9c12c0fd846619c024bb4a71007241d031699288f9311d4ea34fa18249a",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "benchmark/unoq_lineage/all_models.csv",
+      "role": "physical UNO Q all-model table",
+      "bytes": 4178,
+      "sha256": "d01079b046942aab1dfe6fccf973b43a4b054781ee5b47ee0033f4e6b5eb024c",
+      "source": "results/unoq_lineage_matrix/20260731-v1/analysis/all_models.csv",
+      "source_sha256": "d01079b046942aab1dfe6fccf973b43a4b054781ee5b47ee0033f4e6b5eb024c"
+    },
+    {
+      "path": "benchmark/unoq_lineage/analysis.json",
+      "role": "physical UNO Q lineage analysis",
+      "bytes": 13963,
+      "sha256": "c899a19e4433e3a40547a11cfcfc3b0a7b6f00c436aa8c1d742a5dc0399bf649",
+      "source": "results/unoq_lineage_matrix/20260731-v1/analysis/analysis.json",
+      "source_sha256": "c899a19e4433e3a40547a11cfcfc3b0a7b6f00c436aa8c1d742a5dc0399bf649",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/unoq_lineage/chart_inputs.json",
+      "role": "physical UNO Q chart inputs",
+      "bytes": 11443,
+      "sha256": "3f204fcc159824a43a3b41e7b1c08ea661e6337f4277646095cca75000972050",
+      "source": "docs/assets/unoq_lineage_matrix/chart_inputs.json",
+      "source_sha256": "3f204fcc159824a43a3b41e7b1c08ea661e6337f4277646095cca75000972050",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/unoq_lineage/manifest.json",
+      "role": "physical UNO Q model/runtime manifest",
+      "bytes": 6853,
+      "sha256": "4c74bf715c38d4577e939bf987f5e9f3ce93bd10a64f1999657cb3e93302378c",
+      "source": "results/unoq_lineage_matrix/20260731-v1/manifest.json",
+      "source_sha256": "4c74bf715c38d4577e939bf987f5e9f3ce93bd10a64f1999657cb3e93302378c",
+      "normalization": "none"
+    },
+    {
+      "path": "benchmark/x86_cuda_systems.csv",
+      "role": "sealed benchmark evidence",
+      "bytes": 2939,
+      "sha256": "11321452290bc53da5ba371d2f2524590d4abd91d981ad0f89c8708752e2a47e",
+      "source": "docs/benchmarks/final_broad_20260730/x86_cuda_systems.csv",
+      "source_sha256": "11321452290bc53da5ba371d2f2524590d4abd91d981ad0f89c8708752e2a47e"
+    },
+    {
+      "path": "chat_template.jinja",
+      "role": "seed-41 Transformers checkpoint",
+      "bytes": 6669,
+      "sha256": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/checkpoint/chat_template.jinja",
+      "source_sha256": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978"
+    },
+    {
+      "path": "classify.py",
+      "role": "self-contained Transformers CLI",
+      "bytes": 8070,
+      "sha256": "1c09956cc5d3553eed0b5f64c20c81064df4373ccfaf4fec26929b8f4819773a",
+      "source": "scripts/hf_standalone4l_classify.py",
+      "source_sha256": "1c09956cc5d3553eed0b5f64c20c81064df4373ccfaf4fec26929b8f4819773a"
+    },
+    {
+      "path": "config.json",
+      "role": "seed-41 Transformers checkpoint",
+      "bytes": 3380,
+      "sha256": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/checkpoint/config.json",
+      "source_sha256": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0"
+    },
+    {
+      "path": "edge/README.md",
+      "role": "UNO Q deployment guide",
+      "bytes": 9079,
+      "sha256": "fb03e2e2f2ae1452f634f70330ead9d9d17ce0a643473081c880bcfa6fac4668",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "edge/benchmark/A53_SELECTION_DECISION.md",
+      "role": "generic-vs-A53 runtime selection decision",
+      "bytes": 3765,
+      "sha256": "b3bd314d6207b4e4d6fe9e3ec348a8a3e2caa3510296b0e0651382ca5714e034",
+      "source": "results/standalone4l_edge/20260730-phase4b-a53-paired-unoq-v1/DECISION.md",
+      "source_sha256": "b3bd314d6207b4e4d6fe9e3ec348a8a3e2caa3510296b0e0651382ca5714e034"
+    },
+    {
+      "path": "edge/benchmark/a53_analysis.json",
+      "role": "preregistered generic-vs-A53 gate analysis",
+      "bytes": 5571,
+      "sha256": "d5023e573e344885b643e45fa9b6de52180c2ee09f2e857c420c41b74fda37d6",
+      "source": "results/standalone4l_edge/20260730-phase4b-a53-paired-unoq-v1/analysis/analysis.json",
+      "source_sha256": "f619bd86f14fc1706fa0c0d107e521b5517264a53d769b67e35999fa6422b6fb",
+      "normalization": "project-root paths made repository-relative"
+    },
+    {
+      "path": "edge/benchmark/a53_audit.json",
+      "role": "independent generic-vs-A53 audit",
+      "bytes": 3223,
+      "sha256": "82bef36a79a6348428ad04a2fbc816e2ede3d8c97bfb56dcb649cf3310c83a4f",
+      "source": "results/standalone4l_edge/20260730-phase4b-a53-paired-unoq-v1/analysis/AUDIT.json",
+      "source_sha256": "82bef36a79a6348428ad04a2fbc816e2ede3d8c97bfb56dcb649cf3310c83a4f",
+      "normalization": "none"
+    },
+    {
+      "path": "edge/benchmark/execution_context.json",
+      "role": "runtime selection execution context",
+      "bytes": 1418,
+      "sha256": "ab647cb7e10c63c97a7e9ad45edd4f05996463ef84b09d1835ed445f46f80283",
+      "source": "results/standalone4l_edge/20260730-phase4b-a53-paired-unoq-v1/EXECUTION_CONTEXT.json",
+      "source_sha256": "ab647cb7e10c63c97a7e9ad45edd4f05996463ef84b09d1835ed445f46f80283",
+      "normalization": "none"
+    },
+    {
+      "path": "edge/benchmark/generic_vs_a53_unoq.png",
+      "role": "raw-driven generic-vs-A53 comparison graph",
+      "bytes": 253732,
+      "sha256": "d06a0858634fab01cc43f29c8774e161f4943f8282fb512719942737e4e8c22c",
+      "source": "results/standalone4l_edge/20260730-phase4b-a53-paired-unoq-v1/analysis/generic_vs_a53_unoq.png",
+      "source_sha256": "d06a0858634fab01cc43f29c8774e161f4943f8282fb512719942737e4e8c22c"
+    },
+    {
+      "path": "edge/classify_short.py",
+      "role": "short-text Q8 inference helper",
+      "bytes": 5149,
+      "sha256": "61f11a4b64586763424a918c0cbccecfeecf27e632d0a2c50e209d8fe893d38b",
+      "source": "scripts/qwen35_standalone4l_q8_short_inference_v1.py",
+      "source_sha256": "61f11a4b64586763424a918c0cbccecfeecf27e632d0a2c50e209d8fe893d38b"
+    },
+    {
+      "path": "edge/qwen3.5-0.8b-standalone4l-joint-q8_0.gguf",
+      "role": "sealed Q8 GGUF",
+      "bytes": 228999360,
+      "sha256": "acc07b4fdd8260147b3c6cb7c7104513176bcb72c88f5277feaa25fc9080f0b3",
+      "source": "results/standalone4l_edge/20260728-phase2c-quant-ladder-v1/candidates/qwen3.5-0.8b-standalone4l-joint-q8_0.gguf",
+      "source_sha256": "acc07b4fdd8260147b3c6cb7c7104513176bcb72c88f5277feaa25fc9080f0b3"
+    },
+    {
+      "path": "edge/qwen3.5-0.8b-standalone4l-q8-arm64-runtime-v3.tar.gz",
+      "role": "sealed ARM64 runtime package",
+      "bytes": 222663144,
+      "sha256": "daf5d051c816a3aef94713e83fb532f4bd23340d3e8714818696695f9ccd26cc",
+      "source": "results/standalone4l_edge/20260729-phase3a-aarch64-q8-runtime-v3/qwen3.5-0.8b-standalone4l-q8-arm64-runtime-v3.tar.gz",
+      "source_sha256": "daf5d051c816a3aef94713e83fb532f4bd23340d3e8714818696695f9ccd26cc"
+    },
+    {
+      "path": "edge/runtime_manifest.json",
+      "role": "ARM64 package manifest",
+      "bytes": 8363,
+      "sha256": "2f91f9359efbfef94721beb8fe29b075fa04d923dd9ba829e6e75d057f7619a2",
+      "source": "results/standalone4l_edge/20260729-phase3a-aarch64-q8-runtime-v3/manifest.json",
+      "source_sha256": "2f91f9359efbfef94721beb8fe29b075fa04d923dd9ba829e6e75d057f7619a2"
+    },
+    {
+      "path": "edge/technique_bias.json",
+      "role": "required external classifier bias",
+      "bytes": 1307,
+      "sha256": "e499e4ae081129d04bcd8e9790f4aa26014436b8f0d916805798f2d638bcf1bf",
+      "source": "results/standalone4l_edge/20260728-phase2a-x86-f16-no-ui-v3/packed/technique_bias.json",
+      "source_sha256": "e499e4ae081129d04bcd8e9790f4aa26014436b8f0d916805798f2d638bcf1bf"
+    },
+    {
+      "path": "edge/tokenizer/tokenizer.json",
+      "role": "Q8 window tokenizer",
+      "bytes": 9224067,
+      "sha256": "2106c29a0c7de1308e536b9f8a01833b9ff9bd0b34a526019f478bc53b6da81d",
+      "source": "results/layer_shrink_v6/20260728-v6-r23-standalone4l-kd-seed41-v1/student-4l-final/tokenizer.json",
+      "source_sha256": "2106c29a0c7de1308e536b9f8a01833b9ff9bd0b34a526019f478bc53b6da81d"
+    },
+    {
+      "path": "edge/tokenizer/tokenizer_config.json",
+      "role": "Q8 window tokenizer",
+      "bytes": 1314,
+      "sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+      "source": "results/layer_shrink_v6/20260728-v6-r23-standalone4l-kd-seed41-v1/student-4l-final/tokenizer_config.json",
+      "source_sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35"
+    },
+    {
+      "path": "edge/unoq_acceptance_audit.json",
+      "role": "UNO Q acceptance audit",
+      "bytes": 3461,
+      "sha256": "bc5c910c838f715cbea18d736832e2eafb4a43fd99cf2d69ab490b9083b3608c",
+      "source": "results/standalone4l_edge/20260729-phase3b-unoq-device-acceptance-v1/audit.json",
+      "source_sha256": "bc5c910c838f715cbea18d736832e2eafb4a43fd99cf2d69ab490b9083b3608c"
+    },
+    {
+      "path": "edge/unoq_acceptance_report.json",
+      "role": "UNO Q acceptance report",
+      "bytes": 7467,
+      "sha256": "ee0c9c2996ea65f5b18d602b66bdc9ac2e0b160aeb52faa54d255c24446217b1",
+      "source": "results/standalone4l_edge/20260729-phase3b-unoq-device-acceptance-v1/acceptance_report.json",
+      "source_sha256": "ee0c9c2996ea65f5b18d602b66bdc9ac2e0b160aeb52faa54d255c24446217b1"
+    },
+    {
+      "path": "labels.json",
+      "role": "fixed label order",
+      "bytes": 891,
+      "sha256": "946fed4fe4c3d320fd113ec8e5776b10f2707b936f857341bb5443d7a9038248",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "model.safetensors",
+      "role": "seed-41 Transformers checkpoint",
+      "bytes": 421812688,
+      "sha256": "0352da6e4717a2e6f3a9d643d034be2cb1c39632d1bce0ced339ddb62acedb37",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/checkpoint/model.safetensors",
+      "source_sha256": "0352da6e4717a2e6f3a9d643d034be2cb1c39632d1bce0ced339ddb62acedb37"
+    },
+    {
+      "path": "requirements.txt",
+      "role": "inference dependency lock",
+      "bytes": 54,
+      "sha256": "2994886af208a0120c051745f9c14036e6f2caae8c4af863e5965d5a5bd68fdf",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "seeds/seed42/chat_template.jinja",
+      "role": "seed-42 Transformers checkpoint",
+      "bytes": 6669,
+      "sha256": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/checkpoint/chat_template.jinja",
+      "source_sha256": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978"
+    },
+    {
+      "path": "seeds/seed42/config.json",
+      "role": "seed-42 Transformers checkpoint",
+      "bytes": 3380,
+      "sha256": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/checkpoint/config.json",
+      "source_sha256": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0"
+    },
+    {
+      "path": "seeds/seed42/model.safetensors",
+      "role": "seed-42 Transformers checkpoint",
+      "bytes": 421812688,
+      "sha256": "2db5f4be391d9dee64458cb5865530f39747019e7a219443b5f7850befbce697",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/checkpoint/model.safetensors",
+      "source_sha256": "2db5f4be391d9dee64458cb5865530f39747019e7a219443b5f7850befbce697"
+    },
+    {
+      "path": "seeds/seed42/tokenizer.json",
+      "role": "seed-42 Transformers checkpoint",
+      "bytes": 9223900,
+      "sha256": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/checkpoint/tokenizer.json",
+      "source_sha256": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8"
+    },
+    {
+      "path": "seeds/seed42/tokenizer_config.json",
+      "role": "seed-42 Transformers checkpoint",
+      "bytes": 1314,
+      "sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed42/checkpoint/tokenizer_config.json",
+      "source_sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35"
+    },
+    {
+      "path": "seeds/seed43/chat_template.jinja",
+      "role": "seed-43 Transformers checkpoint",
+      "bytes": 6669,
+      "sha256": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/checkpoint/chat_template.jinja",
+      "source_sha256": "04b007131663760bf3e581e5a953be77044014e87efe1d2a6ca4b72ec0eac978"
+    },
+    {
+      "path": "seeds/seed43/config.json",
+      "role": "seed-43 Transformers checkpoint",
+      "bytes": 3380,
+      "sha256": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/checkpoint/config.json",
+      "source_sha256": "9f04dfbd7e1696cd3df2ccbe194f5f155efe5baefd1a0b615851f51bf46691a0"
+    },
+    {
+      "path": "seeds/seed43/model.safetensors",
+      "role": "seed-43 Transformers checkpoint",
+      "bytes": 421812688,
+      "sha256": "81a56d497df758e8a292eea528438cfc4d5a847cd37d3a7e1107fefa7c500640",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/checkpoint/model.safetensors",
+      "source_sha256": "81a56d497df758e8a292eea528438cfc4d5a847cd37d3a7e1107fefa7c500640"
+    },
+    {
+      "path": "seeds/seed43/tokenizer.json",
+      "role": "seed-43 Transformers checkpoint",
+      "bytes": 9223900,
+      "sha256": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/checkpoint/tokenizer.json",
+      "source_sha256": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8"
+    },
+    {
+      "path": "seeds/seed43/tokenizer_config.json",
+      "role": "seed-43 Transformers checkpoint",
+      "bytes": 1314,
+      "sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed43/checkpoint/tokenizer_config.json",
+      "source_sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35"
+    },
+    {
+      "path": "thresholds.json",
+      "role": "seed thresholds and aggregate metrics",
+      "bytes": 2631,
+      "sha256": "737c4e145a5b51660c4c45a8acea4c32219cbbbc0706abe235e36b2ad430f17d",
+      "source": "generated",
+      "source_sha256": null
+    },
+    {
+      "path": "tokenizer.json",
+      "role": "seed-41 Transformers checkpoint",
+      "bytes": 9223900,
+      "sha256": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/checkpoint/tokenizer.json",
+      "source_sha256": "dd2b27bbd4f5f650c7200300013ef03ee01efe620b128343163521bf04806fc8"
+    },
+    {
+      "path": "tokenizer_config.json",
+      "role": "seed-41 Transformers checkpoint",
+      "bytes": 1314,
+      "sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35",
+      "source": "results/final_broad_benchmark/20260729-v1/trainable/qwen35-standalone4l-commonhead/seed41/checkpoint/tokenizer_config.json",
+      "source_sha256": "2215318fe27878ec67e772931bb5f40a98658348d33f2672a575f766a2190d35"
+    }
+  ],
+  "claim_boundary": {
+    "opened_public_human_gold": true,
+    "test_articles": 55,
+    "three_seed_sample_sd_not_ci": true,
+    "q8_different_head_lineage": true,
+    "task3_private_or_final_used": false,
+    "mac_used": false,
+    "recommended_edge_runtime": "generic-armv8a-v3",
+    "a53_candidate_promoted": false
+  }
+}

models/semeval-propaganda/requirements.txt

@@ -0,0 +1,3 @@
+torch>=2.4
+transformers==5.13.0
+huggingface_hub>=0.34

models/semeval-propaganda/seeds/seed42/chat_template.jinja

@@ -0,0 +1,120 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- else %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- 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 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 }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+{%- endmacro %}
+{%- if tools is defined and tools is iterable and tools | length > 0 %}
+    {{- '<|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' and messages[0].content | trim %}
+        {%- set content = render_content(messages[0].content, false) %}
+        {{- '\n\n' + content.lstrip('\n') }}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + render_content(messages[0].content, false) + '<|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) %}
+        {%- 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 %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true) %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
+            {%- 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 %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- set content = content.rstrip('\n') %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- 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 %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n<think>\n' }}
+{%- endif %}

models/semeval-propaganda/seeds/seed42/config.json

@@ -0,0 +1,122 @@
+{
+  "architectures": [
+    "Qwen3_5TextForSequenceClassification"
+  ],
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "attn_output_gate": true,
+  "bos_token_id": null,
+  "dtype": "bfloat16",
+  "eos_token_id": 127967,
+  "full_attention_interval": 4,
+  "head_dim": 256,
+  "hidden_act": "silu",
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "Appeal_to_Authority",
+    "1": "Appeal_to_fear-prejudice",
+    "2": "Bandwagon,Reductio_ad_hitlerum",
+    "3": "Black-and-White_Fallacy",
+    "4": "Causal_Oversimplification",
+    "5": "Doubt",
+    "6": "Exaggeration,Minimisation",
+    "7": "Flag-Waving",
+    "8": "Loaded_Language",
+    "9": "Name_Calling,Labeling",
+    "10": "Repetition",
+    "11": "Slogans",
+    "12": "Thought-terminating_Cliches",
+    "13": "Whataboutism,Straw_Men,Red_Herring"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3584,
+  "label2id": {
+    "Appeal_to_Authority": 0,
+    "Appeal_to_fear-prejudice": 1,
+    "Bandwagon,Reductio_ad_hitlerum": 2,
+    "Black-and-White_Fallacy": 3,
+    "Causal_Oversimplification": 4,
+    "Doubt": 5,
+    "Exaggeration,Minimisation": 6,
+    "Flag-Waving": 7,
+    "Loaded_Language": 8,
+    "Name_Calling,Labeling": 9,
+    "Repetition": 10,
+    "Slogans": 11,
+    "Thought-terminating_Cliches": 12,
+    "Whataboutism,Straw_Men,Red_Herring": 13
+  },
+  "layer_types": [
+    "linear_attention",
+    "full_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": 4,
+  "num_key_value_heads": 2,
+  "pad_token_id": 127967,
+  "partial_rotary_factor": 0.25,
+  "phase_v6_map_selection_rank": 1,
+  "phase_v6_map_selection_split": "public_gold_train",
+  "phase_v6_materialized_role": "student6l-r3-final-teacher",
+  "phase_v6_materialized_trainable_state": "results/layer_shrink_v6/20260726-v6-r3-student6l-map013457-kd-seed41-pilot-v2/student-6l-kd-trainable.safetensors",
+  "phase_v6_selected_original_8l_layers": [
+    0,
+    3,
+    4,
+    7
+  ],
+  "phase_v6_selected_source_layers": [
+    0,
+    1,
+    3,
+    4,
+    5,
+    7
+  ],
+  "phase_v6_selected_source_layers_6l": [
+    0,
+    2,
+    3,
+    5
+  ],
+  "phase_v6_source_teacher": "student6l-r3-final",
+  "phase_v6_standalone4l_kd": {
+    "canonical_materialization_dtype": "bfloat16",
+    "canonical_training_state_preservation": true,
+    "epochs": 3,
+    "legacy_float16_checkpoint": "results/layer_shrink_v6/20260728-v6-r23-standalone4l-kd-seed41-v1/student-4l-final",
+    "opened_calibration_used_for_model_selection": false,
+    "seed": 41,
+    "teacher": "results/layer_shrink_v6/20260728-v6-r22-standalone4l-map-probe-seed41-v1/teacher-6l-r3-final"
+  },
+  "problem_type": "multi_label_classification",
+  "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,
+  "transformers_version": "5.13.0",
+  "use_cache": false,
+  "vocab_size": 128000
+}

models/semeval-propaganda/seeds/seed42/model.safetensors

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

models/semeval-propaganda/seeds/seed42/tokenizer_config.json

@@ -0,0 +1,39 @@
+{
+  "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": true,
+  "max_length": 256,
+  "model_max_length": 131072,
+  "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_to_multiple_of": null,
+  "pad_token": "<|endoftext|>",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "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,
+  "stride": 0,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

models/semeval-propaganda/seeds/seed43/chat_template.jinja

@@ -0,0 +1,120 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- else %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- 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 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 }}
+            {%- endif %}
+        {%- endfor %}
+    {%- endif %}
+{%- endmacro %}
+{%- if tools is defined and tools is iterable and tools | length > 0 %}
+    {{- '<|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' and messages[0].content | trim %}
+        {%- set content = render_content(messages[0].content, false) %}
+        {{- '\n\n' + content.lstrip('\n') }}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {{- '<|im_start|>system\n' + render_content(messages[0].content, false) + '<|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) %}
+        {%- 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 %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true) %}
+    {%- if (message.role == "user") or (message.role == "system" and not loop.first) %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is defined and message.reasoning_content is not none %}
+            {%- 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 %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- set content = content.rstrip('\n') %}
+        {%- endif %}
+        {%- if loop.index0 > ns.last_query_index %}
+                {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content.strip('\n') + '\n</think>\n\n' + content.lstrip('\n') }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls is defined and message.tool_calls is not none and message.tool_calls is iterable and message.tool_calls | length > 0 %}
+            {%- 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 %}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n<think>\n' }}
+{%- endif %}