initial release

.gitattributes

@@ -0,0 +1,38 @@
+*.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
+ukisai-banner.png filter=lfs diff=lfs merge=lfs -text
+swift-1.5-planet-demo.mp4 filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,233 @@
+Swift Open License v1.0
+
+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 this document.
+
+"Licensor" shall mean UkisAI.
+
+"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,
+configuration files, and model weights in an unquantized, trainable format.
+
+"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, quantized or otherwise converted model weights,
+and conversions to other media types or file formats.
+
+"Base Model" shall mean the Qwen3.8-27B model, Copyright 2026 Alibaba Cloud,
+made available at https://huggingface.co/Qwen/Qwen3.8-27B, including its
+weights, configuration, tokenizer, and chat template, in any form.
+
+"Base Model License" shall mean the Apache License, Version 2.0, under which
+the Base Model is made available. A copy is distributed with the Work in the
+file LICENSE-APACHE-2.0.
+
+"Swift Contribution" shall mean the modifications to the Base Model authored
+by Licensor, in any form, including without limitation adapted model weights,
+weight deltas, model weights to the extent they differ from the Base Model, and
+any configuration, documentation, and evaluation materials created by Licensor
+and distributed with the Work.
+
+"Work" shall mean the Swift Contribution together with, to the extent of
+Licensor's rights therein, the Derivative Work of the Base Model made available
+by Licensor under this License (as indicated by a copyright notice that is
+included in or attached to the work), in any format made available by Licensor.
+
+"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.
+
+"Commercial Use" shall mean any use of the Work or a Derivative Work for direct
+or indirect commercial advantage or monetary compensation.
+
+"Qualified Non-Profit Organization" shall mean a Legal Entity that is organized
+and operated exclusively for religious, charitable, scientific, testing for
+public safety, literary, or educational purposes, and which is exempt from
+federal income tax under Section 501(c)(3) of the United States Internal
+Revenue Code of 1986, as amended, or any equivalent non-profit or charitable
+organization in a foreign jurisdiction.
+
+"Non-Commercial or Research Purposes" shall mean purposes that do not involve
+any use of the Work or a Derivative Work for Commercial Use.
+
+"Threshold" shall mean gross revenue of one million United States dollars
+(US$1,000,000) or more, measured over the most recently completed fiscal year
+of You together with every Legal Entity that controls, is controlled by, or is
+under common control with You.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, including the Commercial Use limitation set forth in Section 5, 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, including the Commercial Use limitation set forth in Section 5, 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; and
+
+(e) If the copy You distribute contains any portion of the Base Model
+(including merged, quantized, or otherwise converted weights that incorporate
+the Base Model), You must also give recipients a copy of the Base Model License
+and must comply with the Base Model License with respect to the Base Model.
+
+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, and provided that Section
+5 continues to apply to the Swift Contribution contained in any such
+Derivative Works.
+
+5. Commercial Use Limitation.
+
+(a) The rights granted under this License for Commercial Use are conditioned
+upon You or Your Legal Entity not exceeding the Threshold.
+
+(b) Any Commercial Use of the Work or a Derivative Work by a Legal Entity that
+exceeds the Threshold is not licensed under this License.
+
+(c) The Threshold shall not apply to a Qualified Non-Profit Organization's use
+of the Work or a Derivative Work for Non-Commercial or Research Purposes.
+
+(d) A Legal Entity that exceeds the Threshold may obtain a separate written
+license for Commercial Use from Licensor (the "Swift Enterprise License").
+Contact: https://ukisai.com/contact.
+
+6. Base Model Rights. The Work incorporates the Base Model. Nothing in this
+License limits, restricts, conditions, or modifies any rights You have in the
+Base Model under the Base Model License, and the Base Model remains available
+to You from its licensor under the Base Model License. Sections 5 and 12 of
+this License apply solely to the Swift Contribution and to the Work or any
+Derivative Work to the extent it contains, incorporates, or is derived from the
+Swift Contribution.
+
+7. 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.
+
+8. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor (including "UkisAI"
+and "Swift"), except for the reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+9. 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.
+
+10. 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.
+
+11. 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.
+
+12. Termination. This License will terminate automatically and immediately if
+You fail to comply with any of its terms and conditions. Upon termination, You
+must cease all use of the Swift Contribution and of any Work or Derivative
+Works containing it, and delete all copies in Your possession. Termination does
+not affect Your rights in the Base Model under the Base Model License.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: Notice for redistributors (quantizations, conversions, merges).
+
+   Copyright 2026 UkisAI. Swift Contribution licensed under the Swift Open
+   License v1.0 (https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b/blob/main/LICENSE).
+   Derivative of Qwen3.8-27B, Copyright 2026 Alibaba Cloud, Apache License 2.0.

LICENSE-APACHE-2.0

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

NOTICE

@@ -0,0 +1,24 @@
+Swift 1.5 Qwen3.8-27B
+Copyright 2026 UkisAI
+
+UkisAI's contribution (the "Swift Contribution") is licensed under the
+Swift Open License v1.0. See LICENSE.
+
+This model is a Derivative Work of Qwen3.8-27B
+  https://huggingface.co/Qwen/Qwen3.8-27B
+  Copyright 2026 Alibaba Cloud
+  Licensed under the Apache License, Version 2.0. See LICENSE-APACHE-2.0.
+
+Swift 1.5 continues UkisAI's Swift 1.0 model, itself a Qwen3.8-27B
+derivative. The full release incorporates the Qwen3.8-27B Base Model and
+UkisAI's Swift 1.0 and Swift 1.5 contributions.
+
+Changes made by UkisAI (Apache License 2.0, Section 4(b) change notice):
+  - model-*.safetensors, model.safetensors.index.json: the model weights from
+    Swift 1.0 were further adapted by UkisAI using additional post-training
+    methods.
+  - README.md: replaced. LICENSE and NOTICE added.
+  - All other files (config.json, generation_config.json, chat_template.jinja,
+    tokenizer.json, tokenizer_config.json, vocab.json, merges.txt,
+    preprocessor_config.json, video_preprocessor_config.json) are retained from
+    the parent model and remain available under Apache License, Version 2.0.

QUANTIZATION_MANIFEST.json

@@ -0,0 +1,240 @@
+{
+  "status": "VALIDATED",
+  "created_at": "2026-09-21T18:16:33.223816+00:00",
+  "source_repository": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "source_manifest_sha256": "0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae",
+  "source_manifest_note": "SHA-256 of the original pre-publication-redaction export manifest.",
+  "source_weight_shards": 18,
+  "source_weight_bytes": 55563006776,
+  "source_file_bytes": 55586102681,
+  "source_recovery": "The pinned Hub revision was incomplete at conversion time. All 18 original shards and runtime assets were supplied by the verified project BF16 export and checked against the original export manifest; no weights were reconstructed or borrowed.",
+  "quantization": {
+    "mode": "affine",
+    "bits": 4,
+    "group_size": 64
+  },
+  "official_mlx_lm_repository": "https://github.com/ml-explore/mlx-lm",
+  "official_mlx_lm_base_commit": "c69d1288440a0dc4e6401fc417098b07598dccd5",
+  "architecture_patch_sha256": "f6f1d0bdafa45863bfbf93dac0398c481c993ea04fdf38b9bae98c643f89eaec",
+  "packages": {
+    "mlx": "0.32.2",
+    "mlx-cpu": "0.32.2",
+    "mlx-lm": "0.32.0",
+    "transformers": "5.14.1",
+    "huggingface_hub": "1.31.0",
+    "torch": "2.11.0+cpu",
+    "torchvision": "0.26.0+cpu",
+    "safetensors": "0.8.0"
+  },
+  "python": "3.12.3",
+  "platform": "Linux x86_64",
+  "validation_runtime": {
+    "device": "CPU"
+  },
+  "conversion_command": [
+    "mlx_lm.convert",
+    "--hf-path",
+    "<SOURCE_MODEL_DIR>",
+    "--mlx-path",
+    "<OUTPUT_MODEL_DIR>",
+    "--quantize",
+    "--q-mode",
+    "affine",
+    "--q-bits",
+    "4",
+    "--q-group-size",
+    "64"
+  ],
+  "conversion_elapsed_seconds": 120.018799242,
+  "output_weight_shards": 3,
+  "output_weight_bytes": 15826764635,
+  "source_tensors": 1199,
+  "mapped_source_tensors": 1199,
+  "saved_tensors": 2379,
+  "categories": {
+    "text": 851,
+    "MTP": 15,
+    "vision": 333
+  },
+  "quantized_weight_tensors": 590,
+  "original_bf16_tensors": 609,
+  "ignored_tensors": 0,
+  "unexplained_tensors": 0,
+  "validation": {
+    "status": "PASS",
+    "recorded_at": "2026-09-21T18:14:21.887850+00:00",
+    "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+    "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+    "source_shards": 18,
+    "source_shard_bytes": 55563006776,
+    "source_tensors": 1199,
+    "mapped_source_tensors": 1199,
+    "saved_tensors": 2379,
+    "categories": {
+      "text": 851,
+      "MTP": 15,
+      "vision": 333
+    },
+    "ignored_tensors": 0,
+    "unexplained_tensors": 0,
+    "exact_unquantized_tensors": 609,
+    "quantization": {
+      "group_size": 64,
+      "bits": 4,
+      "mode": "affine"
+    },
+    "all_floating_tensors_finite": true,
+    "tokenizer": "Qwen2Tokenizer",
+    "processor": "Qwen3VLProcessor",
+    "assets_sha256": {
+      "generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+      "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+      "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+      "tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+      "tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+      "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+      "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+      "chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041"
+    },
+    "chat_templates": [
+      {
+        "options": {
+          "enable_thinking": false
+        },
+        "rendered": "<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
+      },
+      {
+        "options": {
+          "reasoning_effort": "low"
+        },
+        "rendered": "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+      },
+      {
+        "options": {
+          "reasoning_effort": "xhigh"
+        },
+        "rendered": "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+      }
+    ],
+    "load_seconds": 3.351265648000208,
+    "load_memory_bytes": 15826466152,
+    "process_peak_rss_bytes": 21142360064,
+    "inference_floating_dtype": "float32, CPU runtime only; stored floating tensors remain BF16",
+    "native_bf16_cpu_inference": "Aborted after reproducing incorrect accumulation in the official Linux BF16 quantized matmul. See cpu-quantized-matmul-diagnostic.json.",
+    "generation": {
+      "prompt": "<|im_start|>user\nReply with exactly: Hello from Swift.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n",
+      "text": "Hello from Swift.",
+      "token_ids": [
+        9419,
+        494,
+        22929,
+        13,
+        248046
+      ],
+      "tokens": 5,
+      "tokens_per_second": 0.0797672292904007,
+      "prompt_tokens_per_second": 0.06443886297275572,
+      "elapsed_seconds": 374.00736365800003,
+      "finish_reason": "stop"
+    },
+    "mtp": {
+      "status": "PASS",
+      "shape": [
+        1,
+        1,
+        248320
+      ],
+      "path": "Explicit MTP step with real text hidden states and shared LM head; speculative generation is not integrated"
+    },
+    "vision": {
+      "status": "PASS",
+      "shape": [
+        64,
+        5120
+      ],
+      "grid": [
+        [
+          1,
+          16,
+          16
+        ]
+      ],
+      "path": "Vision encoder only; image/video insertion and multimodal text generation are not implemented"
+    },
+    "total_validation_seconds": 467.15810263900016
+  },
+  "private_repository": "ukisai/Swift-1.5-4bit-MLX",
+  "apple_silicon_verification": {
+    "status": "PASS_MAC_NATIVE_MLX_FORMAT_AND_REAL_METAL_SAMPLES",
+    "platform": "macOS-26.6-arm64-arm-64bit",
+    "machine": "arm64",
+    "mlx": "0.32.2",
+    "mlx_lm": "0.32.0",
+    "device": "Device(gpu, 0)",
+    "quantization": {
+      "group_size": 64,
+      "bits": 4,
+      "mode": "affine"
+    },
+    "all_saved_tensor_headers_validated": 2379,
+    "all_source_parameters_accounted_for": 1199,
+    "strict_complete_parameter_tree": "PASS using unevaluated header fixtures; no fabricated weights saved",
+    "actual_checkpoint_samples": [
+      {
+        "sample": 0,
+        "category": "text",
+        "checkpoint_weight": "language_model.model.layers.0.linear_attn.in_proj_a.weight",
+        "original_shape": [
+          48,
+          5120
+        ],
+        "packed_shape": [
+          48,
+          640
+        ],
+        "native_metal_bf16": "PASS",
+        "metal_fp32": "PASS",
+        "bf16_max_absolute_error": 0.0004401206970214844,
+        "fp32_max_absolute_error": 0.0
+      },
+      {
+        "sample": 1,
+        "category": "vision",
+        "checkpoint_weight": "visual.blocks.0.attn.proj.weight",
+        "original_shape": [
+          1152,
+          1152
+        ],
+        "packed_shape": [
+          1152,
+          144
+        ],
+        "native_metal_bf16": "PASS",
+        "metal_fp32": "PASS",
+        "bf16_max_absolute_error": 0.0002315044403076172,
+        "fp32_max_absolute_error": 0.0
+      },
+      {
+        "sample": 2,
+        "category": "MTP",
+        "checkpoint_weight": "mtp.layers.0.self_attn.k_proj.weight",
+        "original_shape": [
+          1024,
+          5120
+        ],
+        "packed_shape": [
+          1024,
+          640
+        ],
+        "native_metal_bf16": "PASS",
+        "metal_fp32": "PASS",
+        "bf16_max_absolute_error": 0.0009589195251464844,
+        "fp32_max_absolute_error": 0.0
+      }
+    ],
+    "full_model_mac_generation": "NOT_RUN: targeted native Metal format and real-weight component checks only",
+    "peak_mlx_bytes": 4597960,
+    "peak_process_rss_bytes": 360693760
+  }
+}

README.md

@@ -0,0 +1,146 @@
+---
+license: other
+license_name: swift-open-license-1.0
+license_link: https://huggingface.co/ukisai/Swift-1.5-4bit-MLX/blob/main/LICENSE
+base_model: ukisai/Swift-1.5-Qwen3.8-27b
+base_model_relation: quantized
+library_name: mlx
+pipeline_tag: text-generation
+tags:
+  - mlx
+  - quantized
+  - 4-bit
+  - affine
+  - qwen3_8
+---
+
+<div align="center">
+  <a href="https://ukisai.com"><img src="ukisai-banner.png" alt="UkisAI" style="width:100%;max-width:100%;height:auto;display:block;margin-bottom:0.6em;" /></a>
+  <div style="display:flex;justify-content:center;gap:0.6em;margin-bottom:1em;">
+    <a href="https://ukisai.com"><strong>Website</strong></a> &nbsp;&bull;&nbsp;
+    <a href="https://ukisai.com/products/swift"><strong>Learn more</strong></a> &nbsp;&bull;&nbsp;
+    <a href="https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b"><strong>BF16 model</strong></a> &nbsp;&bull;&nbsp;
+    <a href="https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27B-GGUF"><strong>GGUF</strong></a> &nbsp;&bull;&nbsp;
+    <a href="https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27B-GSQ-RCO-GGUF"><strong>GSQ-RCO GGUF</strong></a> &nbsp;&bull;&nbsp;
+    <a href="#evaluation"><strong>Evaluation</strong></a> &nbsp;&bull;&nbsp;
+    <a href="#license-and-access"><strong>Enterprise licensing</strong></a>
+  </div>
+</div>
+
+# Swift 1.5 Qwen3.8-27B — 4-bit MLX
+
+**Apple MLX 4-bit affine quantization.** This is Swift 1.5 in native MLX format,
+converted with the official Apple MLX-LM converter using 4 bits and group size 64.
+Swift 1.5 is UkisAI's reasoning-efficient Qwen3.8-27B derivative, focused on stronger
+long-horizon, agentic and coding performance while using fewer thinking tokens.
+
+Swift 1.5 uses **58.5% fewer thinking tokens** than base Qwen3.8-27B while scoring **0.35% higher**, for a **9.18× speed-up** on several tasks.
+
+## Demo
+
+We gave base Qwen3.8-27B and Swift 1.5 27B the same prompt:
+
+> create a 3d little planet globe where I (player can walk around) and it has all these biomes to explore, the globe doesn't have to be too big, but still fun to go around. It's about a boy scout who is camping and goes around exploring.
+
+<video src="https://huggingface.co/ukisai/Swift-1.5-4bit-MLX/resolve/main/swift-1.5-planet-demo.mp4" controls autoplay muted loop playsinline style="width:100%;height:auto;border-radius:12px;"></video>
+
+Try the game yourself here: [https://ukisai.com/swift-games/27b](https://ukisai.com/swift-games/27b)
+
+Base Qwen3.8-27B took 104.6 minutes to build its game. Swift 1.5 took 11.39 minutes.
+
+## Source and quantization
+
+The conversion used the merged Swift 1.5 BF16 export associated with
+[`ukisai/Swift-1.5-Qwen3.8-27b` revision `00ccd14e006897d28cb0ed5bf26390e60d274251`](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b/tree/00ccd14e006897d28cb0ed5bf26390e60d274251).
+The source repository was subsequently completed with all 18 BF16 shards and runtime
+assets at [revision `5ad04445d2686f525e9fbe5c077e6fa0c7df4200`](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b/tree/5ad04445d2686f525e9fbe5c077e6fa0c7df4200).
+The later complete-revision link does not change the actual conversion provenance.
+
+All 1,199 source tensors are accounted for, including 333 vision and 15 MTP tensors.
+Eligible linear and embedding weights use 4-bit affine storage; 609 remaining tensors
+retain their original BF16 values after the documented layout mapping. All 18 source
+shards and runtime assets were verified by SHA-256. No base Qwen or alternate derived
+checkpoint weights were substituted.
+
+The saved checkpoint contains three weight shards. The original tokenizer, chat
+template, processor/config assets, license and notices are included.
+`QUANTIZATION_MANIFEST.json` records the fixed settings and validation results, while
+`UPLOAD_MANIFEST.json` records release-file checksums.
+
+## Evaluation
+
+See the [Swift 1.5 source model card](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b#evaluation)
+for the source model's evaluations and methodology. Those results were not independently
+re-run on this MLX quantization. No broad accuracy or long-context benchmark was run for
+this release.
+
+## Validation and use
+
+The validation results below are preserved historical build/component evidence,
+not a new full-model Apple run. The approximately 15.83 GB tensor payload
+requires additional runtime/cache and OS memory; do not force it onto a
+16 GiB Mac or raise system limits.
+
+**Install the included MLX-LM architecture patch before loading this model.**
+[`USAGE.md`](USAGE.md) provides the pinned official revision, patch commands and a text
+generation example. The source configuration declares
+`Qwen3_5ForConditionalGeneration` / `qwen3_5`; the patch preserves that configuration
+and the inherited Swift text behavior.
+
+Validation passed on Linux CPU with MLX 0.32.2 and patched MLX-LM 0.32.0: complete
+source hashing, strict mapping and reload, finite floating tensors, exact BF16 remainder
+preservation, tokenizer/chat-template/processor loading, and a short text-generation
+smoke test that returned `Hello from Swift.`.
+
+CPU smoke tests use FP32 floating-point arithmetic with the original packed 4-bit
+tensors. This avoids a reproduced accumulation issue in MLX 0.32.2's Linux BF16
+quantized-matmul path; checkpoint files and stored BF16 values are unchanged. Follow
+the Linux branch in `USAGE.md`.
+
+Apple Silicon checks passed for all 2,379 native tensor headers. Real packed text,
+vision and MTP weight samples passed native BF16 Metal execution and matched the FP32
+reference within BF16 tolerance. These checks verify native Mac MLX compatibility,
+but **full 27B Apple Silicon generation was not tested**.
+
+The vision encoder and an explicit MTP step passed real-weight component checks.
+Integrated image/video chat and speculative generation are not implemented in this
+patch. Component validation does not establish those end-to-end runtime features.
+
+The `compatibility/` directory retains the MLX-LM patch, reproducible instructions,
+source/tensor validation evidence, and the documented runtime limitations. Internal
+project names, machine paths and cloud-instance details have been redacted from the
+current published copies; older commits remain unchanged.
+
+## License and access
+
+Swift 1.5 is a derivative of [Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B)
+(Copyright 2026 Alibaba Cloud, [Apache License 2.0](https://huggingface.co/ukisai/Swift-1.5-4bit-MLX/blob/main/LICENSE-APACHE-2.0)). UkisAI's
+contribution, including the adapted weights, is licensed under the
+**[Swift Open License v1.0](https://huggingface.co/ukisai/Swift-1.5-4bit-MLX/blob/main/LICENSE)**. See [NOTICE](https://huggingface.co/ukisai/Swift-1.5-4bit-MLX/blob/main/NOTICE) for the change notice and
+attribution details.
+
+Personal, research, educational, evaluation and commercial use are free for individuals
+and organizations with gross annual revenue, including affiliates, of up to US$1,000,000.
+Above that threshold, commercial use requires a separate Swift Enterprise License.
+Contact [UkisAI](https://ukisai.com/contact) for terms.
+
+Nothing in the Swift Open License limits rights in Qwen3.8-27B itself under Apache 2.0.
+The accompanying Apple MLX-LM code has a separate [MIT notice](compatibility/MLX-LM-LICENSE).
+
+## Citation
+
+```bibtex
+@misc{swift-1.5-qwen3.8-27b,
+  title  = {Swift 1.5 Qwen3.8-27B},
+  author = {UkisAI},
+  year   = {2026},
+  url    = {https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b}
+}
+```
+
+## Acknowledgements
+
+We acknowledge the [NVIDIA Innovation Lab](https://www.nvidia.com/en-us/data-center/innovation-lab/),
+[Amazon Web Services](https://aws.amazon.com/), and
+[Google Cloud](https://cloud.google.com/) for providing compute credits and
+infrastructure support for Swift's development, training, and evaluation.

UPLOAD_MANIFEST.json

@@ -0,0 +1,333 @@
+{
+  "repository": "ukisai/Swift-1.5-4bit-MLX",
+  "private": true,
+  "source_repository": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "files": [
+    {
+      "path": "LICENSE",
+      "bytes": 13306,
+      "sha256": "1367057bf17041aa1d69286a1400be5f464d2f8b8f54f600088b209eac1850be",
+      "git_blob_sha1": "209a5720f7e4a747e658b49808a933309eeecceb"
+    },
+    {
+      "path": "LICENSE-APACHE-2.0",
+      "bytes": 11544,
+      "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+      "git_blob_sha1": "f938136e3adacfd92be087f6e113b5d6d97f678f"
+    },
+    {
+      "path": "NOTICE",
+      "bytes": 1133,
+      "sha256": "be30f3d464974990e40e9833bc6f356fd89fe16733c6c1a581d97106b8ae741d",
+      "git_blob_sha1": "c4ad1a7188a4191cb5efd0f5109bf6e9ba8caee8"
+    },
+    {
+      "path": "QUANTIZATION_MANIFEST.json",
+      "bytes": 8230,
+      "sha256": "9f061d15042d9368e2c6a406ee20071ba6d78ce8da4c3ca53bfc13f5c2f95dd1",
+      "git_blob_sha1": "9726e2a5a93ee4abe32cb1032a38c01695b056d8"
+    },
+    {
+      "path": "README.md",
+      "bytes": 7084,
+      "sha256": "f9b9dd2366f69000bf70d47e393581a51a3ef69866e702be94259f1cc0261f4c",
+      "git_blob_sha1": "f4c63e395c2b6bf9b473a42dcb260d6d0a1fa834"
+    },
+    {
+      "path": "USAGE.md",
+      "bytes": 4074,
+      "sha256": "2d50b7882228b72dadb7b506580d4e57cc4f8b482f9afd9262c5240da161b53b",
+      "git_blob_sha1": "8037d79a8570d801f9c8f22fd4afa4bf53d1eca8"
+    },
+    {
+      "path": "chat_template.jinja",
+      "bytes": 8952,
+      "sha256": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041",
+      "git_blob_sha1": "c0c686f9c38d70d179fb7b5f5aa7530bc913dda3"
+    },
+    {
+      "path": "compatibility/MLX-LM-LICENSE",
+      "bytes": 1066,
+      "sha256": "ccfab7ccb2ea306f71531c8ca77bb55507606cd90768b1e32b8b52ab5b48cf01",
+      "git_blob_sha1": "98ff47b9ef9d4ac9f1a4bde3db13dd27456c5ea1"
+    },
+    {
+      "path": "compatibility/SOURCE_EXPORT_MANIFEST.json",
+      "bytes": 62808,
+      "sha256": "77dd1e156ac7f0c3f5e241bbbb2a0d721fb0e3513d8dd6870862509a1812275e",
+      "git_blob_sha1": "2c1632f6cf958f5b43169a4dfda3a5e4e813b9b6"
+    },
+    {
+      "path": "compatibility/architecture-compatibility-report.md",
+      "bytes": 2465,
+      "sha256": "39d19fae47331b0e70f661a839c7b320d540985f8ed56b8d2d5f171128d0eaf4",
+      "git_blob_sha1": "a7769aead59da94d0406ec0fe24e65b5dfc1f1de"
+    },
+    {
+      "path": "compatibility/aws-actual-source-structural-results.json",
+      "bytes": 2144,
+      "sha256": "a869d8e7a5048f59089077f37135cdc63ec955ad38738bc1b6bbc6460cc9d7bc",
+      "git_blob_sha1": "dea1d92bcf6cef93a611e19bf034dfc1891467ba"
+    },
+    {
+      "path": "compatibility/aws-source-verification.json",
+      "bytes": 379707,
+      "sha256": "ad944ae15bedaaec80abf9cd5e9e945f478397328cf3145f19517ff96295ad9c",
+      "git_blob_sha1": "c0de55933daec5c6a5f794b9b9a9c4e3bc2bdd7d"
+    },
+    {
+      "path": "compatibility/compatibility-tests-linux.log",
+      "bytes": 99,
+      "sha256": "e8735c26c6801337a00665881341818701e196a0c69ebd90f7702d98535f3179",
+      "git_blob_sha1": "eb3133aba134e5c5d8378aad30409dd4d4afa0d3"
+    },
+    {
+      "path": "compatibility/conversion-command.json",
+      "bytes": 581,
+      "sha256": "94e711a0a931855979a4db1d83a43cd54167f55c829c74e24135c8ad583a7f2b",
+      "git_blob_sha1": "a98ccccdb019212183d29b6374974ce63d1b8050"
+    },
+    {
+      "path": "compatibility/conversion-result.json",
+      "bytes": 689,
+      "sha256": "aa74632f5e0ebe7cfaccb9fd8251ccfd7dbe9d81e9384658e7d313b611acafc7",
+      "git_blob_sha1": "af1aa936ff6f2f2a5986e6d68ff3a748b72ab4da"
+    },
+    {
+      "path": "compatibility/conversion.log",
+      "bytes": 113,
+      "sha256": "927e01909126b96eea5faf9692d99f02fdaf99d1aa61d14d257f3ebdb0afd1a0",
+      "git_blob_sha1": "e933301e9777876e2ccac21fc49ae6a2d4879660"
+    },
+    {
+      "path": "compatibility/cpu-quantized-matmul-diagnostic.json",
+      "bytes": 290,
+      "sha256": "5adefdff0a3efbc54c1abc92cd05aa18e63a39771fe9d6b8972bcd2fea1cf3d3",
+      "git_blob_sha1": "7c452317ed3da7cdd2e6ee9742bd91534ba25c28"
+    },
+    {
+      "path": "compatibility/environment-linux.json",
+      "bytes": 367,
+      "sha256": "efdd012bfc5ad59f07f9dc6e8a6bd67bb992cd9363174171c271ce1ad5ee0cec",
+      "git_blob_sha1": "972ebef9b09def952f0880ec1e60a2f192df1416"
+    },
+    {
+      "path": "compatibility/fixed-affine-test.log",
+      "bytes": 113,
+      "sha256": "a40772b0d08d9f5ce659ee06cd5e5573ec0697073295d819a5dc9b6b1f4302bd",
+      "git_blob_sha1": "7e3746c1857e2e5dc808589514ca56d65d699a11"
+    },
+    {
+      "path": "compatibility/mac-check/checkpoint-headers.json",
+      "bytes": 561445,
+      "sha256": "141b5b6193da63332328bb0f8ad8aac129f51232ab345021dd6f8e4319c5640c",
+      "git_blob_sha1": "20ed71f7444de28ca236be0da3bbd70319ee083c"
+    },
+    {
+      "path": "compatibility/mac-check/config.json",
+      "bytes": 4577,
+      "sha256": "d0bbe7655fdaa589acbdf3739e2f2378d2c7462da05338ad5161c70025540b98",
+      "git_blob_sha1": "9143ac44bb812f357882d503ae90149661616fc1"
+    },
+    {
+      "path": "compatibility/mac-check/model.safetensors.index.json",
+      "bytes": 232537,
+      "sha256": "937800b65e142989cf9f973de5c0f42b0a5ad0659871dd1b67d917d78a195921",
+      "git_blob_sha1": "c943542ddfee76de8e5b0ec14e7fbb86243adbb6"
+    },
+    {
+      "path": "compatibility/mac-check/real-checkpoint-samples.safetensors",
+      "bytes": 3866825,
+      "sha256": "c0e3f757947e7ffdaf96b90eb8e0f0ae72e83b9685d3462b99cd6bf193a2cd5b",
+      "git_blob_sha1": "63afc5a8192c9726d15abe3955846fc0dd9c663a"
+    },
+    {
+      "path": "compatibility/mac-check/samples.json",
+      "bytes": 975,
+      "sha256": "e1d9c0062005f8204d01b52099deaa97dcda44f62bb44c7dba6ffaf8f21c72d7",
+      "git_blob_sha1": "fad93b5e0ebffe6fc096b157f30dd4794f661130"
+    },
+    {
+      "path": "compatibility/mac-compatibility-results.json",
+      "bytes": 1924,
+      "sha256": "45f665d5fb442861c40631b78d1134a888b318e30382d729e7e8a703b94434e2",
+      "git_blob_sha1": "af7ac5d2d3d9ec83b6aae7db3ede7ee61c730303"
+    },
+    {
+      "path": "compatibility/missing-file-recovery-report.md",
+      "bytes": 1046,
+      "sha256": "78fe1768db6b2c95354638cf257bea795389c14b38e4872fb3150df851b9d3ec",
+      "git_blob_sha1": "7c45edf5a824384bea8c9cc4b0dd17ea1bbbb096"
+    },
+    {
+      "path": "compatibility/quant-tensor-mapping-manifest.json",
+      "bytes": 646822,
+      "sha256": "bf99693a9747c476af80b306bf61df546824815fb934cc6bfa1ed150fa967587",
+      "git_blob_sha1": "431b551674ec9669b6f04e3f2b5736f93b1f91ba"
+    },
+    {
+      "path": "compatibility/quant-validation-results.json",
+      "bytes": 3783,
+      "sha256": "ecb99453d4c2b23a818f121d0e2c141328dded5f7fac205af766221ec973ae1d",
+      "git_blob_sha1": "1e6eba8e7d3c785284c79d7603d3db13fef158fe"
+    },
+    {
+      "path": "compatibility/quant-validation.log",
+      "bytes": 4092,
+      "sha256": "8616f0367709a655a549a458c7d337ba326681646de9ce01b61439a270b2b493",
+      "git_blob_sha1": "a3c99e8901464f3149b8f9103604f12ce54182cb"
+    },
+    {
+      "path": "compatibility/requirements-linux.txt",
+      "bytes": 810,
+      "sha256": "89a4ef8054809e043b1e0b1c7b0f41847666a7fd7d263c325311b30be9eb798f",
+      "git_blob_sha1": "513937cb32426c806dd60bb83b54ccb402aa81c0"
+    },
+    {
+      "path": "compatibility/run-compatibility.sh",
+      "bytes": 1059,
+      "sha256": "1024e009047bf97ba4876b8543f4151728b1c85f2c93abf09b73f7811c1a25fb",
+      "git_blob_sha1": "551f80902537a58768a170d53134fc0559e131f1"
+    },
+    {
+      "path": "compatibility/run-conversion.py",
+      "bytes": 2860,
+      "sha256": "6d612bbfd438abdecf393f16143f724c1d37f60903ca8ce46da486c2f3671a41",
+      "git_blob_sha1": "2d7e9a1453a489eeb72aecce44a5171e1fadf27f"
+    },
+    {
+      "path": "compatibility/setup-linux.sh",
+      "bytes": 1734,
+      "sha256": "e253306f08eb86d66e1c15d02733e349a5f82c00abb15ff0656f5ce40acfb775",
+      "git_blob_sha1": "ce35740f29f974529d27fde03ac348dabb83efb9"
+    },
+    {
+      "path": "compatibility/source-file-manifest.csv",
+      "bytes": 4842,
+      "sha256": "f4fec6fc3318813395745f4d68700ebaf13e13bbf9bbdf2b90454faf6bbe721e",
+      "git_blob_sha1": "8275d62522a8da3aafbcfc412f23bfb7abf4739c"
+    },
+    {
+      "path": "compatibility/swift15-mlx-lm.patch",
+      "bytes": 38976,
+      "sha256": "f6f1d0bdafa45863bfbf93dac0398c481c993ea04fdf38b9bae98c643f89eaec",
+      "git_blob_sha1": "b739acc2e3b4cb82f073b7280255bcb898bb2a33"
+    },
+    {
+      "path": "compatibility/unmatched-tensor-analysis.csv",
+      "bytes": 102593,
+      "sha256": "57f6537c39953a2f02971c2ef09ccfb7806f0ea729a6143fa90157e1b961ed05",
+      "git_blob_sha1": "43011b66fcf2b390f1c821a21a80d4e84c84fb19"
+    },
+    {
+      "path": "compatibility/validate-mac-format.py",
+      "bytes": 3576,
+      "sha256": "1f8a04cf27919daad342365b26c86c02ceb7b97b71752bc1cf8ac66309743554",
+      "git_blob_sha1": "2abc61b81ddb01ab0754c76ec15d14bd1670bb28"
+    },
+    {
+      "path": "compatibility/validate-quant.py",
+      "bytes": 8617,
+      "sha256": "484255b5a4a8f71119312ed1ae54b1246f5b4dd70ef698fb32d4cc78c75ffba9",
+      "git_blob_sha1": "a52f8c19a3f91fcb09701758d5664bfa453ed8d7"
+    },
+    {
+      "path": "compatibility/validate_aws_source_linux.py",
+      "bytes": 4798,
+      "sha256": "40c8f2678e7efa1ec6df9acbefc7e0c65def8e707d70d78257b0baff02d9b3d8",
+      "git_blob_sha1": "ca986cbfa2a4ba480ef9e7a0986209fae0256831"
+    },
+    {
+      "path": "compatibility/verify_source_readonly.py",
+      "bytes": 4093,
+      "sha256": "2d02c6d7c7e81f6029faf3f7cfcd43ba6b0ca7d3858dd3e5e6c1a82a5631e765",
+      "git_blob_sha1": "5dee1520d86f961e4ceee7e694fbe3515075c6f2"
+    },
+    {
+      "path": "config.json",
+      "bytes": 4577,
+      "sha256": "d0bbe7655fdaa589acbdf3739e2f2378d2c7462da05338ad5161c70025540b98",
+      "git_blob_sha1": "9143ac44bb812f357882d503ae90149661616fc1"
+    },
+    {
+      "path": "generation_config.json",
+      "bytes": 202,
+      "sha256": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+      "git_blob_sha1": "023756cfadf88e5bf69eefeee3e172f38c448d64"
+    },
+    {
+      "path": "merges.txt",
+      "bytes": 3353259,
+      "sha256": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+      "git_blob_sha1": "a494e019ca1502219fd0128658b979e5f05ae8e8"
+    },
+    {
+      "path": "model-00001-of-00003.safetensors",
+      "bytes": 5328325554,
+      "sha256": "d91b70ca84dff315addeeb8a599dce2beccfec33c7483686ede2e8ff3cc459dc",
+      "git_blob_sha1": "972fbab4cd3302fad7f76024f95765a35c6f0c70"
+    },
+    {
+      "path": "model-00002-of-00003.safetensors",
+      "bytes": 5354185158,
+      "sha256": "eddcff1a6ef0971990f7cd01dba77ab9a8c20d59821bb4cd7e25234fe3809346",
+      "git_blob_sha1": "6ab9eeb3981fe2f243a5c6c9b18efb23ad42f879"
+    },
+    {
+      "path": "model-00003-of-00003.safetensors",
+      "bytes": 5144253923,
+      "sha256": "644cc5322ff706c9608b42ea1ff83e0beb12b828d49b36c468a366f44593b8eb",
+      "git_blob_sha1": "7127bb75e507028d7684e48815cfeb11f74dcaa5"
+    },
+    {
+      "path": "model.safetensors.index.json",
+      "bytes": 232537,
+      "sha256": "937800b65e142989cf9f973de5c0f42b0a5ad0659871dd1b67d917d78a195921",
+      "git_blob_sha1": "c943542ddfee76de8e5b0ec14e7fbb86243adbb6"
+    },
+    {
+      "path": "preprocessor_config.json",
+      "bytes": 390,
+      "sha256": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+      "git_blob_sha1": "2ea84a437d448ff71b08df68fdd949d5cc4ebb64"
+    },
+    {
+      "path": "tokenizer.json",
+      "bytes": 12809320,
+      "sha256": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+      "git_blob_sha1": "b438cf847e527641b288c91745740dfa0f9da294"
+    },
+    {
+      "path": "tokenizer_config.json",
+      "bytes": 17928,
+      "sha256": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+      "git_blob_sha1": "5de744b3fca2129d7186979ae47c06be33903243"
+    },
+    {
+      "path": "ukisai-banner.png",
+      "bytes": 307739,
+      "sha256": "8577252b8b37e331f06f7ddecdf3bfa1c497e164f9eb36d78c37232d1b8492ca",
+      "git_blob_sha1": "efd86f93bda3ac7da9628c5284a07706ce798a5b"
+    },
+    {
+      "path": "video_preprocessor_config.json",
+      "bytes": 385,
+      "sha256": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+      "git_blob_sha1": "3ba673a5ad7d4d13f54155ecd38b2a94a6dac8fe"
+    },
+    {
+      "path": "vocab.json",
+      "bytes": 6722759,
+      "sha256": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+      "git_blob_sha1": "0aa0ce0658d60ac4a5d609f4eadb0e8e43514176"
+    },
+    {
+      "path": "swift-1.5-planet-demo.mp4",
+      "bytes": 4738825,
+      "sha256": "1cda6924169e8b83e5d6d7299baf8329ed1b1a182a481aa0e06344e0f5c00111"
+    }
+  ],
+  "total_bytes_excluding_manifest": 15860955305,
+  "manifest_self_excluded": true
+}

USAGE.md

@@ -0,0 +1,92 @@
+# Load Swift 1.5 with its complete MLX architecture
+
+Use the included patch with the pinned official Apple MLX-LM revision. Unpatched
+text-only Qwen support does not preserve this checkpoint's complete parameter tree.
+
+Use Python 3.12 in a new working directory. Install the HF CLI before using it,
+and pin the complete model revision as well as the MLX-LM source revision.
+This repository is private: after installing the CLI, run `hf auth login`
+interactively if not already signed in with an account that has access.
+
+```bash
+python3.12 -m venv .venv
+source .venv/bin/activate
+python -m pip install 'huggingface_hub==1.31.0'
+SWIFT_MLX_REVISION=d2140379e1fd593002c92fa552b2b37fb6eb1159
+hf download ukisai/Swift-1.5-4bit-MLX --revision "$SWIFT_MLX_REVISION" --local-dir Swift-1.5-4bit-MLX
+hf cache verify ukisai/Swift-1.5-4bit-MLX --revision "$SWIFT_MLX_REVISION" --local-dir Swift-1.5-4bit-MLX --fail-on-missing-files
+git clone https://github.com/ml-explore/mlx-lm.git swift15-mlx-lm
+git -C swift15-mlx-lm checkout --detach c69d1288440a0dc4e6401fc417098b07598dccd5
+git -C swift15-mlx-lm apply --check ../Swift-1.5-4bit-MLX/compatibility/swift15-mlx-lm.patch
+git -C swift15-mlx-lm apply ../Swift-1.5-4bit-MLX/compatibility/swift15-mlx-lm.patch
+```
+
+Stop after any missing-file or checksum failure. The checkpoint contains about
+15.83 GB of tensor data, before runtime, cache and OS overhead. Do not force the
+full model onto a 16 GiB Mac or increase system memory limits. Full-model Apple
+generation remains unverified. The recorded small Metal samples are not a full run.
+
+On Apple Silicon:
+
+```bash
+pip install 'mlx==0.32.2' 'transformers==5.14.1' 'huggingface_hub==1.31.0' pillow
+pip install -e ./swift15-mlx-lm
+```
+
+On Linux CPU (Python 3.12 and glibc 2.35 or newer):
+
+```bash
+pip install 'mlx[cpu]==0.32.2' 'transformers==5.14.1' 'huggingface_hub==1.31.0' pillow
+pip install -e ./swift15-mlx-lm
+```
+
+Text generation:
+
+```python
+import mlx.core as mx
+from mlx_lm import load, generate
+
+model, tokenizer = load("Swift-1.5-4bit-MLX")
+if mx.default_device() == mx.cpu:
+    model.apply(
+        lambda value: value.astype(mx.float32)
+        if mx.issubdtype(value.dtype, mx.floating) else value
+    )
+prompt = tokenizer.apply_chat_template(
+    [{"role": "user", "content": "Say hello."}],
+    tokenize=False,
+    add_generation_prompt=True,
+    enable_thinking=False,
+)
+print(generate(model, tokenizer, prompt=prompt, max_tokens=32))
+```
+
+The Linux CPU branch promotes only in-memory floating parameters to FP32. Packed
+4-bit weights and all files remain unchanged. This avoids the official MLX 0.32.2
+Linux scalar BF16 quantized-matmul accumulation bug reproduced in
+`compatibility/cpu-quantized-matmul-diagnostic.json` (8,192 exact ones summed to
+256 in BF16, versus the correct 8,192 in FP32). The release's CPU generation,
+MTP and vision smoke tests use this FP32 runtime. Apple Silicon inference does
+not use this CPU workaround; full-model Apple Silicon execution was not tested.
+
+The original chat template also accepts `reasoning_effort="low"`, `"medium"`,
+and `"xhigh"`; this release validates the original low and xhigh formats.
+This structural smoke test does not establish long-context or benchmark accuracy.
+
+The patch implements an explicit MTP step (`model.mtp_logits`) and the vision
+encoder (`model.visual`). Their weights are retained and the release validation
+records their component execution. Speculative generation and integrated image/video
+chat are not implemented. Unsupported multimodal generation calls raise an error.
+
+Reproduce conversion only from the complete original Swift BF16 export identified
+in `QUANTIZATION_MANIFEST.json`, after verifying its 18 shards and original assets:
+
+```bash
+mlx_lm.convert --hf-path /path/to/Swift-1.5-BF16 \
+  --mlx-path Swift-1.5-4bit-MLX \
+  --quantize --q-mode affine --q-bits 4 --q-group-size 64
+```
+
+The converter refuses an existing output directory. It uses official MLX-LM lazy
+loading, quantization, sharding, and saving; the patch supplies the complete model
+and strict parameter/asset mapping.

chat_template.jinja

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

compatibility/MLX-LM-LICENSE

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

compatibility/SOURCE_EXPORT_MANIFEST.json

@@ -0,0 +1,1730 @@
+{
+  "model": "Swift-1.5",
+  "publication_redaction": "Internal training names, paths and timestamps were removed from the current published copy. The original manifest SHA-256 remains recorded in QUANTIZATION_MANIFEST.json.",
+  "source_checkpoint": "<INTERNAL_TRAINING_CHECKPOINT_REDACTED>",
+  "parent_model": "<INTERNAL_PARENT_MODEL_REDACTED>",
+  "dtype": "bfloat16",
+  "source_training_state": "Internal training-state inventory redacted from the current publication.",
+  "converter_path": "<INTERNAL_CONVERTER_PATH_REDACTED>",
+  "converter_sha256": "e83cd55ba2cf81936ab72a6b0a8ae3c2cbd02de6a232094aec5dc215939ee639",
+  "export_script_sha256": "c8a097372b7f7eb5f35470697d37857e72b695d12309400eaea834c867e5d35d",
+  "text_tensors": 851,
+  "replicated_tensors_checked_equal": 454,
+  "preserved_parent_tensors": [
+    "model.visual.blocks.0.attn.proj.bias",
+    "model.visual.blocks.0.attn.proj.weight",
+    "model.visual.blocks.0.attn.qkv.bias",
+    "model.visual.blocks.0.attn.qkv.weight",
+    "model.visual.blocks.0.mlp.linear_fc1.bias",
+    "model.visual.blocks.0.mlp.linear_fc1.weight",
+    "model.visual.blocks.0.mlp.linear_fc2.bias",
+    "model.visual.blocks.0.mlp.linear_fc2.weight",
+    "model.visual.blocks.0.norm1.bias",
+    "model.visual.blocks.0.norm1.weight",
+    "model.visual.blocks.0.norm2.bias",
+    "model.visual.blocks.0.norm2.weight",
+    "model.visual.blocks.1.attn.proj.bias",
+    "model.visual.blocks.1.attn.proj.weight",
+    "model.visual.blocks.1.attn.qkv.bias",
+    "model.visual.blocks.1.attn.qkv.weight",
+    "model.visual.blocks.1.mlp.linear_fc1.bias",
+    "model.visual.blocks.1.mlp.linear_fc1.weight",
+    "model.visual.blocks.1.mlp.linear_fc2.bias",
+    "model.visual.blocks.1.mlp.linear_fc2.weight",
+    "model.visual.blocks.1.norm1.bias",
+    "model.visual.blocks.1.norm1.weight",
+    "model.visual.blocks.1.norm2.bias",
+    "model.visual.blocks.1.norm2.weight",
+    "model.visual.blocks.10.attn.proj.bias",
+    "model.visual.blocks.10.attn.proj.weight",
+    "model.visual.blocks.10.attn.qkv.bias",
+    "model.visual.blocks.10.attn.qkv.weight",
+    "model.visual.blocks.10.mlp.linear_fc1.bias",
+    "model.visual.blocks.10.mlp.linear_fc1.weight",
+    "model.visual.blocks.10.mlp.linear_fc2.bias",
+    "model.visual.blocks.10.mlp.linear_fc2.weight",
+    "model.visual.blocks.10.norm1.bias",
+    "model.visual.blocks.10.norm1.weight",
+    "model.visual.blocks.10.norm2.bias",
+    "model.visual.blocks.10.norm2.weight",
+    "model.visual.blocks.11.attn.proj.bias",
+    "model.visual.blocks.11.attn.proj.weight",
+    "model.visual.blocks.11.attn.qkv.bias",
+    "model.visual.blocks.11.attn.qkv.weight",
+    "model.visual.blocks.11.mlp.linear_fc1.bias",
+    "model.visual.blocks.11.mlp.linear_fc1.weight",
+    "model.visual.blocks.11.mlp.linear_fc2.bias",
+    "model.visual.blocks.11.mlp.linear_fc2.weight",
+    "model.visual.blocks.11.norm1.bias",
+    "model.visual.blocks.11.norm1.weight",
+    "model.visual.blocks.11.norm2.bias",
+    "model.visual.blocks.11.norm2.weight",
+    "model.visual.blocks.12.attn.proj.bias",
+    "model.visual.blocks.12.attn.proj.weight",
+    "model.visual.blocks.12.attn.qkv.bias",
+    "model.visual.blocks.12.attn.qkv.weight",
+    "model.visual.blocks.12.mlp.linear_fc1.bias",
+    "model.visual.blocks.12.mlp.linear_fc1.weight",
+    "model.visual.blocks.12.mlp.linear_fc2.bias",
+    "model.visual.blocks.12.mlp.linear_fc2.weight",
+    "model.visual.blocks.12.norm1.bias",
+    "model.visual.blocks.12.norm1.weight",
+    "model.visual.blocks.12.norm2.bias",
+    "model.visual.blocks.12.norm2.weight",
+    "model.visual.blocks.13.attn.proj.bias",
+    "model.visual.blocks.13.attn.proj.weight",
+    "model.visual.blocks.13.attn.qkv.bias",
+    "model.visual.blocks.13.attn.qkv.weight",
+    "model.visual.blocks.13.mlp.linear_fc1.bias",
+    "model.visual.blocks.13.mlp.linear_fc1.weight",
+    "model.visual.blocks.13.mlp.linear_fc2.bias",
+    "model.visual.blocks.13.mlp.linear_fc2.weight",
+    "model.visual.blocks.13.norm1.bias",
+    "model.visual.blocks.13.norm1.weight",
+    "model.visual.blocks.13.norm2.bias",
+    "model.visual.blocks.13.norm2.weight",
+    "model.visual.blocks.14.attn.proj.bias",
+    "model.visual.blocks.14.attn.proj.weight",
+    "model.visual.blocks.14.attn.qkv.bias",
+    "model.visual.blocks.14.attn.qkv.weight",
+    "model.visual.blocks.14.mlp.linear_fc1.bias",
+    "model.visual.blocks.14.mlp.linear_fc1.weight",
+    "model.visual.blocks.14.mlp.linear_fc2.bias",
+    "model.visual.blocks.14.mlp.linear_fc2.weight",
+    "model.visual.blocks.14.norm1.bias",
+    "model.visual.blocks.14.norm1.weight",
+    "model.visual.blocks.14.norm2.bias",
+    "model.visual.blocks.14.norm2.weight",
+    "model.visual.blocks.15.attn.proj.bias",
+    "model.visual.blocks.15.attn.proj.weight",
+    "model.visual.blocks.15.attn.qkv.bias",
+    "model.visual.blocks.15.attn.qkv.weight",
+    "model.visual.blocks.15.mlp.linear_fc1.bias",
+    "model.visual.blocks.15.mlp.linear_fc1.weight",
+    "model.visual.blocks.15.mlp.linear_fc2.bias",
+    "model.visual.blocks.15.mlp.linear_fc2.weight",
+    "model.visual.blocks.15.norm1.bias",
+    "model.visual.blocks.15.norm1.weight",
+    "model.visual.blocks.15.norm2.bias",
+    "model.visual.blocks.15.norm2.weight",
+    "model.visual.blocks.16.attn.proj.bias",
+    "model.visual.blocks.16.attn.proj.weight",
+    "model.visual.blocks.16.attn.qkv.bias",
+    "model.visual.blocks.16.attn.qkv.weight",
+    "model.visual.blocks.16.mlp.linear_fc1.bias",
+    "model.visual.blocks.16.mlp.linear_fc1.weight",
+    "model.visual.blocks.16.mlp.linear_fc2.bias",
+    "model.visual.blocks.16.mlp.linear_fc2.weight",
+    "model.visual.blocks.16.norm1.bias",
+    "model.visual.blocks.16.norm1.weight",
+    "model.visual.blocks.16.norm2.bias",
+    "model.visual.blocks.16.norm2.weight",
+    "model.visual.blocks.17.attn.proj.bias",
+    "model.visual.blocks.17.attn.proj.weight",
+    "model.visual.blocks.17.attn.qkv.bias",
+    "model.visual.blocks.17.attn.qkv.weight",
+    "model.visual.blocks.17.mlp.linear_fc1.bias",
+    "model.visual.blocks.17.mlp.linear_fc1.weight",
+    "model.visual.blocks.17.mlp.linear_fc2.bias",
+    "model.visual.blocks.17.mlp.linear_fc2.weight",
+    "model.visual.blocks.17.norm1.bias",
+    "model.visual.blocks.17.norm1.weight",
+    "model.visual.blocks.17.norm2.bias",
+    "model.visual.blocks.17.norm2.weight",
+    "model.visual.blocks.18.attn.proj.bias",
+    "model.visual.blocks.18.attn.proj.weight",
+    "model.visual.blocks.18.attn.qkv.bias",
+    "model.visual.blocks.18.attn.qkv.weight",
+    "model.visual.blocks.18.mlp.linear_fc1.bias",
+    "model.visual.blocks.18.mlp.linear_fc1.weight",
+    "model.visual.blocks.18.mlp.linear_fc2.bias",
+    "model.visual.blocks.18.mlp.linear_fc2.weight",
+    "model.visual.blocks.18.norm1.bias",
+    "model.visual.blocks.18.norm1.weight",
+    "model.visual.blocks.18.norm2.bias",
+    "model.visual.blocks.18.norm2.weight",
+    "model.visual.blocks.19.attn.proj.bias",
+    "model.visual.blocks.19.attn.proj.weight",
+    "model.visual.blocks.19.attn.qkv.bias",
+    "model.visual.blocks.19.attn.qkv.weight",
+    "model.visual.blocks.19.mlp.linear_fc1.bias",
+    "model.visual.blocks.19.mlp.linear_fc1.weight",
+    "model.visual.blocks.19.mlp.linear_fc2.bias",
+    "model.visual.blocks.19.mlp.linear_fc2.weight",
+    "model.visual.blocks.19.norm1.bias",
+    "model.visual.blocks.19.norm1.weight",
+    "model.visual.blocks.19.norm2.bias",
+    "model.visual.blocks.19.norm2.weight",
+    "model.visual.blocks.2.attn.proj.bias",
+    "model.visual.blocks.2.attn.proj.weight",
+    "model.visual.blocks.2.attn.qkv.bias",
+    "model.visual.blocks.2.attn.qkv.weight",
+    "model.visual.blocks.2.mlp.linear_fc1.bias",
+    "model.visual.blocks.2.mlp.linear_fc1.weight",
+    "model.visual.blocks.2.mlp.linear_fc2.bias",
+    "model.visual.blocks.2.mlp.linear_fc2.weight",
+    "model.visual.blocks.2.norm1.bias",
+    "model.visual.blocks.2.norm1.weight",
+    "model.visual.blocks.2.norm2.bias",
+    "model.visual.blocks.2.norm2.weight",
+    "model.visual.blocks.20.attn.proj.bias",
+    "model.visual.blocks.20.attn.proj.weight",
+    "model.visual.blocks.20.attn.qkv.bias",
+    "model.visual.blocks.20.attn.qkv.weight",
+    "model.visual.blocks.20.mlp.linear_fc1.bias",
+    "model.visual.blocks.20.mlp.linear_fc1.weight",
+    "model.visual.blocks.20.mlp.linear_fc2.bias",
+    "model.visual.blocks.20.mlp.linear_fc2.weight",
+    "model.visual.blocks.20.norm1.bias",
+    "model.visual.blocks.20.norm1.weight",
+    "model.visual.blocks.20.norm2.bias",
+    "model.visual.blocks.20.norm2.weight",
+    "model.visual.blocks.21.attn.proj.bias",
+    "model.visual.blocks.21.attn.proj.weight",
+    "model.visual.blocks.21.attn.qkv.bias",
+    "model.visual.blocks.21.attn.qkv.weight",
+    "model.visual.blocks.21.mlp.linear_fc1.bias",
+    "model.visual.blocks.21.mlp.linear_fc1.weight",
+    "model.visual.blocks.21.mlp.linear_fc2.bias",
+    "model.visual.blocks.21.mlp.linear_fc2.weight",
+    "model.visual.blocks.21.norm1.bias",
+    "model.visual.blocks.21.norm1.weight",
+    "model.visual.blocks.21.norm2.bias",
+    "model.visual.blocks.21.norm2.weight",
+    "model.visual.blocks.22.attn.proj.bias",
+    "model.visual.blocks.22.attn.proj.weight",
+    "model.visual.blocks.22.attn.qkv.bias",
+    "model.visual.blocks.22.attn.qkv.weight",
+    "model.visual.blocks.22.mlp.linear_fc1.bias",
+    "model.visual.blocks.22.mlp.linear_fc1.weight",
+    "model.visual.blocks.22.mlp.linear_fc2.bias",
+    "model.visual.blocks.22.mlp.linear_fc2.weight",
+    "model.visual.blocks.22.norm1.bias",
+    "model.visual.blocks.22.norm1.weight",
+    "model.visual.blocks.22.norm2.bias",
+    "model.visual.blocks.22.norm2.weight",
+    "model.visual.blocks.23.attn.proj.bias",
+    "model.visual.blocks.23.attn.proj.weight",
+    "model.visual.blocks.23.attn.qkv.bias",
+    "model.visual.blocks.23.attn.qkv.weight",
+    "model.visual.blocks.23.mlp.linear_fc1.bias",
+    "model.visual.blocks.23.mlp.linear_fc1.weight",
+    "model.visual.blocks.23.mlp.linear_fc2.bias",
+    "model.visual.blocks.23.mlp.linear_fc2.weight",
+    "model.visual.blocks.23.norm1.bias",
+    "model.visual.blocks.23.norm1.weight",
+    "model.visual.blocks.23.norm2.bias",
+    "model.visual.blocks.23.norm2.weight",
+    "model.visual.blocks.24.attn.proj.bias",
+    "model.visual.blocks.24.attn.proj.weight",
+    "model.visual.blocks.24.attn.qkv.bias",
+    "model.visual.blocks.24.attn.qkv.weight",
+    "model.visual.blocks.24.mlp.linear_fc1.bias",
+    "model.visual.blocks.24.mlp.linear_fc1.weight",
+    "model.visual.blocks.24.mlp.linear_fc2.bias",
+    "model.visual.blocks.24.mlp.linear_fc2.weight",
+    "model.visual.blocks.24.norm1.bias",
+    "model.visual.blocks.24.norm1.weight",
+    "model.visual.blocks.24.norm2.bias",
+    "model.visual.blocks.24.norm2.weight",
+    "model.visual.blocks.25.attn.proj.bias",
+    "model.visual.blocks.25.attn.proj.weight",
+    "model.visual.blocks.25.attn.qkv.bias",
+    "model.visual.blocks.25.attn.qkv.weight",
+    "model.visual.blocks.25.mlp.linear_fc1.bias",
+    "model.visual.blocks.25.mlp.linear_fc1.weight",
+    "model.visual.blocks.25.mlp.linear_fc2.bias",
+    "model.visual.blocks.25.mlp.linear_fc2.weight",
+    "model.visual.blocks.25.norm1.bias",
+    "model.visual.blocks.25.norm1.weight",
+    "model.visual.blocks.25.norm2.bias",
+    "model.visual.blocks.25.norm2.weight",
+    "model.visual.blocks.26.attn.proj.bias",
+    "model.visual.blocks.26.attn.proj.weight",
+    "model.visual.blocks.26.attn.qkv.bias",
+    "model.visual.blocks.26.attn.qkv.weight",
+    "model.visual.blocks.26.mlp.linear_fc1.bias",
+    "model.visual.blocks.26.mlp.linear_fc1.weight",
+    "model.visual.blocks.26.mlp.linear_fc2.bias",
+    "model.visual.blocks.26.mlp.linear_fc2.weight",
+    "model.visual.blocks.26.norm1.bias",
+    "model.visual.blocks.26.norm1.weight",
+    "model.visual.blocks.26.norm2.bias",
+    "model.visual.blocks.26.norm2.weight",
+    "model.visual.blocks.3.attn.proj.bias",
+    "model.visual.blocks.3.attn.proj.weight",
+    "model.visual.blocks.3.attn.qkv.bias",
+    "model.visual.blocks.3.attn.qkv.weight",
+    "model.visual.blocks.3.mlp.linear_fc1.bias",
+    "model.visual.blocks.3.mlp.linear_fc1.weight",
+    "model.visual.blocks.3.mlp.linear_fc2.bias",
+    "model.visual.blocks.3.mlp.linear_fc2.weight",
+    "model.visual.blocks.3.norm1.bias",
+    "model.visual.blocks.3.norm1.weight",
+    "model.visual.blocks.3.norm2.bias",
+    "model.visual.blocks.3.norm2.weight",
+    "model.visual.blocks.4.attn.proj.bias",
+    "model.visual.blocks.4.attn.proj.weight",
+    "model.visual.blocks.4.attn.qkv.bias",
+    "model.visual.blocks.4.attn.qkv.weight",
+    "model.visual.blocks.4.mlp.linear_fc1.bias",
+    "model.visual.blocks.4.mlp.linear_fc1.weight",
+    "model.visual.blocks.4.mlp.linear_fc2.bias",
+    "model.visual.blocks.4.mlp.linear_fc2.weight",
+    "model.visual.blocks.4.norm1.bias",
+    "model.visual.blocks.4.norm1.weight",
+    "model.visual.blocks.4.norm2.bias",
+    "model.visual.blocks.4.norm2.weight",
+    "model.visual.blocks.5.attn.proj.bias",
+    "model.visual.blocks.5.attn.proj.weight",
+    "model.visual.blocks.5.attn.qkv.bias",
+    "model.visual.blocks.5.attn.qkv.weight",
+    "model.visual.blocks.5.mlp.linear_fc1.bias",
+    "model.visual.blocks.5.mlp.linear_fc1.weight",
+    "model.visual.blocks.5.mlp.linear_fc2.bias",
+    "model.visual.blocks.5.mlp.linear_fc2.weight",
+    "model.visual.blocks.5.norm1.bias",
+    "model.visual.blocks.5.norm1.weight",
+    "model.visual.blocks.5.norm2.bias",
+    "model.visual.blocks.5.norm2.weight",
+    "model.visual.blocks.6.attn.proj.bias",
+    "model.visual.blocks.6.attn.proj.weight",
+    "model.visual.blocks.6.attn.qkv.bias",
+    "model.visual.blocks.6.attn.qkv.weight",
+    "model.visual.blocks.6.mlp.linear_fc1.bias",
+    "model.visual.blocks.6.mlp.linear_fc1.weight",
+    "model.visual.blocks.6.mlp.linear_fc2.bias",
+    "model.visual.blocks.6.mlp.linear_fc2.weight",
+    "model.visual.blocks.6.norm1.bias",
+    "model.visual.blocks.6.norm1.weight",
+    "model.visual.blocks.6.norm2.bias",
+    "model.visual.blocks.6.norm2.weight",
+    "model.visual.blocks.7.attn.proj.bias",
+    "model.visual.blocks.7.attn.proj.weight",
+    "model.visual.blocks.7.attn.qkv.bias",
+    "model.visual.blocks.7.attn.qkv.weight",
+    "model.visual.blocks.7.mlp.linear_fc1.bias",
+    "model.visual.blocks.7.mlp.linear_fc1.weight",
+    "model.visual.blocks.7.mlp.linear_fc2.bias",
+    "model.visual.blocks.7.mlp.linear_fc2.weight",
+    "model.visual.blocks.7.norm1.bias",
+    "model.visual.blocks.7.norm1.weight",
+    "model.visual.blocks.7.norm2.bias",
+    "model.visual.blocks.7.norm2.weight",
+    "model.visual.blocks.8.attn.proj.bias",
+    "model.visual.blocks.8.attn.proj.weight",
+    "model.visual.blocks.8.attn.qkv.bias",
+    "model.visual.blocks.8.attn.qkv.weight",
+    "model.visual.blocks.8.mlp.linear_fc1.bias",
+    "model.visual.blocks.8.mlp.linear_fc1.weight",
+    "model.visual.blocks.8.mlp.linear_fc2.bias",
+    "model.visual.blocks.8.mlp.linear_fc2.weight",
+    "model.visual.blocks.8.norm1.bias",
+    "model.visual.blocks.8.norm1.weight",
+    "model.visual.blocks.8.norm2.bias",
+    "model.visual.blocks.8.norm2.weight",
+    "model.visual.blocks.9.attn.proj.bias",
+    "model.visual.blocks.9.attn.proj.weight",
+    "model.visual.blocks.9.attn.qkv.bias",
+    "model.visual.blocks.9.attn.qkv.weight",
+    "model.visual.blocks.9.mlp.linear_fc1.bias",
+    "model.visual.blocks.9.mlp.linear_fc1.weight",
+    "model.visual.blocks.9.mlp.linear_fc2.bias",
+    "model.visual.blocks.9.mlp.linear_fc2.weight",
+    "model.visual.blocks.9.norm1.bias",
+    "model.visual.blocks.9.norm1.weight",
+    "model.visual.blocks.9.norm2.bias",
+    "model.visual.blocks.9.norm2.weight",
+    "model.visual.merger.linear_fc1.bias",
+    "model.visual.merger.linear_fc1.weight",
+    "model.visual.merger.linear_fc2.bias",
+    "model.visual.merger.linear_fc2.weight",
+    "model.visual.merger.norm.bias",
+    "model.visual.merger.norm.weight",
+    "model.visual.patch_embed.proj.bias",
+    "model.visual.patch_embed.proj.weight",
+    "model.visual.pos_embed.weight",
+    "mtp.fc.weight",
+    "mtp.layers.0.input_layernorm.weight",
+    "mtp.layers.0.mlp.down_proj.weight",
+    "mtp.layers.0.mlp.gate_proj.weight",
+    "mtp.layers.0.mlp.up_proj.weight",
+    "mtp.layers.0.post_attention_layernorm.weight",
+    "mtp.layers.0.self_attn.k_norm.weight",
+    "mtp.layers.0.self_attn.k_proj.weight",
+    "mtp.layers.0.self_attn.o_proj.weight",
+    "mtp.layers.0.self_attn.q_norm.weight",
+    "mtp.layers.0.self_attn.q_proj.weight",
+    "mtp.layers.0.self_attn.v_proj.weight",
+    "mtp.norm.weight",
+    "mtp.pre_fc_norm_embedding.weight",
+    "mtp.pre_fc_norm_hidden.weight"
+  ],
+  "replicated_tensor_differences": [
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.0.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 45,
+      "numel": 40960,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 1.8214023622675768e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.0.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 18609,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.291975748607399e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.0.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 9639,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.112669623104523e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.0.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 213,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.895282318922e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.0.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 115,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.531059501402865e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.0.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 9183,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.0142108264332705e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.1.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 49,
+      "numel": 40960,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 2.0707602299552264e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.1.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 15243,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.0479778156380348e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.1.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 8172,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 9.054810790054546e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.1.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 182,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.5461306396579175e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.1.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 102,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.203668831273319e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.1.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 7573,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 8.400473094916094e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.2.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 19,
+      "numel": 40960,
+      "max_abs_difference": 3.814697265625e-06,
+      "mean_abs_difference": 3.8039615901652724e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.2.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 6412,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 4.1276040918525325e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.2.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 3067,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.217904831487317e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.2.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 85,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.0481007173268608e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.2.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 48,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.6057949121269814e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.2.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 2922,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.940546695029411e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.4.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 22,
+      "numel": 40960,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 1.0222720447927713e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.4.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 6353,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 5.091326249484496e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.4.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 2880,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.73936021036414e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.4.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 57,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.159601079718357e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.4.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 52,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.798018259424055e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.4.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 2780,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.477997612133521e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.5.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 2,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 7.465132401129893e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.5.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 4450,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.5795788555503805e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.5.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 1443,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.8462815998265825e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.5.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 44,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.661214912995206e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.5.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 25,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.0735236578038894e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.5.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 1449,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.7835337373650617e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.6.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 6,
+      "numel": 40960,
+      "max_abs_difference": 3.814697265625e-06,
+      "mean_abs_difference": 1.6470949604219243e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.6.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 423,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.7659968065973928e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.6.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 165,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.594046075692468e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.6.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 2,
+      "numel": 245760,
+      "max_abs_difference": 2.9802322387695312e-08,
+      "mean_abs_difference": 1.3452941831273296e-13,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.6.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 3,
+      "numel": 245760,
+      "max_abs_difference": 2.384185791015625e-07,
+      "mean_abs_difference": 1.515824466814808e-12,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.6.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 143,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.4855916843914407e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.8.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 93,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.272486530178867e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.8.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 51265,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 4.324009594824929e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.8.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 23917,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.2533382654520437e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.8.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 518,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 9.054241800754426e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.8.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 387,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.4282117406833095e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.8.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 22821,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.0835232145420832e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.9.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 32,
+      "numel": 40960,
+      "max_abs_difference": 7.62939453125e-06,
+      "mean_abs_difference": 1.059993315344343e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.9.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 12825,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 9.968682546102059e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.9.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 5561,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 6.905871430262778e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.9.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 152,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.8903487664090335e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.9.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 116,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.5164772770859258e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.9.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 5352,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 6.321395629171889e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 97,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.235148841682303e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 53292,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 4.463299507762031e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 26066,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.531776870957515e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 536,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 9.588347893441096e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 358,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.20299145381864e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 23819,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.1701967717623347e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.10.self_attention.input_layernorm.weight",
+      "different_elements": 3,
+      "numel": 5120,
+      "max_abs_difference": 1.9073486328125e-06,
+      "mean_abs_difference": 3.978129770043637e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 74,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.36947464269133e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 38407,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.054222652565386e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 18097,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.2853243741849383e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 523,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 9.139074386155244e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 283,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.652696450335725e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 16178,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.9580772558924764e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.12.self_attention.input_layernorm.weight",
+      "different_elements": 3,
+      "numel": 5120,
+      "max_abs_difference": 9.5367431640625e-07,
+      "mean_abs_difference": 2.561137135703717e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.13.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 76,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.16889633925166e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.13.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 31336,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.4398696396588093e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.13.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 15366,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.9322343725036717e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.13.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 279,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.049010542990118e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.13.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 221,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.640221235556851e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.13.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 13685,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.660277915149777e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 84,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.1558565477828324e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 40416,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.276448889977246e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 19017,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.4159578781990376e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 406,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.500220279230916e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 273,
+      "numel": 245760,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 4.591712787771485e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 17752,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.2255928211478704e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.14.self_attention.input_layernorm.weight",
+      "different_elements": 2,
+      "numel": 5120,
+      "max_abs_difference": 1.1920928955078125e-07,
+      "mean_abs_difference": 3.4924597935859225e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.16.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 57,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.780075281094696e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.16.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 20152,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.5492070959410853e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.16.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 9562,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.1243013187112183e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.16.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 222,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.512121343225317e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.16.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 134,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.5048989549247835e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.16.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 9301,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.0786788129379943e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.17.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 1,
+      "numel": 40960,
+      "max_abs_difference": 1.862645149230957e-09,
+      "mean_abs_difference": 4.547473576627277e-14,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.17.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 195,
+      "numel": 52428800,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.0620981524822604e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.17.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 67,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.297081349942001e-12,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.17.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 1,
+      "numel": 245760,
+      "max_abs_difference": 1.4901161193847656e-08,
+      "mean_abs_difference": 6.063298328045155e-14,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.17.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 65,
+      "numel": 31457280,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 3.132455449542104e-12,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.18.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 68,
+      "numel": 40960,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.081948556944326e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.18.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 36762,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.761990192112762e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.18.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 17856,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.11608064404345e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.18.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 374,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.4634009255826186e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.18.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 275,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.500869454915346e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.18.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 17512,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.1355404111744747e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.20.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 1241,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 8.9016530258057e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.20.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 567,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 6.48919945556159e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.20.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 14,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.3502857993129567e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.20.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 23,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.7907845479013815e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.20.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 536,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 5.636174513212744e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.21.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 6,
+      "numel": 40960,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 5.768924782323381e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.21.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 2887,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.173750207612457e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.21.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 932,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.1033134822424628e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.21.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 22,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.046504160053587e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.21.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 19,
+      "numel": 245760,
+      "max_abs_difference": 7.62939453125e-06,
+      "mean_abs_difference": 7.048583938740194e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.21.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 993,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.1451626452663177e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.22.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 4,
+      "numel": 40960,
+      "max_abs_difference": 3.814697265625e-06,
+      "mean_abs_difference": 1.9244908444626674e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.22.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 2806,
+      "numel": 52428800,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.8561535641836713e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.22.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 1136,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.3165928069991395e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.22.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 22,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.7560615728793323e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.22.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 16,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.761945949725231e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.22.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 1198,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.337261967826464e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.24.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 7,
+      "numel": 40960,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 8.898496384190935e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.24.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 10669,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 9.136215117777624e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.24.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 4606,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 5.804748903770474e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.24.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 138,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.1675616856953184e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.24.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 84,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 1.714393738083686e-09,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.24.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 4876,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 6.426523757596669e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.25.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 1,
+      "numel": 40960,
+      "max_abs_difference": 3.725290298461914e-09,
+      "mean_abs_difference": 9.094947153254554e-14,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.25.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 1653,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.0847993336948747e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.25.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 463,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 4.799040331793236e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.25.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 22,
+      "numel": 245760,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 1.6037422778669708e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.25.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 16,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.5112664725490674e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.25.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 527,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.016221119036324e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.26.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 8,
+      "numel": 40960,
+      "max_abs_difference": 7.62939453125e-06,
+      "mean_abs_difference": 2.3937901660886496e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.26.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 4895,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.8790440304303786e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.26.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 2237,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.649653274566788e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.26.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 73,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 9.704839154522915e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.26.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 42,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 5.797507474092356e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.26.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 2269,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 3.2059588317423504e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.28.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 2,
+      "numel": 40960,
+      "max_abs_difference": 7.62939453125e-06,
+      "mean_abs_difference": 2.3283064365386963e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.28.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 1106,
+      "numel": 52428800,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 8.712219140560862e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.28.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 285,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.5129877345708707e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.28.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 19,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.697285533288408e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.28.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 12,
+      "numel": 245760,
+      "max_abs_difference": 1.52587890625e-05,
+      "mean_abs_difference": 2.2749493955309674e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.28.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 333,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.7015664838824236e-11,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.30.self_attention.linear_attn.conv1d.weight",
+      "different_elements": 4,
+      "numel": 40960,
+      "max_abs_difference": 7.62939453125e-06,
+      "mean_abs_difference": 3.78531705980123e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.30.self_attention.linear_attn.in_proj_qkv.weight",
+      "different_elements": 3408,
+      "numel": 52428800,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 2.462122727919791e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.30.self_attention.linear_attn.in_proj_z.weight",
+      "different_elements": 1602,
+      "numel": 31457280,
+      "max_abs_difference": 6.103515625e-05,
+      "mean_abs_difference": 1.9702034448343397e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.30.self_attention.linear_attn.in_proj_b.weight",
+      "different_elements": 63,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 8.512794358317421e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.30.self_attention.linear_attn.in_proj_a.weight",
+      "different_elements": 16,
+      "numel": 245760,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 3.135331438919309e-10,
+      "selected_tp_rank": 0
+    },
+    {
+      "pp_rank": 1,
+      "parameter": "decoder.layers.30.self_attention.linear_attn.out_proj.weight",
+      "different_elements": 1583,
+      "numel": 31457280,
+      "max_abs_difference": 3.0517578125e-05,
+      "mean_abs_difference": 2.1037689645897473e-10,
+      "selected_tp_rank": 0
+    }
+  ],
+  "replica_selection": "TP rank 0 for unsharded/duplicated tensors, matching upstream HF export convention; checkpoint replicas are not all identical",
+  "output_shards": [
+    {
+      "file": "model-00001-of-00018.safetensors",
+      "bytes": 3966730552,
+      "sha256": "b9dcb3e15c00823d46d92f645f8a7324cdd1163c39ff6c04de48fa6e478952a0"
+    },
+    {
+      "file": "model-00002-of-00018.safetensors",
+      "bytes": 3043080328,
+      "sha256": "ecf7312565a089592217b58d761e714f3b3d85d4ec578a15d901210a9ba14773"
+    },
+    {
+      "file": "model-00003-of-00018.safetensors",
+      "bytes": 2542796952,
+      "sha256": "cec21a53517089f1b9708a77936465420f266482a45da26fd4c0dd596d609d08"
+    },
+    {
+      "file": "model-00004-of-00018.safetensors",
+      "bytes": 3988973152,
+      "sha256": "3a1a2bfcfd177e62fbe78f08b2b1d3edac59c495397aa64d0d1c41b727a94c73"
+    },
+    {
+      "file": "model-00005-of-00018.safetensors",
+      "bytes": 2099339864,
+      "sha256": "389931270466dcdbc9125bda7572cc7712f164e1fe774e7377524abca899b0c2"
+    },
+    {
+      "file": "model-00006-of-00018.safetensors",
+      "bytes": 3979553696,
+      "sha256": "da6f16eabe6be8552af22ed5ad171ae97469fa5bb5d5e613982460e43265debf"
+    },
+    {
+      "file": "model-00007-of-00018.safetensors",
+      "bytes": 2108759344,
+      "sha256": "b4b9f91766d367f0260882d97b5c0862863c393ef381f54d48dfda3d362072a9"
+    },
+    {
+      "file": "model-00008-of-00018.safetensors",
+      "bytes": 3979553696,
+      "sha256": "df58405d10cb8a199e3e5a01346c6b6ebf2a1bed05d6b11e14f856543b28e55c"
+    },
+    {
+      "file": "model-00009-of-00018.safetensors",
+      "bytes": 2108759344,
+      "sha256": "84ba24193b7d0885ef504ce5806d3d4ebbe5506fdfd5919f4837ebc9479611e6"
+    },
+    {
+      "file": "model-00010-of-00018.safetensors",
+      "bytes": 3979553696,
+      "sha256": "aacd71e34312a13bf487a06c9c54205ad31f72a8788b0a550154a04565820a97"
+    },
+    {
+      "file": "model-00011-of-00018.safetensors",
+      "bytes": 2108759344,
+      "sha256": "6d967f431bdfde43c38839188023c5507d5d0dce6a1daa6bbbf8605ecb3da9aa"
+    },
+    {
+      "file": "model-00012-of-00018.safetensors",
+      "bytes": 3979553696,
+      "sha256": "c36593694bc3f250449ae2196366e6cf788c122dc9a645fbe6ef116746fc5d73"
+    },
+    {
+      "file": "model-00013-of-00018.safetensors",
+      "bytes": 2108759344,
+      "sha256": "b50b55cffe8be40b6eb90c43b1d3cec7672d7f3a86b2efd436db5a83619686d2"
+    },
+    {
+      "file": "model-00014-of-00018.safetensors",
+      "bytes": 3979553696,
+      "sha256": "27b627a940af6ba6f26d240767ca75a4774d02a91255c3a2274dd316e364d1d1"
+    },
+    {
+      "file": "model-00015-of-00018.safetensors",
+      "bytes": 2108759344,
+      "sha256": "f9203192d4a759f6fc58c32eebda8a2f00f4a15dc183f06ddc263de49595ade5"
+    },
+    {
+      "file": "model-00016-of-00018.safetensors",
+      "bytes": 3979564040,
+      "sha256": "cf3333f84d3783148a58b24612998ba24b8c60dc69f77e14d86e66ef958c23de"
+    },
+    {
+      "file": "model-00017-of-00018.safetensors",
+      "bytes": 2108759344,
+      "sha256": "e446dd9c79fc0255d9b2181a9a85debb2b5b51b2eb31177c4c1a7daa198221f7"
+    },
+    {
+      "file": "model-00018-of-00018.safetensors",
+      "bytes": 3392197344,
+      "sha256": "2898c2335e6ce74567af2de8373d7468c403fb5e69f4b00f5f7b83fb815d71be"
+    }
+  ],
+  "asset_sha256": {
+    "chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041",
+    "generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+    "config.json": "191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab",
+    "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+    "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+    "tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3"
+  },
+  "parent_comparison": {
+    "sampled_tensors": 851,
+    "sampled_tensors_different_from_parent": 666
+  },
+  "all_saved_tensors_equal_to_export": true,
+  "all_text_tensors_finite": true,
+  "gated_qkv_roundtrip": true,
+  "total_tensor_bytes": 55562855904,
+  "finished_at": "2026-09-16T08:48:35.548578+00:00",
+  "elapsed_seconds": 180.26648061099695
+}

compatibility/architecture-compatibility-report.md

@@ -0,0 +1,40 @@
+# Swift 1.5 MLX compatibility: validated complete checkpoint
+
+Source: `ukisai/Swift-1.5-Qwen3.8-27b` at `00ccd14e006897d28cb0ed5bf26390e60d274251`.
+All 18 BF16 shards and original runtime assets passed full SHA256 verification.
+Source: 55563006776 weight bytes, 1199 BF16 tensors.
+
+The official Qwen loader dropped 333 vision and 15 MTP tensors. The isolated patch
+adds `mlx_lm/models/qwen3_5_full.py` with a real vision encoder and explicit MTP
+module, plus strict dispatch/index checks and config/asset preservation in
+`mlx_lm/utils.py`. `tests/test_qwen3_5_full.py` exercises mapping failures,
+Transformers numerical agreement, cache behavior, native nonquantized conversion,
+and exact-target quantized saving/reloading.
+
+All 16 nonquantized architecture tests and the additional fixed affine test passed
+on Linux CPU. The real source loaded strictly with 851 text, 333 vision and 15 MTP
+tensors. There are zero ignored or unexplained tensors. The native quant has
+2379 saved tensors because quantized weights have scales and biases.
+All 609 BF16 remainder tensors equal the source values.
+
+Text generation passed. Vision encoder execution and an MTP step using real text
+hidden states passed. Image/video text integration and speculative generation are
+not implemented. The original tokenizer, chat template, context, processor,
+untied output head/shared MTP embeddings, norms and gating configuration are retained.
+
+CPU runtime checks promote only in-memory floating values to FP32. The original
+Linux BF16 QMM kernel produced 256 when summing 8192 exact ones; FP32 returned
+8192. This reproducible backend issue and the runtime workaround are recorded in
+cpu-quantized-matmul-diagnostic.json and ../USAGE.md. Stored weights were not changed.
+
+Apple Silicon Metal checks passed for all 2379 native parameter headers and
+real packed Q4 samples from text, vision and MTP. Both native BF16 Metal and
+FP32 Metal executions matched their references. Only small actual samples were
+evaluated on the 16 GiB Mac; no full 27B Mac generation is claimed.
+
+The original source was read without modification. The source tensor layout
+transposes are recorded individually in `quant-tensor-mapping-manifest.json`.
+No custom quantization algorithm or alternate quantization configuration was used.
+
+Patch SHA256: `f6f1d0bdafa45863bfbf93dac0398c481c993ea04fdf38b9bae98c643f89eaec`. Apply to official MLX-LM commit
+`c69d1288440a0dc4e6401fc417098b07598dccd5`; see `../USAGE.md`.

compatibility/aws-actual-source-structural-results.json

@@ -0,0 +1,53 @@
+{
+  "status": "PASS_ACTUAL_SOURCE_LAZY_STRUCTURAL_LOAD",
+  "recorded_at": "2026-09-21T17:51:07.992995+00:00",
+  "platform": "Linux x86_64",
+  "source": "<SOURCE_MODEL_DIR>",
+  "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "source_verification": "compatibility/aws-source-verification.json",
+  "source_verification_sha256": "ad944ae15bedaaec80abf9cd5e9e945f478397328cf3145f19517ff96295ad9c",
+  "source_tensors": 1199,
+  "mapped_tensors": 1199,
+  "categories": {
+    "text": 851,
+    "MTP": 15,
+    "vision": 333
+  },
+  "ignored_tensors": 0,
+  "unexplained_tensors": 0,
+  "weight_backing": "actual verified source safetensors; lazy loading",
+  "full_parameter_evaluation": false,
+  "tokenizer": "Qwen2Tokenizer",
+  "chat_templates": [
+    {
+      "options": {
+        "enable_thinking": false
+      },
+      "tokens": 15,
+      "rendered": "<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
+    },
+    {
+      "options": {
+        "reasoning_effort": "low"
+      },
+      "tokens": 43,
+      "rendered": "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+    },
+    {
+      "options": {
+        "reasoning_effort": "xhigh"
+      },
+      "tokens": 55,
+      "rendered": "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+    }
+  ],
+  "processor": "Qwen3VLProcessor",
+  "generation": "NOT_RUN",
+  "mtp_runtime": "component-only; no integrated speculative decoding",
+  "vision_runtime": "encoder-only; no integrated multimodal generation",
+  "quantization_executed": false,
+  "elapsed_seconds": 0.9277446469999973,
+  "mlx_active_memory_bytes": 8,
+  "process_peak_rss_bytes": 797855744
+}

compatibility/compatibility-tests-linux.log

@@ -0,0 +1,2 @@
+................                                                         [100%]
+16 passed in 6.44s

compatibility/conversion-command.json

@@ -0,0 +1,25 @@
+{
+  "command": [
+    "mlx_lm.convert",
+    "--hf-path",
+    "<SOURCE_MODEL_DIR>",
+    "--mlx-path",
+    "<OUTPUT_MODEL_DIR>",
+    "--quantize",
+    "--q-mode",
+    "affine",
+    "--q-bits",
+    "4",
+    "--q-group-size",
+    "64"
+  ],
+  "started_at": "2026-09-21T17:53:29.797067+00:00",
+  "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "source_manifest_sha256": "0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae",
+  "quantization": {
+    "mode": "affine",
+    "bits": 4,
+    "group_size": 64
+  }
+}

compatibility/conversion-result.json

@@ -0,0 +1,28 @@
+{
+  "command": [
+    "mlx_lm.convert",
+    "--hf-path",
+    "<SOURCE_MODEL_DIR>",
+    "--mlx-path",
+    "<OUTPUT_MODEL_DIR>",
+    "--quantize",
+    "--q-mode",
+    "affine",
+    "--q-bits",
+    "4",
+    "--q-group-size",
+    "64"
+  ],
+  "started_at": "2026-09-21T17:53:29.797067+00:00",
+  "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "source_manifest_sha256": "0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae",
+  "quantization": {
+    "mode": "affine",
+    "bits": 4,
+    "group_size": 64
+  },
+  "returncode": 0,
+  "elapsed_seconds": 120.018799242,
+  "finished_at": "2026-09-21T17:55:29.816005+00:00"
+}

compatibility/conversion.log

@@ -0,0 +1,4 @@
+[INFO] Loading
+[INFO] Using dtype: bfloat16
+[INFO] Quantizing
+[INFO] Quantized model with 4.557 bits per weight.

compatibility/cpu-quantized-matmul-diagnostic.json

@@ -0,0 +1,19 @@
+{
+  "test": "sum of 8192 exact ones with official affine/4-bit/group-64 quantized matmul",
+  "bf16_cpu_result": [
+    [
+      256.0
+    ]
+  ],
+  "float32_cpu_result": [
+    [
+      8192.0
+    ]
+  ],
+  "reference": [
+    [
+      8192.0
+    ]
+  ],
+  "stored_packed_weights_unchanged": true
+}

compatibility/environment-linux.json

@@ -0,0 +1,20 @@
+{
+  "platform": "Linux x86_64",
+  "python": "3.12.3",
+  "device": "Device(cpu, 0)",
+  "cpu_test": [
+    1,
+    4,
+    9
+  ],
+  "packages": {
+    "mlx": "0.32.2",
+    "mlx-cpu": "0.32.2",
+    "mlx-lm": "0.32.0",
+    "transformers": "5.14.1",
+    "huggingface_hub": "1.31.0",
+    "torch": "2.11.0+cpu",
+    "torchvision": "0.26.0+cpu",
+    "safetensors": "0.8.0"
+  }
+}

compatibility/fixed-affine-test.log

@@ -0,0 +1,2 @@
+.                                                                        [100%]
+1 passed, 16 deselected in 2.48s

compatibility/mac-check/config.json

@@ -0,0 +1,154 @@
+{
+    "architectures": [
+        "Qwen3_5ForConditionalGeneration"
+    ],
+    "eos_token_id": [
+        248046,
+        248044
+    ],
+    "image_token_id": 248056,
+    "language_model_only": false,
+    "model_type": "qwen3_5",
+    "quantization": {
+        "group_size": 64,
+        "bits": 4,
+        "mode": "affine"
+    },
+    "quantization_config": {
+        "group_size": 64,
+        "bits": 4,
+        "mode": "affine"
+    },
+    "text_config": {
+        "attention_bias": false,
+        "attention_dropout": 0.0,
+        "attn_output_gate": true,
+        "bos_token_id": 248044,
+        "dtype": "bfloat16",
+        "eos_token_id": 248044,
+        "full_attention_interval": 4,
+        "head_dim": 256,
+        "hidden_act": "silu",
+        "hidden_size": 5120,
+        "initializer_range": 0.02,
+        "intermediate_size": 17408,
+        "layer_types": [
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention"
+        ],
+        "linear_conv_kernel_dim": 4,
+        "linear_key_head_dim": 128,
+        "linear_num_key_heads": 16,
+        "linear_num_value_heads": 48,
+        "linear_value_head_dim": 128,
+        "mamba_ssm_dtype": "float32",
+        "max_position_embeddings": 262144,
+        "model_type": "qwen3_5_text",
+        "mtp_num_hidden_layers": 1,
+        "mtp_use_dedicated_embeddings": false,
+        "num_attention_heads": 24,
+        "num_hidden_layers": 64,
+        "num_key_value_heads": 4,
+        "output_gate_type": "swish",
+        "pad_token_id": null,
+        "partial_rotary_factor": 0.25,
+        "rms_norm_eps": 1e-06,
+        "rope_parameters": {
+            "mrope_interleaved": true,
+            "mrope_section": [
+                11,
+                11,
+                10
+            ],
+            "partial_rotary_factor": 0.25,
+            "rope_theta": 10000000,
+            "rope_type": "default"
+        },
+        "tie_word_embeddings": false,
+        "use_cache": true,
+        "vocab_size": 248320
+    },
+    "tie_word_embeddings": false,
+    "transformers_version": "5.8.0.dev0",
+    "video_token_id": 248057,
+    "vision_config": {
+        "deepstack_visual_indexes": [],
+        "depth": 27,
+        "hidden_act": "gelu_pytorch_tanh",
+        "hidden_size": 1152,
+        "in_channels": 3,
+        "initializer_range": 0.02,
+        "intermediate_size": 4304,
+        "model_type": "qwen3_5",
+        "num_heads": 16,
+        "num_position_embeddings": 2304,
+        "out_hidden_size": 5120,
+        "patch_size": 16,
+        "spatial_merge_size": 2,
+        "temporal_patch_size": 2
+    },
+    "vision_end_token_id": 248054,
+    "vision_start_token_id": 248053
+}

compatibility/mac-check/real-checkpoint-samples.safetensors

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

compatibility/mac-check/samples.json

@@ -0,0 +1,45 @@
+{
+  "source": "Actual completed Swift-1.5-4bit-MLX checkpoint; no substitute weights",
+  "samples": [
+    {
+      "sample": 0,
+      "category": "text",
+      "checkpoint_weight": "language_model.model.layers.0.linear_attn.in_proj_a.weight",
+      "original_shape": [
+        48,
+        5120
+      ],
+      "packed_shape": [
+        48,
+        640
+      ]
+    },
+    {
+      "sample": 1,
+      "category": "vision",
+      "checkpoint_weight": "visual.blocks.0.attn.proj.weight",
+      "original_shape": [
+        1152,
+        1152
+      ],
+      "packed_shape": [
+        1152,
+        144
+      ]
+    },
+    {
+      "sample": 2,
+      "category": "MTP",
+      "checkpoint_weight": "mtp.layers.0.self_attn.k_proj.weight",
+      "original_shape": [
+        1024,
+        5120
+      ],
+      "packed_shape": [
+        1024,
+        640
+      ]
+    }
+  ],
+  "coverage": "Small real packed tensor samples plus all saved tensor headers; not a full-model Mac generation test"
+}

compatibility/mac-compatibility-results.json

@@ -0,0 +1,72 @@
+{
+  "status": "PASS_MAC_NATIVE_MLX_FORMAT_AND_REAL_METAL_SAMPLES",
+  "platform": "macOS-26.6-arm64-arm-64bit",
+  "machine": "arm64",
+  "mlx": "0.32.2",
+  "mlx_lm": "0.32.0",
+  "device": "Device(gpu, 0)",
+  "quantization": {
+    "group_size": 64,
+    "bits": 4,
+    "mode": "affine"
+  },
+  "all_saved_tensor_headers_validated": 2379,
+  "all_source_parameters_accounted_for": 1199,
+  "strict_complete_parameter_tree": "PASS using unevaluated header fixtures; no fabricated weights saved",
+  "actual_checkpoint_samples": [
+    {
+      "sample": 0,
+      "category": "text",
+      "checkpoint_weight": "language_model.model.layers.0.linear_attn.in_proj_a.weight",
+      "original_shape": [
+        48,
+        5120
+      ],
+      "packed_shape": [
+        48,
+        640
+      ],
+      "native_metal_bf16": "PASS",
+      "metal_fp32": "PASS",
+      "bf16_max_absolute_error": 0.0004401206970214844,
+      "fp32_max_absolute_error": 0.0
+    },
+    {
+      "sample": 1,
+      "category": "vision",
+      "checkpoint_weight": "visual.blocks.0.attn.proj.weight",
+      "original_shape": [
+        1152,
+        1152
+      ],
+      "packed_shape": [
+        1152,
+        144
+      ],
+      "native_metal_bf16": "PASS",
+      "metal_fp32": "PASS",
+      "bf16_max_absolute_error": 0.0002315044403076172,
+      "fp32_max_absolute_error": 0.0
+    },
+    {
+      "sample": 2,
+      "category": "MTP",
+      "checkpoint_weight": "mtp.layers.0.self_attn.k_proj.weight",
+      "original_shape": [
+        1024,
+        5120
+      ],
+      "packed_shape": [
+        1024,
+        640
+      ],
+      "native_metal_bf16": "PASS",
+      "metal_fp32": "PASS",
+      "bf16_max_absolute_error": 0.0009589195251464844,
+      "fp32_max_absolute_error": 0.0
+    }
+  ],
+  "full_model_mac_generation": "NOT_RUN: targeted native Metal format and real-weight component checks only",
+  "peak_mlx_bytes": 4597960,
+  "peak_process_rss_bytes": 360693760
+}

compatibility/missing-file-recovery-report.md

@@ -0,0 +1,16 @@
+# Original Swift source recovery completed
+
+The pinned Hub snapshot lacked these original export files:
+
+- `model-00015-of-00018.safetensors`
+- `model-00016-of-00018.safetensors`
+- `model-00017-of-00018.safetensors`
+- `model-00018-of-00018.safetensors`
+- `preprocessor_config.json`
+- `tokenizer_config.json`
+- `video_preprocessor_config.json`
+- `vocab.json`
+- `tokenizer.json`
+- `model.safetensors.index.json`
+
+All were recovered from the verified original project BF16 export. All 18 shards and runtime assets passed the original export-manifest SHA-256 checks. The source copy was read without modification. No shard was reconstructed or borrowed from base Qwen or a derived quant. The completed source has 55,563,006,776 weight bytes and 1,199 BF16 tensors. Full per-file hashes are in `source-file-manifest.csv` and `aws-source-verification.json`. The complete Hub source is available at revision [`5ad04445d2686f525e9fbe5c077e6fa0c7df4200`](https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-27b/tree/5ad04445d2686f525e9fbe5c077e6fa0c7df4200).

compatibility/quant-validation-results.json

@@ -0,0 +1,103 @@
+{
+  "status": "PASS",
+  "recorded_at": "2026-09-21T18:14:21.887850+00:00",
+  "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "source_shards": 18,
+  "source_shard_bytes": 55563006776,
+  "source_tensors": 1199,
+  "mapped_source_tensors": 1199,
+  "saved_tensors": 2379,
+  "categories": {
+    "text": 851,
+    "MTP": 15,
+    "vision": 333
+  },
+  "ignored_tensors": 0,
+  "unexplained_tensors": 0,
+  "exact_unquantized_tensors": 609,
+  "quantization": {
+    "group_size": 64,
+    "bits": 4,
+    "mode": "affine"
+  },
+  "all_floating_tensors_finite": true,
+  "tokenizer": "Qwen2Tokenizer",
+  "processor": "Qwen3VLProcessor",
+  "assets_sha256": {
+    "generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+    "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+    "tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+    "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+    "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041"
+  },
+  "chat_templates": [
+    {
+      "options": {
+        "enable_thinking": false
+      },
+      "rendered": "<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
+    },
+    {
+      "options": {
+        "reasoning_effort": "low"
+      },
+      "rendered": "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+    },
+    {
+      "options": {
+        "reasoning_effort": "xhigh"
+      },
+      "rendered": "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+    }
+  ],
+  "load_seconds": 3.351265648000208,
+  "load_memory_bytes": 15826466152,
+  "process_peak_rss_bytes": 21142360064,
+  "inference_floating_dtype": "float32, CPU runtime only; stored floating tensors remain BF16",
+  "native_bf16_cpu_inference": "Aborted after reproducing incorrect accumulation in the official Linux BF16 quantized matmul. See cpu-quantized-matmul-diagnostic.json.",
+  "generation": {
+    "prompt": "<|im_start|>user\nReply with exactly: Hello from Swift.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n",
+    "text": "Hello from Swift.",
+    "token_ids": [
+      9419,
+      494,
+      22929,
+      13,
+      248046
+    ],
+    "tokens": 5,
+    "tokens_per_second": 0.0797672292904007,
+    "prompt_tokens_per_second": 0.06443886297275572,
+    "elapsed_seconds": 374.00736365800003,
+    "finish_reason": "stop"
+  },
+  "mtp": {
+    "status": "PASS",
+    "shape": [
+      1,
+      1,
+      248320
+    ],
+    "path": "Explicit MTP step with real text hidden states and shared LM head; speculative generation is not integrated"
+  },
+  "vision": {
+    "status": "PASS",
+    "shape": [
+      64,
+      5120
+    ],
+    "grid": [
+      [
+        1,
+        16,
+        16
+      ]
+    ],
+    "path": "Vision encoder only; image/video insertion and multimodal text generation are not implemented"
+  },
+  "total_validation_seconds": 467.15810263900016
+}

compatibility/quant-validation.log

@@ -0,0 +1,110 @@
+Loaded 2379 saved tensors; all 1199 source tensors accounted for.
+All 609 unquantized tensors equal the original BF16 values.
+CPU inference uses FP32 floating values; saved 4-bit weights are unchanged.
+Hello from Swift.
+Text generation passed.
+Real-weight MTP step passed.
+Real-weight vision encoder passed.
+{
+  "status": "PASS",
+  "recorded_at": "2026-09-21T18:14:21.887850+00:00",
+  "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+  "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+  "source_shards": 18,
+  "source_shard_bytes": 55563006776,
+  "source_tensors": 1199,
+  "mapped_source_tensors": 1199,
+  "saved_tensors": 2379,
+  "categories": {
+    "text": 851,
+    "MTP": 15,
+    "vision": 333
+  },
+  "ignored_tensors": 0,
+  "unexplained_tensors": 0,
+  "exact_unquantized_tensors": 609,
+  "quantization": {
+    "group_size": 64,
+    "bits": 4,
+    "mode": "affine"
+  },
+  "all_floating_tensors_finite": true,
+  "tokenizer": "Qwen2Tokenizer",
+  "processor": "Qwen3VLProcessor",
+  "assets_sha256": {
+    "generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+    "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+    "tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+    "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+    "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041"
+  },
+  "chat_templates": [
+    {
+      "options": {
+        "enable_thinking": false
+      },
+      "rendered": "<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
+    },
+    {
+      "options": {
+        "reasoning_effort": "low"
+      },
+      "rendered": "<|im_start|>system\nReasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+    },
+    {
+      "options": {
+        "reasoning_effort": "xhigh"
+      },
+      "rendered": "<|im_start|>system\nReasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.<|im_end|>\n<|im_start|>user\nSay hello.<|im_end|>\n<|im_start|>assistant\n<think>\n"
+    }
+  ],
+  "load_seconds": 3.351265648000208,
+  "load_memory_bytes": 15826466152,
+  "process_peak_rss_bytes": 21142360064,
+  "inference_floating_dtype": "float32, CPU runtime only; stored floating tensors remain BF16",
+  "native_bf16_cpu_inference": "Aborted after reproducing incorrect accumulation in the official Linux BF16 quantized matmul. See cpu-quantized-matmul-diagnostic.json.",
+  "generation": {
+    "prompt": "<|im_start|>user\nReply with exactly: Hello from Swift.<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n",
+    "text": "Hello from Swift.",
+    "token_ids": [
+      9419,
+      494,
+      22929,
+      13,
+      248046
+    ],
+    "tokens": 5,
+    "tokens_per_second": 0.0797672292904007,
+    "prompt_tokens_per_second": 0.06443886297275572,
+    "elapsed_seconds": 374.00736365800003,
+    "finish_reason": "stop"
+  },
+  "mtp": {
+    "status": "PASS",
+    "shape": [
+      1,
+      1,
+      248320
+    ],
+    "path": "Explicit MTP step with real text hidden states and shared LM head; speculative generation is not integrated"
+  },
+  "vision": {
+    "status": "PASS",
+    "shape": [
+      64,
+      5120
+    ],
+    "grid": [
+      [
+        1,
+        16,
+        16
+      ]
+    ],
+    "path": "Vision encoder only; image/video insertion and multimodal text generation are not implemented"
+  },
+  "total_validation_seconds": 467.15810263900016
+}

compatibility/requirements-linux.txt

@@ -0,0 +1,44 @@
+annotated-doc==0.0.5
+anyio==4.15.1
+certifi==2026.7.22
+click==8.5.0
+filelock==4.0.1
+fsspec==2026.9.0
+h11==0.16.0
+hf-xet==1.6.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.31.0
+idna==3.20
+iniconfig==2.3.0
+Jinja2==3.1.6
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+mlx==0.32.2
+mlx-cpu==0.32.2
+-e git+https://github.com/ml-explore/mlx-lm.git@c69d1288440a0dc4e6401fc417098b07598dccd5#egg=mlx_lm
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.5.3
+packaging==26.3
+pillow==12.3.0
+pluggy==1.6.0
+protobuf==7.36.2
+Pygments==2.21.0
+pytest==9.1.1
+PyYAML==6.0.3
+regex==2026.9.10
+rich==15.0.0
+safetensors==0.8.0
+sentencepiece==0.2.2
+setuptools==78.1.0
+shellingham==1.5.4
+sympy==1.14.0
+tokenizers==0.22.2
+torch==2.11.0+cpu
+torchvision==0.26.0+cpu
+tqdm==4.70.1
+transformers==5.14.1
+typer==0.27.2
+typing_extensions==4.16.0

compatibility/run-compatibility.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source_dir="${SWIFT_SOURCE_DIR:?Set SWIFT_SOURCE_DIR to the verified Swift 1.5 BF16 export}"
+log_dir="${SWIFT_VALIDATION_DIR:-$repo_root/validation-output}"
+mkdir -p "$log_dir"
+cd "$repo_root"
+export HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 PYTHONUNBUFFERED=1
+export OMP_NUM_THREADS=8 OPENBLAS_NUM_THREADS=8
+python3 compatibility/verify_source_readonly.py \
+  --root "$source_dir" \
+  --manifest-sha256 0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae \
+  > "$log_dir/source-verification.json" 2> "$log_dir/source-verification.log"
+.venv/bin/python -m pytest -q mlx-lm/tests/test_qwen3_5_full.py \
+  --junitxml="$log_dir/compatibility-tests-linux.xml" \
+  > "$log_dir/compatibility-tests-linux.log" 2>&1
+.venv/bin/python compatibility/validate_aws_source_linux.py \
+  --source "$source_dir" \
+  --verification "$log_dir/source-verification.json" \
+  --output "$log_dir/source-structural-results.json" \
+  > "$log_dir/source-structural.log" 2>&1

compatibility/run-conversion.py

@@ -0,0 +1,40 @@
+"""Run the official fixed MLX conversion and record resource usage."""
+import json
+import os
+import shutil
+import subprocess
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+root = Path(__file__).resolve().parents[1]
+os.chdir(root)
+source = Path(os.environ['SWIFT_SOURCE_DIR']).resolve(strict=True)
+output = Path(os.environ.get('SWIFT_MLX_OUTPUT', root / 'Swift-1.5-4bit-MLX')).resolve()
+logs = Path(os.environ.get('SWIFT_VALIDATION_DIR', root / 'validation-output')).resolve()
+logs.mkdir(parents=True, exist_ok=True)
+assert not output.exists(), 'Never overwrite an existing artifact'
+command = [str(root / '.venv/bin/mlx_lm.convert'), '--hf-path', str(source), '--mlx-path', str(output), '--quantize', '--q-mode', 'affine', '--q-bits', '4', '--q-group-size', '64']
+record = {'command': command, 'started_at': datetime.now(timezone.utc).isoformat(), 'source_repo': 'ukisai/Swift-1.5-Qwen3.8-27b', 'source_revision': '00ccd14e006897d28cb0ed5bf26390e60d274251', 'source_manifest_sha256': '0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae', 'quantization': {'mode': 'affine', 'bits': 4, 'group_size': 64}}
+(logs / 'conversion-command.json').write_text(json.dumps(record, indent=2)+'\n')
+env = dict(os.environ, HF_HUB_OFFLINE='1', TRANSFORMERS_OFFLINE='1', PYTHONUNBUFFERED='1', OMP_NUM_THREADS='8', OPENBLAS_NUM_THREADS='8')
+start = time.monotonic()
+with (logs / 'conversion.log').open('x') as log, (logs / 'conversion-resources.jsonl').open('x') as monitor:
+    process = subprocess.Popen(command, stdout=log, stderr=subprocess.STDOUT, env=env)
+    record['pid'] = process.pid
+    (logs / 'conversion-pid').write_text(str(process.pid)+'\n')
+    while process.poll() is None:
+        memory = dict(line.split(':', 1) for line in Path('/proc/meminfo').read_text().splitlines())
+        status = Path(f'/proc/{process.pid}/status')
+        stats = dict(line.split(':', 1) for line in status.read_text().splitlines()) if status.exists() else {}
+        disk = shutil.disk_usage(root)
+        sample = {'elapsed_seconds': time.monotonic()-start, 'rss': stats.get('VmRSS', '').strip(), 'peak_rss': stats.get('VmHWM', '').strip(), 'process_swap': stats.get('VmSwap', '').strip(), 'memory_available': memory['MemAvailable'].strip(), 'swap_free': memory['SwapFree'].strip(), 'disk_free_bytes': disk.free}
+        monitor.write(json.dumps(sample)+'\n'); monitor.flush()
+        if disk.free < 1024**3:
+            record['critical_stop_reason'] = 'Less than 1 GiB free disk space'
+            process.terminate()
+        time.sleep(5)
+    record.update(returncode=process.returncode, elapsed_seconds=time.monotonic()-start, finished_at=datetime.now(timezone.utc).isoformat())
+(logs / 'conversion-result.json').write_text(json.dumps(record,indent=2)+'\n')
+print(json.dumps(record,indent=2))
+raise SystemExit(process.returncode)

compatibility/setup-linux.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+log_dir="${SWIFT_VALIDATION_DIR:-$repo_root/validation-output}"
+mkdir -p "$log_dir"
+export SWIFT_VALIDATION_DIR="$log_dir"
+cd "$repo_root"
+python3 -m venv .venv
+.venv/bin/python -m pip install --upgrade pip
+.venv/bin/python -m pip install 'mlx[cpu]==0.32.2' 'transformers==5.14.1' 'huggingface_hub==1.31.0' 'safetensors==0.8.0' 'pytest==9.1.1' pillow sentencepiece protobuf
+.venv/bin/python -m pip install 'torch==2.11.0' 'torchvision==0.26.0' --index-url https://download.pytorch.org/whl/cpu
+if [ ! -d mlx-lm/.git ]; then
+    git clone https://github.com/ml-explore/mlx-lm.git mlx-lm
+    git -C mlx-lm checkout -b swift15-preserve-components c69d1288440a0dc4e6401fc417098b07598dccd5
+fi
+if [ ! -f mlx-lm/mlx_lm/models/qwen3_5_full.py ]; then
+    git -C mlx-lm apply --check "$repo_root/compatibility/swift15-mlx-lm.patch"
+    git -C mlx-lm apply "$repo_root/compatibility/swift15-mlx-lm.patch"
+fi
+.venv/bin/python -m pip install --no-deps -e ./mlx-lm
+.venv/bin/python -m pip check
+.venv/bin/python -m pip freeze > "$log_dir/requirements-linux.txt"
+.venv/bin/python - <<'PY'
+import importlib.metadata as m,json,os,platform
+from pathlib import Path
+import mlx.core as mx
+mx.set_default_device(mx.cpu)
+x=mx.array([1,2,3]); mx.eval(x*x)
+r={'platform':platform.platform(),'python':platform.python_version(),'device':str(mx.default_device()),'cpu_test':(x*x).tolist(),'packages':{n:m.version(n) for n in ('mlx','mlx-cpu','mlx-lm','transformers','huggingface_hub','torch','torchvision','safetensors')}}
+Path(os.environ['SWIFT_VALIDATION_DIR'],'environment-linux.json').write_text(json.dumps(r,indent=2)+'\n')
+print(json.dumps(r,indent=2))
+PY

compatibility/source-file-manifest.csv

@@ -0,0 +1,31 @@
+FILE,EXPECTED,PRESENT,SIZE_BYTES,SHA256,SOURCE_REVISION,PRESENT_IN_PINNED_HUB
+model-00001-of-00018.safetensors,True,True,3966730552,b9dcb3e15c00823d46d92f645f8a7324cdd1163c39ff6c04de48fa6e478952a0,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00002-of-00018.safetensors,True,True,3043080328,ecf7312565a089592217b58d761e714f3b3d85d4ec578a15d901210a9ba14773,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00003-of-00018.safetensors,True,True,2542796952,cec21a53517089f1b9708a77936465420f266482a45da26fd4c0dd596d609d08,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00004-of-00018.safetensors,True,True,3988973152,3a1a2bfcfd177e62fbe78f08b2b1d3edac59c495397aa64d0d1c41b727a94c73,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00005-of-00018.safetensors,True,True,2099339864,389931270466dcdbc9125bda7572cc7712f164e1fe774e7377524abca899b0c2,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00006-of-00018.safetensors,True,True,3979553696,da6f16eabe6be8552af22ed5ad171ae97469fa5bb5d5e613982460e43265debf,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00007-of-00018.safetensors,True,True,2108759344,b4b9f91766d367f0260882d97b5c0862863c393ef381f54d48dfda3d362072a9,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00008-of-00018.safetensors,True,True,3979553696,df58405d10cb8a199e3e5a01346c6b6ebf2a1bed05d6b11e14f856543b28e55c,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00009-of-00018.safetensors,True,True,2108759344,84ba24193b7d0885ef504ce5806d3d4ebbe5506fdfd5919f4837ebc9479611e6,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00010-of-00018.safetensors,True,True,3979553696,aacd71e34312a13bf487a06c9c54205ad31f72a8788b0a550154a04565820a97,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00011-of-00018.safetensors,True,True,2108759344,6d967f431bdfde43c38839188023c5507d5d0dce6a1daa6bbbf8605ecb3da9aa,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00012-of-00018.safetensors,True,True,3979553696,c36593694bc3f250449ae2196366e6cf788c122dc9a645fbe6ef116746fc5d73,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00013-of-00018.safetensors,True,True,2108759344,b50b55cffe8be40b6eb90c43b1d3cec7672d7f3a86b2efd436db5a83619686d2,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00014-of-00018.safetensors,True,True,3979553696,27b627a940af6ba6f26d240767ca75a4774d02a91255c3a2274dd316e364d1d1,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model-00015-of-00018.safetensors,True,True,2108759344,f9203192d4a759f6fc58c32eebda8a2f00f4a15dc183f06ddc263de49595ade5,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+model-00016-of-00018.safetensors,True,True,3979564040,cf3333f84d3783148a58b24612998ba24b8c60dc69f77e14d86e66ef958c23de,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+model-00017-of-00018.safetensors,True,True,2108759344,e446dd9c79fc0255d9b2181a9a85debb2b5b51b2eb31177c4c1a7daa198221f7,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+model-00018-of-00018.safetensors,True,True,3392197344,2898c2335e6ce74567af2de8373d7468c403fb5e69f4b00f5f7b83fb815d71be,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+chat_template.jinja,True,True,8952,c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+generation_config.json,True,True,202,e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+config.json,True,True,4312,191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+merges.txt,True,True,3353259,a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+preprocessor_config.json,True,True,390,27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+tokenizer_config.json,True,True,17928,b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+video_preprocessor_config.json,True,True,385,7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+vocab.json,True,True,6722759,ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+tokenizer.json,True,True,12809320,0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3,00ccd14e006897d28cb0ed5bf26390e60d274251,False
+EXPORT_MANIFEST.json,True,True,63469,0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+README.md,True,True,2715,56ccec79db878d30b3a39ad7a1ac6d196fdf2e5dfc6c12f6c4c5da29e5561d7e,00ccd14e006897d28cb0ed5bf26390e60d274251,True
+model.safetensors.index.json,True,True,112214,bd9f76c08ed50dccdb8a3de2c4e03a321bf6f506b99f838be11b584f36091461,00ccd14e006897d28cb0ed5bf26390e60d274251,False

compatibility/swift15-mlx-lm.patch

@@ -0,0 +1,962 @@
+diff --git a/mlx_lm/models/qwen3_5_full.py b/mlx_lm/models/qwen3_5_full.py
+new file mode 100644
+index 0000000..eb3d09b
+--- /dev/null
++++ b/mlx_lm/models/qwen3_5_full.py
+@@ -0,0 +1,485 @@
++# Copyright © 2026 Apple Inc.
++
++"""Complete Qwen3.5 parameter model, including the vision encoder and MTP.
++
++Text generation, the vision encoder, and explicit MTP steps are separate APIs.
++Image/video token insertion, multimodal text positions, and speculative decoding
++are not implemented here. Unsupported multimodal calls raise an error.
++"""
++
++import copy
++from dataclasses import dataclass
++from typing import Optional
++
++import mlx.core as mx
++import mlx.nn as nn
++import numpy as np
++from mlx.utils import tree_flatten, tree_unflatten
++
++from . import qwen3_5
++from .base import BaseModelArgs, create_attention_mask
++from .cache import KVCache
++
++
++class OffsetRMSNorm(nn.Module):
++    """Keep HF's zero-centered weights without rounding weight + 1 to BF16."""
++
++    def __init__(self, dims, eps=1e-6):
++        super().__init__()
++        self.weight = mx.zeros((dims,))
++        self.eps = eps
++
++    def __call__(self, x):
++        y = x.astype(mx.float32)
++        y = y * mx.rsqrt(mx.mean(y * y, axis=-1, keepdims=True) + self.eps)
++        return (y * (1 + self.weight.astype(mx.float32))).astype(x.dtype)
++
++
++def _use_offset_norms(module):
++    replacements = [
++        (name, OffsetRMSNorm(norm.weight.shape[0], norm.eps))
++        for name, norm in module.named_modules()
++        if isinstance(norm, nn.RMSNorm)
++    ]
++    module.update_modules(tree_unflatten(replacements))
++
++
++@dataclass
++class VisionArgs(BaseModelArgs):
++    depth: int
++    hidden_size: int
++    intermediate_size: int
++    num_heads: int
++    out_hidden_size: int
++    num_position_embeddings: int
++    patch_size: int = 16
++    temporal_patch_size: int = 2
++    spatial_merge_size: int = 2
++    in_channels: int = 3
++    hidden_act: str = "gelu_pytorch_tanh"
++    deepstack_visual_indexes: Optional[list] = None
++
++    def __post_init__(self):
++        if self.deepstack_visual_indexes:
++            raise ValueError("DeepStack vision features are not supported")
++        if self.hidden_act != "gelu_pytorch_tanh":
++            raise ValueError(f"Unsupported vision activation: {self.hidden_act}")
++        if self.hidden_size % self.num_heads or self.hidden_size // self.num_heads % 4:
++            raise ValueError("Vision head dimension must be divisible by four")
++        if int(self.num_position_embeddings**0.5) ** 2 != self.num_position_embeddings:
++            raise ValueError("Vision position table must be square")
++
++
++class VisionPatchEmbed(nn.Module):
++    def __init__(self, args):
++        super().__init__()
++        self.args = args
++        kernel = (args.temporal_patch_size, args.patch_size, args.patch_size)
++        self.proj = nn.Conv3d(
++            args.in_channels, args.hidden_size, kernel, stride=kernel, bias=True
++        )
++
++    def __call__(self, pixels):
++        a = self.args
++        x = pixels.reshape(
++            -1, a.in_channels, a.temporal_patch_size, a.patch_size, a.patch_size
++        )
++        x = x.transpose(0, 2, 3, 4, 1).astype(self.proj.weight.dtype)
++        return self.proj(x).reshape(-1, a.hidden_size)
++
++
++class VisionAttention(nn.Module):
++    def __init__(self, args):
++        super().__init__()
++        self.num_heads = args.num_heads
++        self.head_dim = args.hidden_size // args.num_heads
++        self.qkv = nn.Linear(args.hidden_size, 3 * args.hidden_size)
++        self.proj = nn.Linear(args.hidden_size, args.hidden_size)
++
++    def __call__(self, x, cos, sin, boundaries):
++        qkv = self.qkv(x).reshape(x.shape[0], 3, self.num_heads, self.head_dim)
++        q, k, v = qkv.transpose(1, 0, 2, 3)
++
++        def rotate(y):
++            z = y.astype(mx.float32)
++            half = self.head_dim // 2
++            rotated = mx.concatenate([-z[..., half:], z[..., :half]], axis=-1)
++            return (z * cos[:, None] + rotated * sin[:, None]).astype(y.dtype)
++
++        q, k = rotate(q), rotate(k)
++        outputs = []
++        for start, end in zip(boundaries, boundaries[1:]):
++            out = mx.fast.scaled_dot_product_attention(
++                q[start:end].transpose(1, 0, 2)[None],
++                k[start:end].transpose(1, 0, 2)[None],
++                v[start:end].transpose(1, 0, 2)[None],
++                scale=self.head_dim**-0.5,
++            )
++            outputs.append(out[0].transpose(1, 0, 2).reshape(end - start, -1))
++        return self.proj(mx.concatenate(outputs, axis=0))
++
++
++class VisionMLP(nn.Module):
++    def __init__(self, args):
++        super().__init__()
++        self.linear_fc1 = nn.Linear(args.hidden_size, args.intermediate_size)
++        self.linear_fc2 = nn.Linear(args.intermediate_size, args.hidden_size)
++
++    def __call__(self, x):
++        return self.linear_fc2(nn.gelu_approx(self.linear_fc1(x)))
++
++
++class VisionBlock(nn.Module):
++    def __init__(self, args):
++        super().__init__()
++        self.norm1 = nn.LayerNorm(args.hidden_size, eps=1e-6)
++        self.norm2 = nn.LayerNorm(args.hidden_size, eps=1e-6)
++        self.attn = VisionAttention(args)
++        self.mlp = VisionMLP(args)
++
++    def __call__(self, x, cos, sin, boundaries):
++        x = x + self.attn(self.norm1(x), cos, sin, boundaries)
++        return x + self.mlp(self.norm2(x))
++
++
++class VisionMerger(nn.Module):
++    def __init__(self, args):
++        super().__init__()
++        self.hidden_size = args.hidden_size * args.spatial_merge_size**2
++        self.norm = nn.LayerNorm(args.hidden_size, eps=1e-6)
++        self.linear_fc1 = nn.Linear(self.hidden_size, self.hidden_size)
++        self.linear_fc2 = nn.Linear(self.hidden_size, args.out_hidden_size)
++
++    def __call__(self, x):
++        x = self.norm(x).reshape(-1, self.hidden_size)
++        return self.linear_fc2(nn.gelu(self.linear_fc1(x)))
++
++
++class VisionModel(nn.Module):
++    def __init__(self, args):
++        super().__init__()
++        self.args = args
++        self.patch_embed = VisionPatchEmbed(args)
++        self.pos_embed = nn.Embedding(args.num_position_embeddings, args.hidden_size)
++        self.blocks = [VisionBlock(args) for _ in range(args.depth)]
++        self.merger = VisionMerger(args)
++
++    def _positions(self, grid_thw):
++        grid = np.asarray(
++            grid_thw.tolist() if hasattr(grid_thw, "tolist") else grid_thw
++        )
++        if (
++            grid.ndim != 2
++            or grid.shape[1] != 3
++            or not np.issubdtype(grid.dtype, np.integer)
++        ):
++            raise ValueError("grid_thw must be an integer array with shape (N, 3)")
++        merge = self.args.spatial_merge_size
++        side = int(self.args.num_position_embeddings**0.5)
++        positions, indices, weights, boundaries = [], [], [], [0]
++        for t, h, w in grid.tolist():
++            if min(t, h, w) <= 0 or h % merge or w % merge:
++                raise ValueError("Invalid vision grid or spatial merge dimensions")
++            hp, wp = np.indices((h, w))
++            block = (h // merge, merge, w // merge, merge)
++            hp = hp.reshape(block).transpose(0, 2, 1, 3).reshape(-1)
++            wp = wp.reshape(block).transpose(0, 2, 1, 3).reshape(-1)
++            positions.append(np.tile(np.stack([hp, wp], axis=-1), (t, 1)))
++            reorder = np.tile(hp * w + wp, t)
++            hs = np.linspace(0, side - 1, h, dtype=np.float32)
++            ws = np.linspace(0, side - 1, w, dtype=np.float32)
++            hf, wf = hs.astype(np.int32), ws.astype(np.int32)
++            hc, wc = np.minimum(hf + 1, side - 1), np.minimum(wf + 1, side - 1)
++            dh, dw = hs - hf, ws - wf
++            idx = [
++                (a[:, None] * side + b[None]).reshape(-1)
++                for a, b in [(hf, wf), (hf, wc), (hc, wf), (hc, wc)]
++            ]
++            coeff = [
++                (a[:, None] * b[None]).reshape(-1)
++                for a, b in [(1 - dh, 1 - dw), (1 - dh, dw), (dh, 1 - dw), (dh, dw)]
++            ]
++            indices.append(np.stack(idx)[:, reorder])
++            weights.append(np.stack(coeff)[:, reorder])
++            offset = boundaries[-1]
++            boundaries.extend(offset + (i + 1) * h * w for i in range(t))
++        if not positions:
++            raise ValueError("At least one vision grid is required")
++        return (
++            mx.array(np.concatenate(positions), dtype=mx.float32),
++            mx.array(np.concatenate(indices, axis=1), dtype=mx.int32),
++            mx.array(np.concatenate(weights, axis=1), dtype=mx.float32),
++            boundaries,
++        )
++
++    def __call__(self, pixels, grid_thw, return_hidden_states=False):
++        positions, indices, weights, boundaries = self._positions(grid_thw)
++        x = self.patch_embed(pixels)
++        if x.shape[0] != boundaries[-1]:
++            raise ValueError("Pixel patch count does not match grid_thw")
++        pos = (self.pos_embed(indices) * weights[..., None]).sum(axis=0)
++        x = x + pos.astype(x.dtype)
++        dim = self.args.hidden_size // self.args.num_heads // 2
++        inv_freq = 1.0 / (10000 ** (mx.arange(0, dim, 2, dtype=mx.float32) / dim))
++        angles = (positions[..., None] * inv_freq).reshape(x.shape[0], -1)
++        angles = mx.concatenate([angles, angles], axis=-1)
++        cos, sin = mx.cos(angles), mx.sin(angles)
++        for block in self.blocks:
++            x = block(x, cos, sin, boundaries)
++        merged = self.merger(x)
++        return (x, merged) if return_hidden_states else merged
++
++
++class MultiTokenPredictor(nn.Module):
++    """An explicit MTP step; embeddings and the output head belong to the LM."""
++
++    def __init__(self, args, num_layers):
++        super().__init__()
++        self.fc = nn.Linear(2 * args.hidden_size, args.hidden_size, bias=False)
++        self.pre_fc_norm_embedding = OffsetRMSNorm(args.hidden_size, args.rms_norm_eps)
++        self.pre_fc_norm_hidden = OffsetRMSNorm(args.hidden_size, args.rms_norm_eps)
++        self.layers = [
++            qwen3_5.DecoderLayer(args, args.full_attention_interval - 1)
++            for _ in range(num_layers)
++        ]
++        self.norm = OffsetRMSNorm(args.hidden_size, args.rms_norm_eps)
++        _use_offset_norms(self)
++
++    def __call__(self, hidden_states, next_token_embeddings, cache=None, step=0):
++        if hidden_states.shape != next_token_embeddings.shape:
++            raise ValueError("MTP hidden states and next-token embeddings must align")
++        if step < 0:
++            raise ValueError("MTP step must be non-negative")
++        x = mx.concatenate(
++            [
++                self.pre_fc_norm_embedding(next_token_embeddings),
++                self.pre_fc_norm_hidden(hidden_states),
++            ],
++            axis=-1,
++        )
++        x = self.fc(x)
++        layer = step % len(self.layers)
++        if cache is not None and len(cache) != len(self.layers):
++            raise ValueError("MTP requires one KV cache per MTP layer")
++        c = cache[layer] if cache is not None else None
++        return self.norm(self.layers[layer](x, create_attention_mask(x, c), c))
++
++    def make_cache(self):
++        return [KVCache() for _ in self.layers]
++
++
++@dataclass
++class ModelArgs(BaseModelArgs):
++    model_type: str
++    text_config: dict
++    vision_config: dict
++    language_model_only: bool = False
++    image_token_id: Optional[int] = None
++    video_token_id: Optional[int] = None
++    vision_start_token_id: Optional[int] = None
++    tie_word_embeddings: bool = False
++    quantization: Optional[dict] = None
++
++    @classmethod
++    def from_dict(cls, params):
++        return super().from_dict(copy.deepcopy(params))
++
++
++class Model(nn.Module):
++    extra_save_files = (
++        "preprocessor_config.json",
++        "video_preprocessor_config.json",
++        "processor_config.json",
++        "tokenizer.json",
++        "tokenizer_config.json",
++        "special_tokens_map.json",
++        "vocab.json",
++        "merges.txt",
++        "chat_template.jinja",
++    )
++
++    def __init__(self, args):
++        super().__init__()
++        self.args = args
++        self.model_type = args.model_type
++        text = args.text_config
++        if args.language_model_only:
++            raise ValueError("The complete model requires language_model_only=false")
++        if text.get("hidden_act", "silu") not in ("silu", "swish"):
++            raise ValueError("Unsupported text MLP activation")
++        if text.get("attn_output_gate", True) is not True:
++            raise ValueError("Ungated attention is not supported")
++        if text.get("output_gate_type", "swish") not in ("swish", "sigmoid"):
++            raise ValueError("Unknown attention gate declaration")
++        if text.get("mtp_use_dedicated_embeddings", False):
++            raise ValueError("Dedicated MTP embeddings are not supported")
++        if args.tie_word_embeddings != text.get("tie_word_embeddings", False):
++            raise ValueError("Conflicting text and top-level weight tying settings")
++        self._text_args = qwen3_5.TextModelArgs.from_dict(copy.deepcopy(text))
++        expected_layers = [
++            (
++                "full_attention"
++                if (i + 1) % self._text_args.full_attention_interval == 0
++                else "linear_attention"
++            )
++            for i in range(self._text_args.num_hidden_layers)
++        ]
++        if text.get("layer_types", expected_layers) != expected_layers:
++            raise ValueError("Layer schedule differs from the supported architecture")
++        if self._text_args.num_experts:
++            raise ValueError("This complete model supports the dense architecture")
++        self.language_model = qwen3_5.TextModel(self._text_args)
++        _use_offset_norms(self.language_model)
++        self.visual = VisionModel(VisionArgs.from_dict(args.vision_config))
++        if self.visual.args.out_hidden_size != self._text_args.hidden_size:
++            raise ValueError("Vision output size does not match text hidden size")
++        num_mtp = text.get("mtp_num_hidden_layers", 0)
++        if num_mtp < 0:
++            raise ValueError("Invalid MTP layer count")
++        if num_mtp:
++            self.mtp = MultiTokenPredictor(self._text_args, num_mtp)
++        self._parameter_shapes = {
++            k: tuple(v.shape) for k, v in tree_flatten(self.parameters())
++        }
++
++    @property
++    def model(self):
++        return self.language_model.model
++
++    @property
++    def layers(self):
++        return self.language_model.layers
++
++    def make_cache(self):
++        return self.language_model.make_cache()
++
++    def __call__(self, inputs, cache=None, input_embeddings=None, **kwargs):
++        if kwargs:
++            raise NotImplementedError(
++                "Multimodal text integration is not implemented; use visual() for encoder features"
++            )
++        for token in (
++            self.args.image_token_id,
++            self.args.video_token_id,
++            self.args.vision_start_token_id,
++        ):
++            if (
++                token is not None
++                and inputs is not None
++                and bool(mx.any(inputs == token))
++            ):
++                raise NotImplementedError(
++                    "Multimodal token positions require a multimodal text runtime"
++                )
++        return self.language_model(inputs, cache, input_embeddings)
++
++    def mtp_logits(self, next_token_ids, previous_hidden_states, cache=None, step=0):
++        if not hasattr(self, "mtp"):
++            raise ValueError("This checkpoint has no MTP layers")
++        embeddings = self.model.embed_tokens(next_token_ids)
++        hidden = self.mtp(previous_hidden_states, embeddings, cache, step)
++        if self._text_args.tie_word_embeddings:
++            return self.model.embed_tokens.as_linear(hidden)
++        return self.language_model.lm_head(hidden)
++
++    def weight_mapping(self):
++        rows = []
++        for name, shape in sorted(self._parameter_shapes.items()):
++            source, source_shape, transform = name, shape, "identity"
++            if name.startswith("language_model.model."):
++                source = "model.language_model." + name[len("language_model.model.") :]
++            elif name.startswith("language_model.lm_head."):
++                source = name[len("language_model.") :]
++            elif name.startswith("visual."):
++                source = "model." + name
++            if name.endswith(".conv1d.weight"):
++                source_shape = (shape[0], shape[2], shape[1])
++                transform = "transpose(0,2,1)"
++            elif name == "visual.patch_embed.proj.weight":
++                source_shape = (shape[0], shape[4], shape[1], shape[2], shape[3])
++                transform = "transpose(0,2,3,4,1)"
++            category = (
++                "vision"
++                if name.startswith("visual.")
++                else "MTP" if name.startswith("mtp.") else "text"
++            )
++            rows.append(
++                dict(
++                    source=source,
++                    source_shape=source_shape,
++                    destination=name,
++                    destination_shape=shape,
++                    category=category,
++                    transform=transform,
++                )
++            )
++        return rows
++
++    def sanitize(self, weights):
++        rows = self.weight_mapping()
++        hf_names = {r["source"] for r in rows}
++        native_names = set(self._parameter_shapes)
++        is_hf = any(k.startswith("model.language_model.") for k in weights)
++        expected = hf_names if is_hf else native_names
++        if self.args.quantization:
++            if is_hf:
++                raise ValueError("Only original unquantized HF weights can be mapped")
++            return self._check_native_quantized(weights)
++        missing, unexpected = expected - set(weights), set(weights) - expected
++        if missing or unexpected:
++            raise ValueError(
++                f"Incomplete weight mapping: missing={sorted(missing)}, unexpected={sorted(unexpected)}"
++            )
++        mapped = {}
++        for row in rows:
++            key = row["source"] if is_hf else row["destination"]
++            value = weights[key]
++            shape = row["source_shape"] if is_hf else row["destination_shape"]
++            if tuple(value.shape) != shape:
++                raise ValueError(f"Shape mismatch for {key}: {value.shape} != {shape}")
++            if is_hf and row["transform"] == "transpose(0,2,1)":
++                value = value.transpose(0, 2, 1)
++            elif is_hf and row["transform"] == "transpose(0,2,3,4,1)":
++                value = value.transpose(0, 2, 3, 4, 1)
++            mapped[row["destination"]] = value
++        return mapped
++
++    def _check_native_quantized(self, weights):
++        shapes = dict(self._parameter_shapes)
++        q = self.args.quantization
++        for path, module in self.named_modules():
++            if not hasattr(module, "to_quantized"):
++                continue
++            settings = q.get(path, q)
++            if settings is False:
++                continue
++            if not isinstance(settings, dict):
++                raise ValueError(f"Invalid native quantization metadata for {path}")
++            bits, group, mode = (
++                settings.get("bits"),
++                settings.get("group_size"),
++                settings.get("mode", "affine"),
++            )
++            if (bits, group, mode) != (4, 64, "affine"):
++                raise ValueError(
++                    "This extension only prepares affine/4-bit/group-64 native checkpoints"
++                )
++            original = shapes[f"{path}.weight"]
++            if original[-1] % group:
++                continue
++            shapes[f"{path}.weight"] = (*original[:-1], original[-1] * bits // 32)
++            shapes[f"{path}.scales"] = (*original[:-1], original[-1] // group)
++            shapes[f"{path}.biases"] = shapes[f"{path}.scales"]
++        missing, unexpected = set(shapes) - set(weights), set(weights) - set(shapes)
++        if missing or unexpected:
++            raise ValueError(
++                f"Incomplete native checkpoint: missing={sorted(missing)}, unexpected={sorted(unexpected)}"
++            )
++        for name, shape in shapes.items():
++            if tuple(weights[name].shape) != shape:
++                raise ValueError(f"Native checkpoint shape mismatch: {name}")
++        return weights
++
++    @property
++    def cast_predicate(self):
++        return self.language_model.cast_predicate
+diff --git a/mlx_lm/utils.py b/mlx_lm/utils.py
+index a00fed8..6a751a2 100644
+--- a/mlx_lm/utils.py
++++ b/mlx_lm/utils.py
+@@ -195,6 +195,13 @@ def _transform_awq_weights(
+     return new_weights, mlx_quantization
+ 
+ 
++def _is_complete_qwen3_5(config: dict) -> bool:
++    return (
++        config.get("model_type") == "qwen3_5"
++        and config.get("language_model_only") is False
++    )
++
++
+ def _get_classes(config: dict):
+     """
+     Retrieve the model and model args classes based on the configuration.
+@@ -216,6 +223,8 @@ def _get_classes(config: dict):
+             break
+     else:
+         model_type = MODEL_REMAPPING.get(model_type, model_type)
++    if _is_complete_qwen3_5(config):
++        model_type = "qwen3_5_full"
+     try:
+         arch = importlib.import_module(f"mlx_lm.models.{model_type}")
+     except ImportError as e:
+@@ -446,12 +455,35 @@ def load_model(
+ 
+     weight_files = glob.glob(str(model_path / "model*.safetensors"))
+ 
++    complete_qwen = _is_complete_qwen3_5(config)
++    if complete_qwen:
++        with open(model_path / "model.safetensors.index.json") as stream:
++            index = json.load(stream)
++        expected_files = set(index["weight_map"].values())
++        actual_files = {Path(file).name for file in weight_files}
++        if actual_files != expected_files:
++            raise ValueError(
++                "Incomplete full-model checkpoint: "
++                f"missing shards={sorted(expected_files - actual_files)}, "
++                f"unexpected shards={sorted(actual_files - expected_files)}"
++            )
++
+     if not weight_files and strict:
+         raise FileNotFoundError(f"No safetensors found in {model_path}")
+ 
+     weights = {}
+     for wf in weight_files:
+-        weights.update(mx.load(wf))
++        shard = mx.load(wf)
++        if complete_qwen:
++            duplicates = weights.keys() & shard.keys()
++            if duplicates:
++                raise ValueError(f"Duplicate checkpoint tensors: {sorted(duplicates)}")
++            for name in shard:
++                if index["weight_map"].get(name) != Path(wf).name:
++                    raise ValueError(f"Checkpoint index mismatch: {name}")
++        weights.update(shard)
++    if complete_qwen and weights.keys() != index["weight_map"].keys():
++        raise ValueError("Checkpoint tensor set does not match its index")
+ 
+     if (model_file := config.get("model_file")) is not None:
+         if not trust_remote_code:
+@@ -1064,9 +1096,11 @@ def save_config(
+         config (dict): The model configuration.
+         config_path (Union[str, Path]): Model configuration file path.
+     """
+-    # Clean unused keys
++    config = copy.deepcopy(config)
++    # Complete multimodal checkpoints need the vision architecture on reload.
+     config.pop("_name_or_path", None)
+-    config.pop("vision_config", None)
++    if not _is_complete_qwen3_5(config):
++        config.pop("vision_config", None)
+     if "quantization" in config:
+         config["quantization_config"] = config["quantization"]
+ 
+@@ -1099,7 +1133,8 @@ def save(
+     save_config(config, config_path=dst_path / "config.json")
+     tokenizer.save_pretrained(dst_path)
+ 
+-    for p in ["*.py", "generation_config.json"]:
++    extra_files = getattr(model, "extra_save_files", ())
++    for p in ["*.py", "generation_config.json", *extra_files]:
+         for file in glob.glob(str(src_path / p)):
+             shutil.copy(file, dst_path)
+ 
+diff --git a/tests/test_qwen3_5_full.py b/tests/test_qwen3_5_full.py
+new file mode 100644
+index 0000000..2b3e5ae
+--- /dev/null
++++ b/tests/test_qwen3_5_full.py
+@@ -0,0 +1,377 @@
++# Copyright © 2026 Apple Inc.
++
++"""Small synthetic fixtures test architecture code, not Swift model quality."""
++
++import copy
++import json
++from pathlib import Path
++from unittest.mock import patch
++
++import mlx.core as mx
++import numpy as np
++import pytest
++import torch
++from mlx.utils import tree_flatten
++from mlx_lm.convert import convert
++from mlx_lm.models.qwen3_5_full import Model, ModelArgs, OffsetRMSNorm
++from mlx_lm.utils import _get_classes, load_model, save_config
++from transformers import Qwen3_5Config, Qwen3_5ForConditionalGeneration
++from transformers.models.qwen3_5.modeling_qwen3_5 import (
++    Qwen3_5DecoderLayer,
++    Qwen3_5RMSNorm,
++    Qwen3_5TextRotaryEmbedding,
++)
++
++
++def small_config():
++    return {
++        "model_type": "qwen3_5",
++        "architectures": ["Qwen3_5ForConditionalGeneration"],
++        "language_model_only": False,
++        "tie_word_embeddings": False,
++        "image_token_id": 125,
++        "video_token_id": 126,
++        "vision_start_token_id": 127,
++        "text_config": {
++            "model_type": "qwen3_5_text",
++            "hidden_size": 128,
++            "intermediate_size": 256,
++            "num_hidden_layers": 4,
++            "num_attention_heads": 4,
++            "num_key_value_heads": 2,
++            "head_dim": 32,
++            "vocab_size": 128,
++            "full_attention_interval": 4,
++            "layer_types": ["linear_attention"] * 3 + ["full_attention"],
++            "linear_num_key_heads": 2,
++            "linear_num_value_heads": 4,
++            "linear_key_head_dim": 32,
++            "linear_value_head_dim": 32,
++            "linear_conv_kernel_dim": 4,
++            "hidden_act": "silu",
++            "attn_output_gate": True,
++            "output_gate_type": "swish",
++            "mamba_ssm_dtype": "float32",
++            "rms_norm_eps": 1e-6,
++            "max_position_embeddings": 256,
++            "tie_word_embeddings": False,
++            "attention_bias": False,
++            "attention_dropout": 0.0,
++            "mtp_num_hidden_layers": 1,
++            "mtp_use_dedicated_embeddings": False,
++            "rope_parameters": {
++                "rope_type": "default",
++                "rope_theta": 10000000,
++                "partial_rotary_factor": 0.5,
++                "mrope_interleaved": True,
++                "mrope_section": [3, 3, 2],
++            },
++        },
++        "vision_config": {
++            "model_type": "qwen3_5",
++            "depth": 2,
++            "hidden_size": 32,
++            "intermediate_size": 48,
++            "num_heads": 4,
++            "out_hidden_size": 128,
++            "num_position_embeddings": 16,
++            "patch_size": 2,
++            "temporal_patch_size": 2,
++            "spatial_merge_size": 2,
++            "in_channels": 3,
++            "hidden_act": "gelu_pytorch_tanh",
++            "deepstack_visual_indexes": [],
++        },
++    }
++
++
++class ReferenceMTP(torch.nn.Module):
++    """Single-step composition used by the source vLLM MTP implementation."""
++
++    def __init__(self, args):
++        super().__init__()
++        h = args.hidden_size
++        self.fc = torch.nn.Linear(2 * h, h, bias=False)
++        self.pre_fc_norm_embedding = Qwen3_5RMSNorm(h, args.rms_norm_eps)
++        self.pre_fc_norm_hidden = Qwen3_5RMSNorm(h, args.rms_norm_eps)
++        self.layers = torch.nn.ModuleList([Qwen3_5DecoderLayer(args, 3)])
++        self.norm = Qwen3_5RMSNorm(h, args.rms_norm_eps)
++        self.rotary = Qwen3_5TextRotaryEmbedding(args)
++
++    def forward(self, hidden, embeds):
++        x = self.fc(
++            torch.cat(
++                [self.pre_fc_norm_embedding(embeds), self.pre_fc_norm_hidden(hidden)],
++                dim=-1,
++            )
++        )
++        positions = torch.arange(x.shape[1])[None, None].expand(3, x.shape[0], -1)
++        rotary = self.rotary(x, positions)
++        mask = torch.triu(
++            torch.full((x.shape[0], 1, x.shape[1], x.shape[1]), float("-inf")),
++            diagonal=1,
++        )
++        return self.norm(
++            self.layers[0](x, position_embeddings=rotary, attention_mask=mask)
++        )
++
++
++@pytest.fixture(scope="module")
++def reference():
++    torch.set_num_threads(2)
++    torch.manual_seed(71)
++    config = small_config()
++    hf_config = Qwen3_5Config(**copy.deepcopy(config))
++    hf_config._attn_implementation = "eager"
++    hf_config.text_config._attn_implementation = "eager"
++    hf_config.vision_config._attn_implementation = "eager"
++    hf = Qwen3_5ForConditionalGeneration(hf_config).eval()
++    mtp = ReferenceMTP(hf_config.text_config).eval()
++    with torch.no_grad():
++        for module in (hf, mtp):
++            for name, value in module.named_parameters():
++                if "norm" in name and value.ndim == 1 and "model.visual" not in name:
++                    value.uniform_(-0.15, 0.15)
++    state = {k: mx.array(v.detach().numpy()) for k, v in hf.state_dict().items()}
++    state.update(
++        {"mtp." + k: mx.array(v.detach().numpy()) for k, v in mtp.state_dict().items()}
++    )
++    model = Model(ModelArgs.from_dict(config))
++    model.load_weights(list(model.sanitize(state).items()), strict=True)
++    model.eval()
++    return config, hf, mtp, state, model
++
++
++def assert_close(mlx_value, torch_value, atol=3e-5, rtol=3e-5):
++    np.testing.assert_allclose(
++        np.array(mlx_value), torch_value.detach().numpy(), atol=atol, rtol=rtol
++    )
++
++
++def test_dispatch_and_mapping_preserve_every_component(reference):
++    config, _, _, state, model = reference
++    before = copy.deepcopy(config)
++    cls, args = _get_classes(config)
++    fresh = cls(args.from_dict(config))
++    assert cls is Model
++    assert config == before
++    rows = fresh.weight_mapping()
++    assert {r["source"] for r in rows} == set(state)
++    assert len(rows) == len(dict(tree_flatten(model.parameters())))
++    assert sum(r["category"] == "MTP" for r in rows) == 15
++    assert sum(r["category"] == "vision" for r in rows) == 33
++    assert model.language_model.lm_head is not model.model.embed_tokens
++    assert not any("mtp.embed" in r["destination"] for r in rows)
++
++
++@pytest.mark.parametrize("prefix", ["model.language_model.", "model.visual.", "mtp."])
++def test_missing_critical_tensor_is_rejected(reference, prefix):
++    _, _, _, state, model = reference
++    missing = dict(state)
++    missing.pop(next(k for k in state if k.startswith(prefix)))
++    with pytest.raises(ValueError, match="missing="):
++        model.sanitize(missing)
++
++
++def test_unexpected_and_misshaped_tensors_are_rejected(reference):
++    _, _, _, state, model = reference
++    with pytest.raises(ValueError, match="unexpected="):
++        model.sanitize(dict(state, **{"mtp.unknown.weight": mx.zeros((1,))}))
++    wrong = dict(state)
++    wrong["mtp.fc.weight"] = mx.zeros((1,))
++    with pytest.raises(ValueError, match="Shape mismatch"):
++        model.sanitize(wrong)
++
++
++def test_native_mapping_is_idempotent_and_norm_values_are_exact(reference):
++    _, _, _, state, model = reference
++    once = model.sanitize(state)
++    twice = model.sanitize(once)
++    for key in once:
++        np.testing.assert_array_equal(np.array(once[key]), np.array(twice[key]))
++    for row in model.weight_mapping():
++        if "norm" in row["source"]:
++            np.testing.assert_array_equal(
++                np.array(state[row["source"]]), np.array(once[row["destination"]])
++            )
++
++
++def test_offset_norm_preserves_small_bf16_deltas():
++    layer = OffsetRMSNorm(4)
++    raw = mx.array([0.0001, -0.0002, 0.0003, -0.0004], dtype=mx.bfloat16)
++    layer.weight = raw
++    x = mx.array([[0.8, -1.2, 0.4, 2.0]], dtype=mx.bfloat16)
++    torch_layer = Qwen3_5RMSNorm(4)
++    torch_layer.weight.data.copy_(torch.tensor(np.array(raw.astype(mx.float32))))
++    expected = torch_layer(
++        torch.tensor(np.array(x.astype(mx.float32))).to(torch.bfloat16)
++    ).float()
++    assert_close(layer(x).astype(mx.float32), expected, atol=0, rtol=0)
++    np.testing.assert_array_equal(
++        np.array(layer.weight.astype(mx.float32)), np.array(raw.astype(mx.float32))
++    )
++
++
++def test_text_forward_matches_transformers(reference):
++    _, hf, _, _, model = reference
++    ids = torch.tensor([[3, 19, 8, 21, 11]])
++    with torch.no_grad():
++        expected = hf(input_ids=ids, use_cache=False).logits
++    actual = model(mx.array(ids.numpy()))
++    assert_close(actual, expected)
++
++
++def test_text_decode_cache_matches_full_forward(reference):
++    _, _, _, _, model = reference
++    ids = mx.array([[3, 19, 8, 21, 11]])
++    full = model(ids)
++    cache = model.make_cache()
++    parts = [model(ids[:, :3], cache)]
++    parts.extend(model(ids[:, i : i + 1], cache) for i in range(3, 5))
++    np.testing.assert_allclose(
++        np.array(mx.concatenate(parts, axis=1)), np.array(full), atol=3e-5, rtol=3e-5
++    )
++
++
++@pytest.mark.parametrize("grid", [[[1, 4, 4]], [[2, 2, 4], [1, 4, 2]], [[1, 6, 4]]])
++def test_vision_encoder_matches_transformers(reference, grid):
++    _, hf, _, _, model = reference
++    torch.manual_seed(11)
++    count = sum(t * h * w for t, h, w in grid)
++    pixels = torch.randn(count, 3 * 2 * 2 * 2)
++    with torch.no_grad():
++        expected = hf.model.visual(pixels, torch.tensor(grid))
++    hidden, pooled = model.visual(
++        mx.array(pixels.numpy()), grid, return_hidden_states=True
++    )
++    assert_close(hidden, expected.last_hidden_state)
++    assert_close(pooled, expected.pooler_output)
++
++
++def test_mtp_forward_and_shared_head_match_reference(reference):
++    _, hf, mtp, _, model = reference
++    torch.manual_seed(9)
++    hidden = torch.randn(1, 4, 128)
++    ids = torch.tensor([[9, 8, 7, 6]])
++    with torch.no_grad():
++        embeds = hf.model.language_model.embed_tokens(ids)
++        expected = mtp(hidden, embeds)
++        expected_logits = hf.lm_head(expected)
++    assert_close(
++        model.mtp(mx.array(hidden.numpy()), mx.array(embeds.numpy())), expected
++    )
++    assert_close(
++        model.mtp_logits(mx.array(ids.numpy()), mx.array(hidden.numpy())),
++        expected_logits,
++    )
++    cache = model.mtp.make_cache()
++    cached = mx.concatenate(
++        [
++            model.mtp(
++                mx.array(hidden[:, i : i + 1].numpy()),
++                mx.array(embeds[:, i : i + 1].numpy()),
++                cache,
++            )
++            for i in range(4)
++        ],
++        axis=1,
++    )
++    assert_close(cached, expected)
++
++
++def test_unsupported_multimodal_generation_fails_explicitly(reference):
++    _, _, _, _, model = reference
++    with pytest.raises(NotImplementedError, match="Multimodal"):
++        model(mx.array([[1, 2]]), pixel_values=mx.zeros((1, 24)))
++    with pytest.raises(NotImplementedError, match="Multimodal"):
++        model(mx.array([[1, 125]]))
++
++
++def test_save_config_keeps_vision_and_does_not_mutate_input(tmp_path):
++    config = small_config()
++    before = copy.deepcopy(config)
++    save_config(config, tmp_path / "config.json")
++    assert config == before
++    assert json.loads((tmp_path / "config.json").read_text()) == before
++
++
++def test_official_nonquantized_convert_and_reload_preserve_all_tensors(
++    reference, tmp_path
++):
++    config, _, _, state, model = reference
++    source, output = tmp_path / "hf", tmp_path / "mlx"
++    source.mkdir()
++    (source / "config.json").write_text(json.dumps(config))
++    mx.save_safetensors(str(source / "model.safetensors"), state)
++    (source / "model.safetensors.index.json").write_text(
++        json.dumps({"weight_map": {k: "model.safetensors" for k in state}})
++    )
++    assets = ["generation_config.json", *model.extra_save_files]
++    for name in assets:
++        (source / name).write_text("original synthetic asset: " + name)
++    (source / "generation_config.json").write_text('{"eos_token_id": 2}')
++
++    class FixtureTokenizer:
++        def save_pretrained(self, target):
++            Path(target, "tokenizer_config.json").write_text("rewritten")
++
++    def fixture_load(path, **kwargs):
++        loaded, loaded_config = load_model(Path(path), lazy=True, strict=True)
++        return loaded, FixtureTokenizer(), loaded_config
++
++    with patch("mlx_lm.convert.load", side_effect=fixture_load):
++        convert(str(source), str(output), quantize=False)
++    loaded, saved_config = load_model(output, lazy=False, strict=True)
++    expected = model.sanitize(state)
++    actual = dict(tree_flatten(loaded.parameters()))
++    assert set(actual) == set(expected)
++    for name in actual:
++        np.testing.assert_array_equal(np.array(actual[name]), np.array(expected[name]))
++    assert saved_config["vision_config"] == config["vision_config"]
++    assert saved_config["text_config"] == config["text_config"]
++    assert "quantization" not in saved_config
++    for name in assets:
++        assert (source / name).read_bytes() == (output / name).read_bytes()
++    ids = mx.array([[3, 19, 8]])
++    np.testing.assert_array_equal(np.array(model(ids)), np.array(loaded(ids)))
++    (output / "model.safetensors.index.json").write_text(
++        json.dumps(
++            {
++                "weight_map": {
++                    **{k: "model.safetensors" for k in actual},
++                    "mtp.missing.weight": "missing.safetensors",
++                }
++            }
++        )
++    )
++    with pytest.raises(ValueError, match="missing shards"):
++        load_model(output, lazy=True)
++
++
++def test_fixed_affine_quantized_roundtrip_preserves_component_tree(reference, tmp_path):
++    from mlx_lm.utils import quantize_model, save_model
++
++    config, _, _, state, _ = reference
++    model = Model(ModelArgs.from_dict(config))
++    model.load_weights(list(model.sanitize(state).items()), strict=True)
++    original_names = set(dict(tree_flatten(model.parameters())))
++    model, quantized_config = quantize_model(model, config, 64, 4, mode="affine")
++    save_model(tmp_path, model)
++    save_config(quantized_config, tmp_path / "config.json")
++    loaded, saved_config = load_model(tmp_path, lazy=False, strict=True)
++    actual = dict(tree_flatten(loaded.parameters()))
++    expected = dict(tree_flatten(model.parameters()))
++    assert set(actual) == set(expected)
++    assert original_names <= set(actual)
++    assert saved_config["quantization"] == {
++        "bits": 4,
++        "group_size": 64,
++        "mode": "affine",
++    }
++    for name in actual:
++        np.testing.assert_array_equal(np.array(actual[name]), np.array(expected[name]))
++    assert bool(mx.all(mx.isfinite(loaded(mx.array([[3, 19, 8]])))))
++    missing = dict(actual)
++    missing.pop("mtp.fc.scales")
++    with pytest.raises(ValueError, match="Incomplete native checkpoint"):
++        loaded.sanitize(missing)

compatibility/validate-mac-format.py

@@ -0,0 +1,57 @@
+"""Validate complete native parameter headers and real Q4 samples on Metal.
+
+This is not a full 27B Mac generation test. Header fixtures are never saved.
+"""
+import importlib.metadata
+import argparse
+import json
+import platform
+import resource
+from pathlib import Path
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+from mlx.utils import tree_flatten
+from mlx_lm.utils import _get_classes
+
+parser=argparse.ArgumentParser(description=__doc__)
+parser.add_argument('--folder',type=Path,default=Path(__file__).resolve().parent/'mac-check')
+parser.add_argument('--output',type=Path,default=Path('mac-compatibility-results.json'))
+options=parser.parse_args()
+folder=options.folder
+assert platform.system()=='Darwin' and platform.machine()=='arm64'
+assert mx.metal.is_available()
+mx.set_default_device(mx.gpu)
+config=json.loads((folder/'config.json').read_text())
+assert config['quantization']=={'group_size':64,'bits':4,'mode':'affine'}
+headers=json.loads((folder/'checkpoint-headers.json').read_text())
+index=json.loads((folder/'model.safetensors.index.json').read_text())
+assert set(headers)==set(index['weight_map'])
+cls,args=_get_classes(config)
+model=cls(args.from_dict(config))
+dtype={'BF16':mx.bfloat16,'F16':mx.float16,'F32':mx.float32,'U32':mx.uint32}
+fixtures={k:mx.broadcast_to(mx.array(0,dtype=dtype[v['dtype']]),v['shape']) for k,v in headers.items()}
+fixtures=model.sanitize(fixtures)
+nn.quantize(model,group_size=64,bits=4,mode='affine',class_predicate=lambda path,module: path+'.scales' in fixtures)
+model.load_weights(list(fixtures.items()),strict=True)
+assert set(dict(tree_flatten(model.parameters())))==set(headers)
+assert len(model.weight_mapping())==1199
+del fixtures,model
+
+samples=mx.load(str(folder/'real-checkpoint-samples.safetensors'))
+description=json.loads((folder/'samples.json').read_text())
+results=[]
+for item in description['samples']:
+    prefix=f"sample_{item['sample']}."
+    x,w,s,b,ref=[samples[prefix+k] for k in ('input','weight','scales','biases','fp32_reference')]
+    assert w.dtype==mx.uint32 and s.dtype==mx.bfloat16 and b.dtype==mx.bfloat16
+    native=mx.quantized_matmul(x,w,s,b,transpose=True,group_size=64,bits=4,mode='affine')
+    fp32=mx.quantized_matmul(x.astype(mx.float32),w,s.astype(mx.float32),b.astype(mx.float32),transpose=True,group_size=64,bits=4,mode='affine')
+    mx.eval(native,fp32,ref)
+    a,r,f=[np.array(value.astype(mx.float32)) for value in (native,ref,fp32)]
+    np.testing.assert_allclose(a,r,atol=0.01,rtol=0.02)
+    np.testing.assert_allclose(f,r,atol=1e-4,rtol=5e-4)
+    results.append(dict(item,native_metal_bf16='PASS',metal_fp32='PASS',bf16_max_absolute_error=float(np.max(np.abs(a-r))),fp32_max_absolute_error=float(np.max(np.abs(f-r)))))
+result={'status':'PASS_MAC_NATIVE_MLX_FORMAT_AND_REAL_METAL_SAMPLES','platform':platform.platform(),'machine':platform.machine(),'mlx':importlib.metadata.version('mlx'),'mlx_lm':importlib.metadata.version('mlx-lm'),'device':str(mx.default_device()),'quantization':config['quantization'],'all_saved_tensor_headers_validated':len(headers),'all_source_parameters_accounted_for':1199,'strict_complete_parameter_tree':'PASS using unevaluated header fixtures; no fabricated weights saved','actual_checkpoint_samples':results,'full_model_mac_generation':'NOT_RUN: targeted native Metal format and real-weight component checks only','peak_mlx_bytes':mx.get_peak_memory(),'peak_process_rss_bytes':resource.getrusage(resource.RUSAGE_SELF).ru_maxrss}
+with options.output.open('x') as stream:json.dump(result,stream,indent=2)
+print(json.dumps(result,indent=2))

compatibility/validate-quant.py

@@ -0,0 +1,134 @@
+"""Validate the saved real Swift MLX artifact, including all components."""
+import hashlib
+import json
+import platform
+import resource
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+import os
+
+import mlx.core as mx
+from mlx.utils import tree_flatten
+from mlx_lm import load, stream_generate
+from mlx_lm.sample_utils import make_sampler
+from transformers import AutoProcessor, AutoTokenizer
+from PIL import Image
+
+root = Path(__file__).resolve().parents[1]
+source = Path(os.environ['SWIFT_SOURCE_DIR']).resolve(strict=True)
+output = Path(os.environ.get('SWIFT_MLX_OUTPUT', root / 'Swift-1.5-4bit-MLX')).resolve(strict=True)
+logs = Path(os.environ.get('SWIFT_VALIDATION_DIR', root / 'validation-output')).resolve(strict=True)
+verified = json.loads((logs / 'source-verification.json').read_text())
+conversion = json.loads((logs / 'conversion-result.json').read_text())
+assert conversion['returncode'] == 0
+assert not (logs / 'quant-validation-results.json').exists()
+mx.set_default_device(mx.cpu)
+start = time.monotonic()
+model, tokenizer, config = load(str(output), lazy=False, return_config=True)
+load_seconds = time.monotonic() - start
+load_memory = mx.get_active_memory()
+parameters = dict(tree_flatten(model.parameters()))
+assert type(model).__module__ == 'mlx_lm.models.qwen3_5_full'
+assert config['quantization'] == {'mode': 'affine', 'bits': 4, 'group_size': 64}
+assert config['vision_config'] == verified['config']['vision_config']
+assert config['text_config'] == verified['config']['text_config']
+assert config['tie_word_embeddings'] == verified['config']['tie_word_embeddings']
+rows = model.weight_mapping()
+assert {r['source'] for r in rows} == set(verified['tensors'])
+assert len(rows) == 1199
+accounted = set()
+for row in rows:
+    assert list(row['source_shape']) == verified['tensors'][row['source']]['shape']
+    name = row['destination']
+    assert name in parameters, name
+    native = [name]
+    if name.endswith('.weight') and name[:-7]+'.scales' in parameters:
+        native += [name[:-7]+'.scales', name[:-7]+'.biases']
+        assert parameters[name].dtype == mx.uint32
+        row['storage'] = 'affine/4-bit/group-size-64'
+    else:
+        assert parameters[name].dtype == mx.bfloat16, name
+        row['storage'] = 'original BF16, with the documented layout mapping'
+    row['saved_tensors'] = native
+    accounted.update(native)
+assert accounted == set(parameters)
+categories = dict(Counter(r['category'] for r in rows))
+assert categories == {'text': 851, 'MTP': 15, 'vision': 333}
+for name, value in parameters.items():
+    if mx.issubdtype(value.dtype, mx.floating):
+        assert bool(mx.all(mx.isfinite(value))), f'Nonfinite values in {name}'
+print(f'Loaded {len(parameters)} saved tensors; all 1199 source tensors accounted for.', flush=True)
+
+# Compare every unquantized source tensor bit-for-bit after its required layout change.
+unchanged = [r for r in rows if r['storage'].startswith('original BF16')]
+for shard in sorted({verified['tensors'][r['source']]['shard'] for r in unchanged}):
+    raw = mx.load(str(source / shard))
+    for row in unchanged:
+        if verified['tensors'][row['source']]['shard'] != shard:
+            continue
+        value = raw[row['source']]
+        if row['transform'] == 'transpose(0,2,1)':
+            value = value.transpose(0, 2, 1)
+        elif row['transform'] == 'transpose(0,2,3,4,1)':
+            value = value.transpose(0, 2, 3, 4, 1)
+        assert bool(mx.all(value == parameters[row['destination']])), row['source']
+    del raw
+print(f'All {len(unchanged)} unquantized tensors equal the original BF16 values.', flush=True)
+
+assets = {}
+for name in ['generation_config.json', *model.extra_save_files]:
+    if (source / name).is_file():
+        assert (source / name).read_bytes() == (output / name).read_bytes(), name
+        assets[name] = hashlib.sha256((output / name).read_bytes()).hexdigest()
+hf_tokenizer = AutoTokenizer.from_pretrained(output, local_files_only=True, trust_remote_code=False)
+processor = AutoProcessor.from_pretrained(output, local_files_only=True, trust_remote_code=False)
+chats = []
+for options in ({'enable_thinking': False}, {'reasoning_effort': 'low'}, {'reasoning_effort': 'xhigh'}):
+    prompt = hf_tokenizer.apply_chat_template([{'role': 'user', 'content': 'Say hello.'}], tokenize=False, add_generation_prompt=True, **options)
+    assert prompt and hf_tokenizer.encode(prompt, add_special_tokens=False)
+    chats.append({'options': options, 'rendered': prompt})
+mapping = {'source_tensors':1199, 'mapped_source_tensors':1199, 'native_tensors':len(parameters), 'ignored':0, 'unexplained':0, 'rows':rows}
+mapping_path = logs / 'quant-tensor-mapping-manifest.json'
+if mapping_path.exists():
+    assert json.loads(mapping_path.read_text()) == json.loads(json.dumps(mapping))
+else:
+    with mapping_path.open('x') as f:
+        json.dump(mapping, f, indent=2)
+
+# The official Linux scalar BF16 QMM accumulates in BF16 (8192 ones -> 256).
+# Promote only in-memory floating values; packed 4-bit tensors/files stay unchanged.
+model.apply(lambda value: value.astype(mx.float32) if mx.issubdtype(value.dtype, mx.floating) else value)
+mx.eval(model.parameters())
+print('CPU inference uses FP32 floating values; saved 4-bit weights are unchanged.', flush=True)
+
+prompt = tokenizer.apply_chat_template([{'role':'user','content':'Reply with exactly: Hello from Swift.'}], tokenize=False, add_generation_prompt=True, enable_thinking=False)
+pieces, tokens, last = [], [], None
+generation_start = time.monotonic()
+for response in stream_generate(model, tokenizer, prompt=prompt, max_tokens=24, sampler=make_sampler(temp=0.0), prefill_step_size=64):
+    assert bool(mx.all(mx.isfinite(response.logprobs))), 'Nonfinite generation probabilities'
+    pieces.append(response.text); tokens.append(response.token); last = response
+    print(response.text, end='', flush=True)
+generated = ''.join(pieces)
+assert generated.strip(), 'Empty text generation'
+print('\nText generation passed.', flush=True)
+generation = {'prompt':prompt, 'text':generated, 'token_ids':tokens, 'tokens':last.generation_tokens, 'tokens_per_second':last.generation_tps, 'prompt_tokens_per_second':last.prompt_tps, 'elapsed_seconds':time.monotonic()-generation_start, 'finish_reason':last.finish_reason}
+
+ids = mx.array([hf_tokenizer.encode('Hello', add_special_tokens=False)[:2]], dtype=mx.int32)
+hidden = model.model(ids)
+mtp = model.mtp_logits(ids, hidden)
+mx.eval(mtp)
+assert bool(mx.all(mx.isfinite(mtp)))
+mtp_result = {'status':'PASS', 'shape':list(mtp.shape), 'path':'Explicit MTP step with real text hidden states and shared LM head; speculative generation is not integrated'}
+print('Real-weight MTP step passed.', flush=True)
+pixels = processor.image_processor(images=[Image.new('RGB', (256,256), (64,128,192))], return_tensors='np')
+features = model.visual(mx.array(pixels['pixel_values']), pixels['image_grid_thw'])
+mx.eval(features)
+assert bool(mx.all(mx.isfinite(features)))
+vision_result = {'status':'PASS', 'shape':list(features.shape), 'grid':pixels['image_grid_thw'].tolist(), 'path':'Vision encoder only; image/video insertion and multimodal text generation are not implemented'}
+print('Real-weight vision encoder passed.', flush=True)
+
+result = {'status':'PASS', 'recorded_at':datetime.now(timezone.utc).isoformat(), 'source_repo':conversion['source_repo'], 'source_revision':conversion['source_revision'], 'source_shards':18, 'source_shard_bytes':verified['shard_bytes'], 'source_tensors':1199, 'mapped_source_tensors':1199, 'saved_tensors':len(parameters), 'categories':categories, 'ignored_tensors':0, 'unexplained_tensors':0, 'exact_unquantized_tensors':len(unchanged), 'quantization':config['quantization'], 'all_floating_tensors_finite':True, 'tokenizer':type(hf_tokenizer).__name__, 'processor':type(processor).__name__, 'assets_sha256':assets, 'chat_templates':chats, 'load_seconds':load_seconds, 'load_memory_bytes':load_memory, 'process_peak_rss_bytes':resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * (1024 if platform.system()=='Linux' else 1), 'inference_floating_dtype':'float32, CPU runtime only; stored floating tensors remain BF16', 'native_bf16_cpu_inference':'Aborted after reproducing incorrect accumulation in the official Linux BF16 quantized matmul. See cpu-quantized-matmul-diagnostic.json.', 'generation':generation, 'mtp':mtp_result, 'vision':vision_result, 'total_validation_seconds':time.monotonic()-start}
+with (logs / 'quant-validation-results.json').open('x') as f:json.dump(result,f,indent=2)
+print(json.dumps(result,indent=2),flush=True)

compatibility/validate_aws_source_linux.py

@@ -0,0 +1,104 @@
+"""Load the actual verified Swift BF16 source lazily, without quantization."""
+
+import argparse
+import hashlib
+import json
+import platform
+import resource
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+import mlx.core as mx
+from mlx.utils import tree_flatten
+from transformers import AutoProcessor, AutoTokenizer
+
+from mlx_lm.utils import load_model
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", required=True, type=Path)
+    parser.add_argument("--verification", required=True, type=Path)
+    parser.add_argument("--output", required=True, type=Path)
+    args = parser.parse_args()
+    if args.output.exists():
+        raise FileExistsError(args.output)
+    source = args.source.resolve(strict=True)
+    verified = json.loads(args.verification.read_text())
+    assert verified["status"] == "PASS"
+    assert Path(verified["source_root"]).resolve() == source
+    manifest_hash = "0a00065b88ab003281853a7fb9bd5ce0086bc3781b36136d8c39da19933923ae"
+    assert verified["manifest_sha256"] == manifest_hash
+    assert hashlib.sha256((source / "EXPORT_MANIFEST.json").read_bytes()).hexdigest() == manifest_hash
+    assert verified["shard_count"] == 18
+    assert verified["shard_bytes"] == 55563006776
+    assert verified["tensor_count"] == 1199
+    for item in verified["files"]:
+        assert (source / item["name"]).stat().st_size == item["bytes"]
+
+    started = time.monotonic()
+    model, config = load_model(source, lazy=True, strict=True)
+    assert type(model).__module__ == "mlx_lm.models.qwen3_5_full"
+    assert not config.get("quantization") and not config.get("quantization_config")
+    rows = model.weight_mapping()
+    parameters = dict(tree_flatten(model.parameters()))
+    assert {row["source"] for row in rows} == set(verified["tensors"])
+    assert {row["destination"] for row in rows} == set(parameters)
+    for row in rows:
+        header = verified["tensors"][row["source"]]
+        value = parameters[row["destination"]]
+        assert list(row["source_shape"]) == header["shape"]
+        assert list(value.shape) == list(row["destination_shape"])
+        assert value.dtype == mx.bfloat16 and header["dtype"] == "BF16"
+    categories = dict(Counter(row["category"] for row in rows))
+    assert categories == {"text": 851, "vision": 333, "MTP": 15}
+
+    tokenizer = AutoTokenizer.from_pretrained(source, local_files_only=True, trust_remote_code=False)
+    assert tokenizer.chat_template
+    chats = []
+    for options in [{"enable_thinking": False}, {"reasoning_effort": "low"}, {"reasoning_effort": "xhigh"}]:
+        prompt = tokenizer.apply_chat_template(
+            [{"role": "user", "content": "Say hello."}],
+            tokenize=False, add_generation_prompt=True, **options,
+        )
+        ids = tokenizer.encode(prompt, add_special_tokens=False)
+        assert ids and all(0 <= token < config["text_config"]["vocab_size"] for token in ids)
+        chats.append({"options": options, "tokens": len(ids), "rendered": prompt})
+    processor = AutoProcessor.from_pretrained(source, local_files_only=True, trust_remote_code=False)
+    result = {
+        "status": "PASS_ACTUAL_SOURCE_LAZY_STRUCTURAL_LOAD",
+        "recorded_at": datetime.now(timezone.utc).isoformat(),
+        "platform": platform.platform(),
+        "source": str(source),
+        "source_repo": "ukisai/Swift-1.5-Qwen3.8-27b",
+        "source_revision": "00ccd14e006897d28cb0ed5bf26390e60d274251",
+        "source_verification": str(args.verification.resolve()),
+        "source_verification_sha256": hashlib.sha256(args.verification.read_bytes()).hexdigest(),
+        "source_tensors": len(verified["tensors"]),
+        "mapped_tensors": len(parameters),
+        "categories": categories,
+        "ignored_tensors": 0,
+        "unexplained_tensors": 0,
+        "weight_backing": "actual verified source safetensors; lazy loading",
+        "full_parameter_evaluation": False,
+        "tokenizer": type(tokenizer).__name__,
+        "chat_templates": chats,
+        "processor": type(processor).__name__,
+        "generation": "NOT_RUN",
+        "mtp_runtime": "component-only; no integrated speculative decoding",
+        "vision_runtime": "encoder-only; no integrated multimodal generation",
+        "quantization_executed": False,
+        "elapsed_seconds": time.monotonic() - started,
+        "mlx_active_memory_bytes": mx.get_active_memory(),
+        "process_peak_rss_bytes": resource.getrusage(resource.RUSAGE_SELF).ru_maxrss * (1024 if platform.system() == "Linux" else 1),
+    }
+    with args.output.open("x") as stream:
+        json.dump(result, stream, indent=2)
+        stream.write("\n")
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

compatibility/verify_source_readonly.py

@@ -0,0 +1,92 @@
+"""Verify the original Swift export without changing or loading its weights."""
+import argparse
+import hashlib
+import json
+import math
+import struct
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--root", required=True)
+parser.add_argument("--manifest-sha256", required=True)
+args = parser.parse_args()
+root = Path(args.root)
+
+
+def digest(path):
+    result = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(16 * 1024 * 1024), b""):
+            result.update(block)
+    return result.hexdigest()
+
+
+manifest_path = root / "EXPORT_MANIFEST.json"
+assert digest(manifest_path) == args.manifest_sha256, "Export provenance mismatch"
+manifest = json.loads(manifest_path.read_text())
+assert manifest["dtype"] == "bfloat16"
+shards = manifest["output_shards"]
+assert len(shards) == 18
+index = json.loads((root / "model.safetensors.index.json").read_text())
+expected_shards = {item["file"] for item in shards}
+assert set(index["weight_map"].values()) == expected_shards
+assert {f.name for f in root.glob("*.safetensors")} == expected_shards
+files, tensors = [], {}
+for item in shards:
+    name = item["file"]
+    assert Path(name).name == name
+    path = root / name
+    size = path.stat().st_size
+    assert size == item["bytes"], f"Size mismatch: {name}"
+    sha = digest(path)
+    assert sha == item["sha256"], f"SHA256 mismatch: {name}"
+    with path.open("rb") as stream:
+        header_size = struct.unpack("<Q", stream.read(8))[0]
+        assert 0 < header_size < 16 * 1024 * 1024
+        header = json.loads(stream.read(header_size))
+    ranges = []
+    for tensor_name, metadata in header.items():
+        if tensor_name == "__metadata__":
+            continue
+        assert tensor_name not in tensors, f"Duplicate tensor: {tensor_name}"
+        assert index["weight_map"][tensor_name] == name
+        assert metadata["dtype"] == "BF16", tensor_name
+        start, end = metadata["data_offsets"]
+        count = math.prod(metadata["shape"])
+        assert end - start == count * 2
+        ranges.append((start, end))
+        tensors[tensor_name] = dict(metadata, shard=name, parameters=count, bytes=end-start)
+    ranges.sort()
+    assert ranges[0][0] == 0
+    assert all(left[1] == right[0] for left, right in zip(ranges, ranges[1:]))
+    assert ranges[-1][1] + 8 + header_size == size
+    files.append({"name": name, "bytes": size, "sha256": sha, "kind": "bf16_shard"})
+    print(f"VERIFIED {name} {size} bytes", file=sys.stderr, flush=True)
+assert set(tensors) == set(index["weight_map"])
+assert sum(v["bytes"] for v in tensors.values()) == manifest["total_tensor_bytes"]
+assert index["metadata"]["total_size"] == manifest["total_tensor_bytes"]
+for name, sha in manifest["asset_sha256"].items():
+    path = root / name
+    assert path.is_file(), f"Missing asset: {name}"
+    actual = digest(path)
+    assert actual == sha, f"Asset hash mismatch: {name}"
+    files.append({"name": name, "bytes": path.stat().st_size, "sha256": actual, "kind": "source_asset"})
+recorded = {item["name"] for item in files}
+for path in sorted(root.iterdir()):
+    if path.is_file() and path.name not in recorded:
+        files.append({"name": path.name, "bytes": path.stat().st_size, "sha256": digest(path), "kind": "additional_source_file"})
+result = {
+    "status": "PASS", "recorded_at": datetime.now(timezone.utc).isoformat(),
+    "source_root": str(root), "manifest_sha256": args.manifest_sha256,
+    "shard_count": len(shards), "shard_bytes": sum(item["bytes"] for item in shards),
+    "source_file_bytes": sum(item["bytes"] for item in files),
+    "tensor_count": len(tensors), "parameter_count": sum(v["parameters"] for v in tensors.values()),
+    "files": files, "tensors": tensors,
+    "config": json.loads((root / "config.json").read_text()),
+    "custom_modeling_files": [path.name for path in root.glob("*.py")],
+    "special_tokens_map_present": (root / "special_tokens_map.json").is_file(),
+    "original_unchanged": True,
+}
+print(json.dumps(result, indent=2))

config.json

@@ -0,0 +1,154 @@
+{
+    "architectures": [
+        "Qwen3_5ForConditionalGeneration"
+    ],
+    "eos_token_id": [
+        248046,
+        248044
+    ],
+    "image_token_id": 248056,
+    "language_model_only": false,
+    "model_type": "qwen3_5",
+    "quantization": {
+        "group_size": 64,
+        "bits": 4,
+        "mode": "affine"
+    },
+    "quantization_config": {
+        "group_size": 64,
+        "bits": 4,
+        "mode": "affine"
+    },
+    "text_config": {
+        "attention_bias": false,
+        "attention_dropout": 0.0,
+        "attn_output_gate": true,
+        "bos_token_id": 248044,
+        "dtype": "bfloat16",
+        "eos_token_id": 248044,
+        "full_attention_interval": 4,
+        "head_dim": 256,
+        "hidden_act": "silu",
+        "hidden_size": 5120,
+        "initializer_range": 0.02,
+        "intermediate_size": 17408,
+        "layer_types": [
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention"
+        ],
+        "linear_conv_kernel_dim": 4,
+        "linear_key_head_dim": 128,
+        "linear_num_key_heads": 16,
+        "linear_num_value_heads": 48,
+        "linear_value_head_dim": 128,
+        "mamba_ssm_dtype": "float32",
+        "max_position_embeddings": 262144,
+        "model_type": "qwen3_5_text",
+        "mtp_num_hidden_layers": 1,
+        "mtp_use_dedicated_embeddings": false,
+        "num_attention_heads": 24,
+        "num_hidden_layers": 64,
+        "num_key_value_heads": 4,
+        "output_gate_type": "swish",
+        "pad_token_id": null,
+        "partial_rotary_factor": 0.25,
+        "rms_norm_eps": 1e-06,
+        "rope_parameters": {
+            "mrope_interleaved": true,
+            "mrope_section": [
+                11,
+                11,
+                10
+            ],
+            "partial_rotary_factor": 0.25,
+            "rope_theta": 10000000,
+            "rope_type": "default"
+        },
+        "tie_word_embeddings": false,
+        "use_cache": true,
+        "vocab_size": 248320
+    },
+    "tie_word_embeddings": false,
+    "transformers_version": "5.8.0.dev0",
+    "video_token_id": 248057,
+    "vision_config": {
+        "deepstack_visual_indexes": [],
+        "depth": 27,
+        "hidden_act": "gelu_pytorch_tanh",
+        "hidden_size": 1152,
+        "in_channels": 3,
+        "initializer_range": 0.02,
+        "intermediate_size": 4304,
+        "model_type": "qwen3_5",
+        "num_heads": 16,
+        "num_position_embeddings": 2304,
+        "out_hidden_size": 5120,
+        "patch_size": 16,
+        "spatial_merge_size": 2,
+        "temporal_patch_size": 2
+    },
+    "vision_end_token_id": 248054,
+    "vision_start_token_id": 248053
+}

generation_config.json

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

model-00001-of-00003.safetensors

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

model-00002-of-00003.safetensors

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

model-00003-of-00003.safetensors

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

preprocessor_config.json

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