Add model card, ComfyUI patch, validation reports, and tools

.gitattributes

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

FL2VA/SHA256SUMS

@@ -0,0 +1 @@
+c57e85fc299ca399a5c84e7888b0f61c532da05ddbf3f92e521690b07cb72b0a  minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-quality21.safetensors

LICENSE

@@ -0,0 +1,84 @@
+MiniMax H3 COMMUNITY LICENSE AGREEMENT
+MiniMax H3 release date/License date: August 2, 2026.
+The scope of this License Agreement (this “Agreement”) is expressly limited to the “Applicable Territory” as defined below.
+By clicking to accept, or by using, reproducing, modifying, distributing, running, or displaying any portion or element of the MiniMax H3 Works (including through any Hosted Services) in any manner, you acknowledge and accept the terms of this Agreement, and this Agreement shall take immediate effect upon the occurrence of such act.
+I.  Definitions
+1. “Acceptable Use Policy” means the policy published by MiniMax in Exhibit A.
+2. “Agreement” means the terms and conditions set forth herein that govern the use, reproduction, distribution, modification, running, and display of the MiniMax H3 Works or any portion or element thereof.
+3. “Applicable Territory” means worldwide, excluding the Excluded Territories.
+4. “Documentation” means the specifications, manuals, and documentation concerning MiniMax H3 that are publicly released by MiniMax.
+5. “Excluded Territories” means the European Union, the United Kingdom, the Republic of Korea and the United States of America.  
+6. “MiniMax H3” means the video generation model, together with its software and algorithms, including trained model weights, parameters (including optimizer states), machine-learning model code, inference-supporting code, and other elements thereof made publicly available by Us, as released at https://huggingface.co/MiniMaxAI/MiniMax-H3.
+7. “MiniMax H3 Works” means (i) the Materials, (ii) the Model Derivatives, and (iii) all derivatives thereof.
+8. “Hosted Services” means hosted services provided via application programming interfaces (APIs), web access, or any other electronic or remote means.
+9. “Licensee,” “you,” or “your” means the natural or legal person exercising rights and/or using the MiniMax H3 Works for any purpose in any field of use under this Agreement.
+10. “Materials” means, collectively, MiniMax H3 and the Documentation (and any portion thereof), in each case as made available by MiniMax under this Agreement and proprietary to MiniMax.
+11. “Model Derivatives” means all of the following: (i) any modification of MiniMax H3 or any Model Derivative thereof; (ii) any work based on MiniMax H3 or any Model Derivative thereof; or (iii) any other machine learning model created by transferring the patterns of the weights, parameters, operational patterns, or Outputs of MiniMax H3 or any Model Derivative thereof to another model, such that the latter model exhibits behavior similar to MiniMax H3 or its Model Derivatives, including by distillation methods, methods using intermediate data representations, or methods based on training using synthetic-data Outputs generated by MiniMax H3 or its Model Derivatives. For the avoidance of doubt, Outputs are not deemed Model Derivatives.
+12. “Output” means any result of operating or otherwise using MiniMax H3 or any Model Derivatives (including through Hosted Services).
+13. “Third Party” means any natural or legal person that is not under common control with us or with you.
+14. “Including” means “including but not limited to.”
+15. “We,” “Us”  or  “MiniMax” means Nanonoble Pte. Ltd..
+II.  Grant of Rights
+Solely within the Applicable Territory, we grant you a non-exclusive, non-transferable, royalty-free, limited license to use, reproduce, distribute, create derivative works (including Model Derivatives), and modify the Materials in accordance with the terms of this Agreement and the Acceptable Use Policy, based on the intellectual property and other rights owned by MiniMax that are embodied in or used by the Materials. You shall not violate (or encourage or permit any person to violate) any term of this Agreement or the Acceptable Use Policy.
+We will continuously evaluate the applicable laws, regulations and compliance requirements for the Excluded Territories. In the meantime, should any person in such Excluded Territories be interested in deploying our models, you are welcome to contact us about obtaining a license, which will be granted based on robust controls and guardrails for purposes of complying with the laws, regulations and compliance requirements of the Excluded Territories.
+III.  Distribution and Redistribution
+Subject to and conditioned on your continuing compliance with this Agreement, including its territorial restrictions and the Acceptable Use Policy, and solely within the Applicable Territory, you may distribute or make available the MiniMax H3 Works to Third Parties within the Applicable Territory; provided, that all of the following conditions are met:
+1. You must provide a copy of this Agreement to all such Third Parties who receive the MiniMax H3 Works or use your products or services related thereto;
+2. You must cause any modified files to carry prominent notices stating that you have modified such files;
+3. You are encouraged to:
+  a. display a notice on any product or service developed using MiniMax H3 indicating that the product or service is “Powered by MiniMax H3”; 
+  b. add an AI-generation identifier to files produced using generative AI models including MiniMax H3; and
+  c. publish at least one technical blog post or a public statement describing your experience using MiniMax H3 Works;
+4. All distributions to Third Parties (other than through Hosted Services) must be accompanied by a “NOTICE” text file containing the following notice:
+  “MiniMax H3 is licensed under the MiniMax H3 Community License Agreement, Copyright © 2026 MiniMax. All Rights Reserved.”
+You may add your own copyright notices on your modifications; except as provided in this Section and in Section V, however, you may not impose additional or different terms and conditions on the use, reproduction, or distribution of your modifications or of any aggregate Model Derivatives, and your use, reproduction, modification, distribution, running, and display of the work must otherwise comply with the terms and conditions of this Agreement (including the provisions concerning the Applicable Territory). If you receive the MiniMax H3 Works from a Licensee as part of an integrated end-user product, the provisions of Section III of this Agreement do not apply to you, but Section V and Exhibit A remain applicable.
+IV.  Additional Commercial Terms
+1. You shall obtain a separate, prior written authorization from MiniMax by contacting api@minimax.io with the subject line “MiniMax H3 licensing - authorization request”, if your commercial products and services generate more than 20 million US dollars (or equivalent in other currencies) in yearly revenue.
+2. You shall prominently display “MiniMax H3”on the user interface of commercial product or service that uses MiniMax H3 or MiniMax H3 Works.
+V. Use Restrictions
+1. Your use of the MiniMax H3 Works must comply with applicable laws and regulations (including trade-compliance laws and regulations) and must comply with the Acceptable Use Policy for the MiniMax H3 Works, which is incorporated into this Agreement by reference. 
+2. Before providing access to the MiniMax H3 Works or any product, service, or Hosted Service incorporating them, you must bind each recipient or user to enforceable terms at least as protective as the use restrictions in this Section V and Exhibit A, and you must notify each recipient or user that those restrictions apply.
+3. You may not use the MiniMax H3 Works or any of their Outputs or results to improve any other artificial intelligence model (other than MiniMax H3 or its Model Derivatives).
+4. You may not use, reproduce, modify, distribute, or display the MiniMax H3 Works or any of their Outputs or results outside the Applicable Territory. Any such use outside the Applicable Territory is not authorized by this Agreement.
+5. If you provide or make available to any Third Party a product, service, or Hosted Service that permits the generation of Outputs using MiniMax H3 or any Model Derivative, you must, before making that product or service available and throughout its operation, implement, maintain, test, and periodically review reasonable and proportionate technical and organizational safeguards designed to prevent and mitigate access, uses, and Outputs that violate this Section V or Exhibit A, including uses or Outputs that infringe, misappropriate, or otherwise violate any Third Party’s intellectual-property or other rights. You must not knowingly disable, materially weaken, or permit the circumvention of those safeguards. You must maintain a reasonably accessible mechanism for reporting suspected violations. Upon receiving a good-faith report or otherwise obtaining actual knowledge of a violation, you must promptly investigate and take reasonable steps within your control to stop or mitigate the violation, including removing or disabling access to offending content or services and suspending or terminating repeat violators where appropriate. You are responsible for implementing and enforcing these requirements with respect to your products, services, systems, users, and downstream recipients.
+VI.  Intellectual Property
+1. Subject to MiniMax’s rights in the MiniMax H3 Works (and the intellectual property therein), and to your compliance with the terms and conditions of this Agreement, as between you and MiniMax, you will own the derivative works and modifications of the Materials that you have created or had created, as well as any Model Derivatives.
+2. Except for the limited license expressly granted in this paragraph, no trademark license is granted under this Agreement; with respect to MiniMax H3 Works, the Licensee may not use any name or mark owned by or associated with MiniMax or any of its affiliates, except as reasonably and customarily necessary to describe and distribute the MiniMax H3 Works. MiniMax hereby grants you a license to use the “MiniMax H3” mark (the “Mark”) within the Applicable Territory solely for the purpose of complying with Section III.3; provided, that you comply with all applicable trademark-protection laws. All goodwill arising from your use of the Mark shall inure to the benefit of MiniMax.
+3. If you bring or assert any suit or other legal proceeding (including a cross-claim or counterclaim in any action) against us or any other natural or legal person alleging that the Materials, any Output, or any portion of the foregoing infringes any intellectual property right or other right owned by you or for which you can obtain a license, all licenses granted to you under this Agreement will terminate as of the date such suit or proceeding is filed. You shall defend, indemnify, and hold us harmless against any Third-Party claim arising out of or related to the use or distribution of the MiniMax H3 Works by you or by any Third Party.
+4. MiniMax claims no rights over the Outputs you generate. You and your users are entirely responsible for the Outputs and any subsequent use thereof.
+VII.  Disclaimers and Limitations of Liability
+1. We have no obligation to support, update, provide training for, or develop any further version of the MiniMax H3 Works, or to grant any license with respect thereto.
+2. UNLESS AND ONLY TO THE EXTENT REQUIRED BY APPLICABLE LAW, THE MINIMAX H3 WORKS AND ANY OUTPUT AND RESULTS THEREFROM ARE PROVIDED “AS IS” WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES OF ANY KIND INCLUDING ANY WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, COURSE OF DEALING, USAGE OF TRADE, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING, REPRODUCING, MODIFYING, PERFORMING, DISPLAYING OR DISTRIBUTING ANY OF THE MINIMAX H3 WORKS OR OUTPUTS AND ASSUME ANY AND ALL RISKS ASSOCIATED WITH YOUR OR A THIRD PARTY’S USE OR DISTRIBUTION OF ANY OF THE MINIMAX H3 WORKS OR OUTPUTS AND YOUR EXERCISE OF RIGHTS AND PERMISSIONS UNDER THIS AGREEMENT.
+3. TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT SHALL MINIMAX OR ITS AFFILIATES BE LIABLE UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, TORT, NEGLIGENCE, PRODUCTS LIABILITY, OR OTHERWISE, FOR ANY DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, CONSEQUENTIAL OR PUNITIVE DAMAGES, OR LOST PROFITS OF ANY KIND ARISING FROM THIS AGREEMENT OR RELATED TO ANY OF THE MINIMAX H3 WORKS OR OUTPUTS, EVEN IF MINIMAX OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF ANY OF THE FOREGOING.
+VIII.  Term and Termination
+1. This Agreement is effective from the moment you accept this Agreement or begin accessing the Materials, and, subject to your compliance with its terms and conditions, will remain in effect until terminated as provided herein.
+2. If you breach any term or condition of this Agreement, we have the right to terminate this Agreement. Upon termination, you must immediately cease accessing, using, and distributing the MiniMax H3 Works; delete or destroy all copies within your possession or control; and notify each downstream recipient that your authorization has ended. The obligations in the preceding sentence and Sections VI.1, VI.3, VII, and IX survive termination.
+IX.  Governing Law and Jurisdiction
+1. This Agreement, and any dispute arising out of or related to this Agreement, shall be governed by the laws of the Hong Kong Special Administrative Region of the People’s Republic of China, without regard to its conflict-of-laws rules. The United Nations Convention on Contracts for the International Sale of Goods does not apply to this Agreement.
+2. Any dispute arising out of or related to this Agreement shall be subject to the exclusive jurisdiction of the courts of the Hong Kong Special Administrative Region of the People’s Republic of China with competent jurisdiction. Both MiniMax and the Licensee hereby consent to the exclusive jurisdiction of such courts for any such dispute.
+Additional Note: Please note that the encoder of MiniMax H3 uses Qwen3-VL-32B, which is licensed under Apache 2.0 License: https://github.com/QwenLM/Qwen3-VL/blob/main/LICENSE.
+
+Exhibit A — Acceptable Use Policy
+MiniMax reserves the right to update this Acceptable Use Policy from time to time. 
+Last revised: August 2, 2026.
+MiniMax is committed to promoting the safe and fair use of its tools and features, including MiniMax H3. You agree not to use MiniMax H3, any Model Derivatives, or any Output in any of the following ways:
+1. Use outside the Applicable Territory;
+2. Use in any manner that violates any applicable national, federal, state, local, or international law, regulation, or other legal requirement, or that infringes, misappropriates, or otherwise violates any Third Party’s intellectual-property or other proprietary rights, including through unauthorized reproduction, distribution, public display, public performance, or creation of derivative works;
+3. Use in any manner that may harm yourself or others;
+4. Use to repurpose or distribute the Outputs of MiniMax H3 or any Model Derivatives in order to harm yourself or others;
+5. Use to circumvent or bypass any safety guardrails or safeguards we have implemented;
+6. Use in any manner that exploits or harms, or intends to exploit or harm, minors;
+7. Use to generate or disseminate verifiably false information and/or content for the purpose of harming others or influencing elections;
+8. Use to manufacture or facilitate false online engagement, including fake reviews and other means of false online engagement;
+9. Use to intentionally defame, disparage, or otherwise harass others;
+10. Use to generate and/or disseminate malware (including ransomware) or any other content intended to damage electronic systems;
+11. Use to generate or disseminate personally identifiable information for the purpose of harming others;
+12. Use to generate or disseminate information (including images, code, posts, or articles) in or to any public environment (including via bot tweets or similar means) without clearly and prominently disclosing that such information and/or content is machine-generated;
+13. Use to impersonate another person without that person’s consent, authorization, or lawful right to do so;
+14. Use to make high-risk automated decisions in critical domains that affect individual safety, rights, or well-being (such as law enforcement, immigration, healthcare or medical services, critical-infrastructure management, product-safety components, essential services, credit, employment, housing, education, social scoring, or insurance);
+15. Use in any manner that violates or disregards the social, ethical, or moral standards of other countries or regions;
+16. Use to carry out, assist, threaten, incite, plan, advocate for, or encourage violent extremism or terrorism;
+17. Use for any purpose intended to discriminate against, or harm, individuals or groups based on protected characteristics or categories, online or offline social behavior, or known or predicted personality traits;
+18. Use to intentionally exploit the vulnerabilities of specific populations based on age, social, physical, or psychological characteristics, so as to materially distort the behavior of a member of that group in a manner that causes, or is likely to cause, physical or psychological harm to that person or to others;
+19. Use for military purposes;
+20. Use to engage in any unauthorized or unlicensed professional activity, including but not limited to financial, legal, medical or healthcare, or other professional practice.

NOTICE

@@ -0,0 +1,10 @@
+MiniMax H3 is licensed under the MiniMax H3 Community License Agreement, Copyright © 2026 MiniMax. All Rights Reserved.
+
+Modification notice
+
+The FL2VA safetensors checkpoint in this repository is a modified derivative of
+MiniMax H3. It was converted from the original Diffusers tensor layout to the
+ComfyUI layout, selectively quantized to INT8 ConvRot, and compressed with a
+dynamic rank-16 representation of the AdaLN time-conditioning curve. The
+included ComfyUI patch and conversion/validation scripts are also modified or
+new files provided for this derivative release.

README.md

@@ -0,0 +1,204 @@
+---
+license: other
+license_name: minimax-h3-community-license-agreement
+license_link: LICENSE
+base_model: MiniMaxAI/MiniMax-H3
+library_name: comfyui
+pipeline_tag: image-text-to-video
+tags:
+  - minimax-h3
+  - comfyui
+  - quantization
+  - int8
+  - convrot
+  - video
+  - audio
+  - fl2va
+---
+
+# MiniMax-H3 INT8 Lean ConvRot
+
+This repository contains a quality-oriented mixed-precision ComfyUI derivative
+of [`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3).
+The currently released checkpoint is the **FL2VA** diffusion transformer. It is
+designed as a first 24 GiB GPU candidate while preserving more of the original
+model than the official pruned INT8 checkpoint.
+
+The release is not an official MiniMax or ComfyOrg checkpoint. It requires the
+small ComfyUI core patch included in [`comfy_patch/`](comfy_patch/).
+
+## Included files
+
+| Path | Purpose |
+|---|---|
+| [`FL2VA/minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-quality21.safetensors`](FL2VA/minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-quality21.safetensors) | FL2VA diffusion transformer, 20.999 GiB |
+| [`comfy_patch/minimax_h3_dynamic_basis.patch`](comfy_patch/minimax_h3_dynamic_basis.patch) | Required dynamic AdaLN basis support for ComfyUI |
+| [`reports/layer_policy.json`](reports/layer_policy.json) | Exact per-layer precision policy |
+| [`reports/validation.json`](reports/validation.json) | Structural, numerical, and CPU-load results |
+| [`reports/mm_quant_profile_fl2va.json`](reports/mm_quant_profile_fl2va.json) | Row-sampled reconstruction profile for all 200 main matrices |
+| [`tools/`](tools/) | Audited converter, profiler, and validator sources |
+
+This repository intentionally does **not** include the MiniMax-H3 text encoder,
+tokenizer, or video/audio VAEs. The text encoder is being prepared as a separate
+repository. Obtain the remaining standard components from the
+[`MiniMaxAI/MiniMax-H3`](https://huggingface.co/MiniMaxAI/MiniMax-H3) or
+[`Comfy-Org/MiniMax-H3`](https://huggingface.co/Comfy-Org/MiniMax-H3)
+repositories. Ref2VA is not included in this release.
+
+## What was changed
+
+The original FL2VA Diffusers shards contain 50 transformer blocks with separate
+Q, K, and V tensors. The converter streams those shards directly and performs
+the layout changes required by current ComfyUI MiniMax-H3 support:
+
+- packs attention rows as global `cat(Q, K, V)`;
+- swaps the two `fc1` halves from `[value, gate]` to `[gate, value]`;
+- stores 170 selected main attention/MLP matrices as INT8 ConvRot with group
+  size 256 and per-row FP32 scales;
+- keeps 30 high-error main matrices as exact BF16 copies;
+- keeps the two-block token refiner, norms, Q/K norms, and condition projection
+  at their source precision;
+- keeps patch projections and video/audio output heads in source FP32;
+- keeps the original four-tensor FP32 time embedder bit-for-bit;
+- replaces only the redundant width of the 51 large AdaLN projections with a
+  shared dynamic rank-16 FP32 basis while keeping every AdaLN projection
+  separate.
+
+The checkpoint contains 877 tensor entries: 170 INT8 weights, 170 quantization
+configuration blobs, 250 BF16 entries, and 287 FP32 entries.
+
+## Precision policy
+
+Every DiT block has four main matrices: QKV, attention output, MLP `fc1`, and
+MLP `fc2`, for 200 matrices total. The `quality21` profile stores 170 in INT8
+and 30 in BF16.
+
+The BF16 island is:
+
+- attention output projections in blocks 0–15, 17, 19, 20, 27, 38, 43–47,
+  and 49 (27 matrices);
+- MLP `fc2` in blocks 39, 45, and 49 (3 matrices).
+
+These were selected from a deterministic reconstruction audit using 64 output
+rows and every input column of each matrix. Attention output projections were
+the most error-prone family and are considerably cheaper to retain in BF16 than
+QKV or `fc1`. The exact machine-readable list is in
+[`reports/layer_policy.json`](reports/layer_policy.json).
+
+## Why preserve the time embedder?
+
+The official pruned checkpoint removes the time MLP and uses a small
+interpolated AdaLN table. This release instead evaluates the original FP32 time
+MLP at runtime and projects its 2,688-dimensional output onto a shared
+16-dimensional basis:
+
+```text
+u(t) = SiLU(time_embedder(t))
+z(t) = (u(t) - mean) @ basis
+AdaLN_i(t) = linear_i(z(t))
+```
+
+Each of the 50 block AdaLN projections and the final AdaLN projection remains a
+different FP32 linear layer. Only their common, smooth time-conditioning input
+space is compressed. There is no lookup-table interpolation in this path.
+
+On nine validation timesteps, the relative AdaLN output error against the raw
+HF weights was between `2.82e-7` and `3.29e-7` for blocks 0, 24, 49, and the
+final layer. For context, the official pruned table path measured about
+`0.016%–0.021%` on the same four projections. This comparison covers only the
+time/AdaLN path, not end-to-end generation quality.
+
+## Comparison with official ComfyOrg files
+
+| Checkpoint | Size | Main matrices | Time/AdaLN representation |
+|---|---:|---:|---|
+| Official regular INT8 ConvRot | about 31.70 GiB | 200 INT8 | full AdaLN weights |
+| Official pruned INT8 ConvRot | 19.530 GiB | 200 INT8 | FP16 rank-8 table |
+| This `quality21` release | 20.999 GiB | 170 INT8 + 30 BF16 | original FP32 time MLP + FP32 dynamic rank-16 basis |
+
+This file is 1.469 GiB (7.52%) larger than the official pruned INT8 checkpoint.
+The added space is intentionally spent on the original time behavior and a
+BF16 island for the most sensitive main matrices.
+
+The full 200-matrix sampled reconstruction proxy produced:
+
+| Metric | Official-style absmax INT8 | This profile |
+|---|---:|---:|
+| Unweighted mean relative matrix error | 0.9345% | 0.7639% |
+
+For this profile, selected BF16 matrices count as zero storage reconstruction
+error. On the remaining 170 INT8 matrices, searched scales reduced the mean
+proxy from 0.9109% to 0.8987%. The overall 18.26% reduction is a sampled weight
+reconstruction result, **not** a perceptual or generation benchmark.
+
+## ComfyUI installation
+
+1. Use a ComfyUI checkout compatible with MiniMax-H3. This release was
+   CPU-load-tested at commit `14b05228cef127ce529bc0c08660770d4af3e9a8`.
+2. Apply [`comfy_patch/minimax_h3_dynamic_basis.patch`](comfy_patch/minimax_h3_dynamic_basis.patch)
+   from the ComfyUI repository root.
+3. Place the safetensors file in `ComfyUI/models/diffusion_models/`.
+4. Load it with the standard diffusion-model loader in a MiniMax-H3 FL2VA
+   workflow. Supply the text encoder and video/audio VAEs separately.
+
+The patch adds a third MiniMax-H3 time-conditioning mode and leaves existing
+full and official `adaln_t_table` checkpoints on their original paths. Do not
+apply it blindly if upstream ComfyUI has since implemented equivalent support.
+
+## Validation status
+
+Completed:
+
+- safetensors structure, shapes, dtypes, and all 170 ConvRot descriptors;
+- SHA-256: `c57e85fc299ca399a5c84e7888b0f61c532da05ddbf3f92e521690b07cb72b0a`;
+- original FP32 time embedder: 4/4 tensors bitwise equal to raw HF;
+- BF16 main island: 30/30 matrices bitwise equal to raw HF;
+- dynamic-basis orthogonality and numerical AdaLN checks;
+- full CPU load through ComfyUI as `ModelPatcher -> MiniMaxH3Model`, with
+  dynamic basis enabled and table mode disabled.
+
+Not completed at release time:
+
+- CUDA/GPU loading of this exact checkpoint;
+- peak VRAM measurement for a target resolution and frame count;
+- end-to-end FL2VA generation;
+- same-seed visual/audio A/B against BF16 and official pruned variants.
+
+Therefore, 20.999 GiB is the on-disk tensor payload, not a promise that every
+workflow will remain under 24 GiB. Activations, runtime buffers, resolution,
+frame count, batch size, and offloading policy determine peak VRAM.
+
+## Reproduction
+
+The converter reads the original top-level `transformer/` Diffusers shards from
+MiniMaxAI directly; it does not create a 61+ GiB merged BF16 intermediate. The
+nested task-specific transformer folder was not used because its already-packed
+QKV is head-major, while current ComfyUI expects global `cat(Q,K,V)` packing.
+
+See [`tools/README.md`](tools/README.md) for exact dry-run, CPU-build, and
+validation commands. The official
+[`minimax_h3_fl2va_pruned_int8_convrot.safetensors`](https://huggingface.co/Comfy-Org/MiniMax-H3/blob/main/diffusion_models/minimax_h3_fl2va_pruned_int8_convrot.safetensors)
+was used only as a layout reference and as the source of the FP32
+`rope.inv_freq` tensor absent from the raw Diffusers state dict.
+
+## Limitations and intended use
+
+This release is intended for research and local ComfyUI inference. It is a
+new, structurally validated operating point, not a completed quality benchmark.
+The current layer policy was profiled on FL2VA and must not be assumed optimal
+for Ref2VA without a separate audit.
+
+## License
+
+This derivative is distributed under the
+[MiniMax H3 Community License Agreement](LICENSE). The license limits use and
+distribution to its defined Applicable Territory, excludes the European Union,
+United Kingdom, Republic of Korea, and United States, and includes additional
+use and redistribution conditions. Read the full license and [`NOTICE`](NOTICE)
+before downloading, using, or redistributing these files.
+
+## Links
+
+- [Original MiniMax-H3 repository](https://huggingface.co/MiniMaxAI/MiniMax-H3)
+- [Official ComfyOrg MiniMax-H3 files](https://huggingface.co/Comfy-Org/MiniMax-H3)
+- [ComfyUI](https://github.com/Comfy-Org/ComfyUI)

comfy_patch/README.md

@@ -0,0 +1,24 @@
+# Required ComfyUI patch
+
+The dynamic-basis checkpoint is intentionally different from the official
+table-pruned format and needs the accompanying core patch.
+
+The patch was created and CPU-load-tested against ComfyUI commit
+`14b05228cef127ce529bc0c08660770d4af3e9a8`.
+
+From the root of a compatible ComfyUI checkout:
+
+```bash
+git apply /path/to/minimax_h3_dynamic_basis.patch
+```
+
+The patch changes only:
+
+- `comfy/ldm/minimax/model.py`
+- `comfy/model_detection.py`
+
+It adds detection and runtime support for `adaln_curve_basis` and
+`adaln_curve_mean`. Existing full and official `adaln_t_table` checkpoints keep
+their previous paths. If a later ComfyUI release already contains equivalent
+support, do not apply the patch blindly; inspect the upstream implementation
+first.

comfy_patch/minimax_h3_dynamic_basis.patch

@@ -0,0 +1,104 @@
+diff --git a/comfy/ldm/minimax/model.py b/comfy/ldm/minimax/model.py
+index 494350d4..112efbe2 100644
+--- a/comfy/ldm/minimax/model.py
++++ b/comfy/ldm/minimax/model.py
+@@ -416,7 +416,7 @@ class MiniMaxH3Model(nn.Module):
+                  timestep_input_dim=256, time_embed_hidden_size=5376, time_embed_dim=2688,
+                  rope_inv_freq_len=16, norm_eps=1e-5, qk_norm_eps=1e-5, final_norm_eps=1e-5,
+                  sigma_shift_video=12.0, sigma_shift_audio=3.0,
+-                 adaln_curve_grid=None,
++                 adaln_curve_grid=None, adaln_curve_basis_dim=None,
+                  image_model=None, dtype=None, device=None, operations=None, **kwargs):
+         super().__init__()
+         self.dtype = dtype
+@@ -426,20 +426,30 @@ class MiniMaxH3Model(nn.Module):
+         self.audio_latents_dim = audio_latents_dim
+         self.sigma_shift_video = sigma_shift_video
+         self.sigma_shift_audio = sigma_shift_audio
+-        self.use_adaln_curves = adaln_curve_grid is not None
+-        # curve-form checkpoints replace the time embedder and full-width adaln weights with a small shared basis of the time-embedding curve
++        if adaln_curve_grid is not None and adaln_curve_basis_dim is not None:
++            raise ValueError("adaln table and dynamic basis modes are mutually exclusive")
++        self.use_adaln_table = adaln_curve_grid is not None
++        self.use_adaln_basis = adaln_curve_basis_dim is not None
++        self.use_adaln_curves = self.use_adaln_table or self.use_adaln_basis
++        # Curve checkpoints replace full-width adaLN weights with projections
++        # over a small shared basis.  Table mode also replaces the time MLP;
++        # dynamic-basis mode retains it and projects its exact fp32 output.
+         curve = {"apply_silu": not self.use_adaln_curves,
+                  "adaln_dtype": torch.float32 if self.use_adaln_curves else dtype}
++        adaln_dim = adaln_curve_basis_dim if self.use_adaln_basis else time_embed_dim
+         video_patch_dim = latents_dim * self.patch_size[0] * self.patch_size[1] * self.patch_size[2]
+ 
+         self.video_patch_proj = operations.Linear(video_patch_dim, hidden_size, bias=True, dtype=torch.float32, device=device)
+         self.audio_patch_proj = operations.Linear(audio_latents_dim, hidden_size, bias=True, dtype=torch.float32, device=device)
+         self.condition_proj = operations.Linear(text_dim, hidden_size, bias=True, dtype=dtype, device=device)
+-        if self.use_adaln_curves:
++        if self.use_adaln_table:
+             self.register_buffer("adaln_t_table", torch.empty(adaln_curve_grid, time_embed_dim, dtype=torch.float32))
+         else:
+             self.time_embedder = TimeEmbedder(timestep_input_dim, time_embed_hidden_size, time_embed_dim,
+                                               dtype=torch.float32, device=device, operations=operations)
++            if self.use_adaln_basis:
++                self.register_buffer("adaln_curve_basis", torch.empty(time_embed_dim, adaln_curve_basis_dim, dtype=torch.float32))
++                self.register_buffer("adaln_curve_mean", torch.empty(time_embed_dim, dtype=torch.float32))
+         self.rope = nn.Module()
+         self.rope.register_buffer("inv_freq", torch.empty(rope_inv_freq_len, dtype=torch.float32))
+         self.token_refiner = TokenRefiner(token_refiner_num_layers, hidden_size, num_attention_heads,
+@@ -447,9 +457,9 @@ class MiniMaxH3Model(nn.Module):
+                                           final_norm_eps, dtype=dtype, device=device, operations=operations)
+         self.blocks = nn.ModuleList([
+             DiTBlock(hidden_size, num_attention_heads, attention_head_dim, ffn_hidden_size,
+-                     time_embed_dim, norm_eps, qk_norm_eps, **curve, dtype=dtype, device=device, operations=operations)
++                     adaln_dim, norm_eps, qk_norm_eps, **curve, dtype=dtype, device=device, operations=operations)
+             for _ in range(num_layers)])
+-        self.final_layer = FinalLayer(hidden_size, time_embed_dim, video_patch_dim, audio_latents_dim,
++        self.final_layer = FinalLayer(hidden_size, adaln_dim, video_patch_dim, audio_latents_dim,
+                                       final_norm_eps, **curve, dtype=dtype, device=device, operations=operations)
+ 
+     def preprocess_text_embeds(self, text_states):
+@@ -599,12 +609,19 @@ class MiniMaxH3Model(nn.Module):
+                 aoff += n
+ 
+         t_vals = torch.tensor(unique_t, dtype=torch.float32, device=device)
+-        if self.use_adaln_curves:
++        if self.use_adaln_table:
+             # adaln projections consume interpolated coordinates of the time-embedding curve
+             table = comfy.model_management.cast_to(self.adaln_t_table, device=device)
+             pos = t_vals.clamp(0.0, 1.0) * (table.shape[0] - 1)     # t in [0,1] -> fractional grid index, out-of-range t clamps to the curve ends
+             i0 = pos.floor().long().clamp(max=table.shape[0] - 2)   # lower grid row, max-clamp keeps t=1.0 on the last interval instead of reading past the table
+             t_emb = torch.lerp(table[i0], table[i0 + 1], (pos - i0).unsqueeze(1))  # blend the two rows by the fractional part
++        elif self.use_adaln_basis:
++            # Preserve the original fp32 time MLP and remove only the redundant
++            # directions that its smooth one-dimensional output curve never uses.
++            full_t_emb = nn.functional.silu(self.time_embedder(t_vals))
++            basis = comfy.model_management.cast_to(self.adaln_curve_basis, device=device)
++            mean = comfy.model_management.cast_to(self.adaln_curve_mean, device=device)
++            t_emb = (full_t_emb - mean) @ basis
+         else:
+             t_emb = self.time_embedder(t_vals).to(dtype)
+ 
+diff --git a/comfy/model_detection.py b/comfy/model_detection.py
+index 103680fd..eaafd3ec 100644
+--- a/comfy/model_detection.py
++++ b/comfy/model_detection.py
+@@ -373,6 +373,7 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
+         dit_config["ffn_hidden_size"] = state_dict['{}blocks.0.mlp.fc1.weight'.format(key_prefix)].shape[0] // 2
+         dit_config["text_dim"] = state_dict['{}condition_proj.weight'.format(key_prefix)].shape[1]
+         table_key = '{}adaln_t_table'.format(key_prefix)
++        basis_key = '{}adaln_curve_basis'.format(key_prefix)
+         if table_key in state_dict_keys:
+             # adaln shipped over a precomputed curve basis: the adaln linears span a small shared basis of the time-embedding curve (no time embedder)
+             table = state_dict[table_key].shape  # [grid, k]
+@@ -383,6 +384,11 @@ def detect_unet_config(state_dict, key_prefix, metadata=None):
+             dit_config["timestep_input_dim"] = te.shape[1]
+             dit_config["time_embed_hidden_size"] = te.shape[0]
+             dit_config["time_embed_dim"] = state_dict['{}time_embedder.proj_out.weight'.format(key_prefix)].shape[0]
++            if basis_key in state_dict_keys:
++                basis = state_dict[basis_key].shape  # [full time dim, compact adaLN dim]
++                if basis[0] != dit_config["time_embed_dim"]:
++                    raise ValueError("MiniMax H3 adaLN basis input does not match time embedder output")
++                dit_config["adaln_curve_basis_dim"] = basis[1]
+         dit_config["rope_inv_freq_len"] = state_dict['{}rope.inv_freq'.format(key_prefix)].shape[0]
+         if metadata is not None and "config" in metadata:
+             dit_config.update(json.loads(metadata["config"]).get("transformer", {}))

reports/layer_policy.json

@@ -0,0 +1,53 @@
+{
+  "variant": "FL2VA",
+  "profile": "quality21",
+  "main_matrix_count": 200,
+  "int8_convrot_group_256_count": 170,
+  "bf16_main_count": 30,
+  "bf16_main_layers": [
+    "blocks.0.attn.out_proj",
+    "blocks.1.attn.out_proj",
+    "blocks.2.attn.out_proj",
+    "blocks.3.attn.out_proj",
+    "blocks.4.attn.out_proj",
+    "blocks.5.attn.out_proj",
+    "blocks.6.attn.out_proj",
+    "blocks.7.attn.out_proj",
+    "blocks.8.attn.out_proj",
+    "blocks.9.attn.out_proj",
+    "blocks.10.attn.out_proj",
+    "blocks.11.attn.out_proj",
+    "blocks.12.attn.out_proj",
+    "blocks.13.attn.out_proj",
+    "blocks.14.attn.out_proj",
+    "blocks.15.attn.out_proj",
+    "blocks.17.attn.out_proj",
+    "blocks.19.attn.out_proj",
+    "blocks.20.attn.out_proj",
+    "blocks.27.attn.out_proj",
+    "blocks.38.attn.out_proj",
+    "blocks.43.attn.out_proj",
+    "blocks.44.attn.out_proj",
+    "blocks.45.attn.out_proj",
+    "blocks.46.attn.out_proj",
+    "blocks.47.attn.out_proj",
+    "blocks.49.attn.out_proj",
+    "blocks.39.mlp.fc2",
+    "blocks.45.mlp.fc2",
+    "blocks.49.mlp.fc2"
+  ],
+  "other_precision": {
+    "token_refiner": "source BF16",
+    "normalization_and_qk_norm": "source BF16",
+    "condition_projection": "source BF16",
+    "video_audio_patch_and_output_projections": "source FP32",
+    "time_embedder": "source FP32, bitwise copy",
+    "adaln_projections": "51 separate FP32 rank-16 projections",
+    "adaln_shared_basis": "FP32 [2688, 16] plus FP32 mean [2688]",
+    "rope_inv_freq": "FP32 [16]"
+  },
+  "packing": {
+    "qkv": "global cat(Q,K,V) for current ComfyUI MiniMax-H3 split",
+    "mlp_fc1": "halves reordered from [value,gate] to [gate,value]"
+  }
+}

reports/mm_quant_profile_fl2va.json

@@ -0,0 +1,3011 @@
+{
+  "variant": "fl2va",
+  "source": "MiniMaxAI/MiniMax-H3:transformer/",
+  "groupsize": 256,
+  "rows": 64,
+  "search_min": 0.8,
+  "clip_margin": 0.05,
+  "elapsed_seconds": 59.14021396636963,
+  "layers": [
+    {
+      "layer": "blocks.0.attn.qkv_proj",
+      "block": 0,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009152177721261978,
+      "searched_error": 0.009113732725381851,
+      "improvement": 3.844499588012695e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.0.attn.out_proj",
+      "block": 0,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.011882137507200241,
+      "searched_error": 0.011777178384363651,
+      "improvement": 0.00010495912283658981,
+      "clipped_row_fraction": 0.3125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.0.mlp.fc1",
+      "block": 0,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00878384243696928,
+      "searched_error": 0.00870873685926199,
+      "improvement": 7.510557770729065e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.0.mlp.fc2",
+      "block": 0,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009269612841308117,
+      "searched_error": 0.008981985971331596,
+      "improvement": 0.00028762686997652054,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.1.attn.qkv_proj",
+      "block": 1,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008961416780948639,
+      "searched_error": 0.008927497081458569,
+      "improvement": 3.391969949007034e-05,
+      "clipped_row_fraction": 0.109375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.1.attn.out_proj",
+      "block": 1,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.012739170342683792,
+      "searched_error": 0.012587778270244598,
+      "improvement": 0.00015139207243919373,
+      "clipped_row_fraction": 0.375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.1.mlp.fc1",
+      "block": 1,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008769280277192593,
+      "searched_error": 0.008701339364051819,
+      "improvement": 6.794091314077377e-05,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.1.mlp.fc2",
+      "block": 1,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009266164153814316,
+      "searched_error": 0.00898699089884758,
+      "improvement": 0.00027917325496673584,
+      "clipped_row_fraction": 0.8125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.2.attn.qkv_proj",
+      "block": 2,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008809692226350307,
+      "searched_error": 0.008738144300878048,
+      "improvement": 7.154792547225952e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.2.attn.out_proj",
+      "block": 2,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.012884954921901226,
+      "searched_error": 0.0127450842410326,
+      "improvement": 0.00013987068086862564,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.2.mlp.fc1",
+      "block": 2,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00894160382449627,
+      "searched_error": 0.008885352872312069,
+      "improvement": 5.625095218420029e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.2.mlp.fc2",
+      "block": 2,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009285910055041313,
+      "searched_error": 0.009044776670634747,
+      "improvement": 0.00024113338440656662,
+      "clipped_row_fraction": 0.765625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.3.attn.qkv_proj",
+      "block": 3,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008725655265152454,
+      "searched_error": 0.008664319291710854,
+      "improvement": 6.13359734416008e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.3.attn.out_proj",
+      "block": 3,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.011724220588803291,
+      "searched_error": 0.011615997180342674,
+      "improvement": 0.00010822340846061707,
+      "clipped_row_fraction": 0.34375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.3.mlp.fc1",
+      "block": 3,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008707783184945583,
+      "searched_error": 0.00865384191274643,
+      "improvement": 5.39412721991539e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.3.mlp.fc2",
+      "block": 3,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00944015197455883,
+      "searched_error": 0.00914775114506483,
+      "improvement": 0.0002924008294939995,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.4.attn.qkv_proj",
+      "block": 4,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009004554711282253,
+      "searched_error": 0.008930174633860588,
+      "improvement": 7.438007742166519e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.4.attn.out_proj",
+      "block": 4,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010641911998391151,
+      "searched_error": 0.010547509416937828,
+      "improvement": 9.440258145332336e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.4.mlp.fc1",
+      "block": 4,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00890740193426609,
+      "searched_error": 0.008863168768584728,
+      "improvement": 4.423316568136215e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.4.mlp.fc2",
+      "block": 4,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009372618049383163,
+      "searched_error": 0.009068206883966923,
+      "improvement": 0.0003044111654162407,
+      "clipped_row_fraction": 0.90625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.5.attn.qkv_proj",
+      "block": 5,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008844029158353806,
+      "searched_error": 0.008820337243378162,
+      "improvement": 2.3691914975643158e-05,
+      "clipped_row_fraction": 0.09375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.5.attn.out_proj",
+      "block": 5,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.01112278364598751,
+      "searched_error": 0.011005363427102566,
+      "improvement": 0.00011742021888494492,
+      "clipped_row_fraction": 0.3125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.5.mlp.fc1",
+      "block": 5,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008900557644665241,
+      "searched_error": 0.008855637162923813,
+      "improvement": 4.4920481741428375e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.5.mlp.fc2",
+      "block": 5,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009373556822538376,
+      "searched_error": 0.009093226864933968,
+      "improvement": 0.00028032995760440826,
+      "clipped_row_fraction": 0.8125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.6.attn.qkv_proj",
+      "block": 6,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008842005394399166,
+      "searched_error": 0.00879959762096405,
+      "improvement": 4.2407773435115814e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.6.attn.out_proj",
+      "block": 6,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010709479451179504,
+      "searched_error": 0.010630433447659016,
+      "improvement": 7.904600352048874e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.6.mlp.fc1",
+      "block": 6,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008929567411541939,
+      "searched_error": 0.008865898475050926,
+      "improvement": 6.366893649101257e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.6.mlp.fc2",
+      "block": 6,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00941010843962431,
+      "searched_error": 0.0091486144810915,
+      "improvement": 0.0002614939585328102,
+      "clipped_row_fraction": 0.765625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.7.attn.qkv_proj",
+      "block": 7,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00882177148014307,
+      "searched_error": 0.008771982975304127,
+      "improvement": 4.978850483894348e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.7.attn.out_proj",
+      "block": 7,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.011009636335074902,
+      "searched_error": 0.010906275361776352,
+      "improvement": 0.00010336097329854965,
+      "clipped_row_fraction": 0.28125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.7.mlp.fc1",
+      "block": 7,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008888943120837212,
+      "searched_error": 0.00882368441671133,
+      "improvement": 6.52587041258812e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.7.mlp.fc2",
+      "block": 7,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00938947219401598,
+      "searched_error": 0.00911177508533001,
+      "improvement": 0.0002776971086859703,
+      "clipped_row_fraction": 0.796875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.8.attn.qkv_proj",
+      "block": 8,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008989319205284119,
+      "searched_error": 0.00893863569945097,
+      "improvement": 5.0683505833148956e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.8.attn.out_proj",
+      "block": 8,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010419621132314205,
+      "searched_error": 0.010341066867113113,
+      "improvement": 7.855426520109177e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.8.mlp.fc1",
+      "block": 8,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00879050511866808,
+      "searched_error": 0.008731446228921413,
+      "improvement": 5.9058889746665955e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.8.mlp.fc2",
+      "block": 8,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009295894764363766,
+      "searched_error": 0.009004893712699413,
+      "improvement": 0.0002910010516643524,
+      "clipped_row_fraction": 0.84375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.9.attn.qkv_proj",
+      "block": 9,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008668643422424793,
+      "searched_error": 0.008617810904979706,
+      "improvement": 5.083251744508743e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.9.attn.out_proj",
+      "block": 9,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010687579400837421,
+      "searched_error": 0.010574358515441418,
+      "improvement": 0.00011322088539600372,
+      "clipped_row_fraction": 0.375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.9.mlp.fc1",
+      "block": 9,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008629563264548779,
+      "searched_error": 0.008573157712817192,
+      "improvement": 5.6405551731586456e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.9.mlp.fc2",
+      "block": 9,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009348033927381039,
+      "searched_error": 0.009073112159967422,
+      "improvement": 0.0002749217674136162,
+      "clipped_row_fraction": 0.8125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.10.attn.qkv_proj",
+      "block": 10,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008851743303239346,
+      "searched_error": 0.008800441399216652,
+      "improvement": 5.1301904022693634e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.10.attn.out_proj",
+      "block": 10,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.01040264405310154,
+      "searched_error": 0.010317868553102016,
+      "improvement": 8.477549999952316e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.10.mlp.fc1",
+      "block": 10,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00881904549896717,
+      "searched_error": 0.00878453440964222,
+      "improvement": 3.451108932495117e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.10.mlp.fc2",
+      "block": 10,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009316526353359222,
+      "searched_error": 0.009032001718878746,
+      "improvement": 0.0002845246344804764,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.11.attn.qkv_proj",
+      "block": 11,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008875393308699131,
+      "searched_error": 0.008854538202285767,
+      "improvement": 2.085510641336441e-05,
+      "clipped_row_fraction": 0.09375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.11.attn.out_proj",
+      "block": 11,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010382995009422302,
+      "searched_error": 0.010304039344191551,
+      "improvement": 7.895566523075104e-05,
+      "clipped_row_fraction": 0.28125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.11.mlp.fc1",
+      "block": 11,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008945159614086151,
+      "searched_error": 0.008855168707668781,
+      "improvement": 8.999090641736984e-05,
+      "clipped_row_fraction": 0.28125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.11.mlp.fc2",
+      "block": 11,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009415395557880402,
+      "searched_error": 0.009122848510742188,
+      "improvement": 0.0002925470471382141,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.12.attn.qkv_proj",
+      "block": 12,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008705309592187405,
+      "searched_error": 0.008628779090940952,
+      "improvement": 7.653050124645233e-05,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.12.attn.out_proj",
+      "block": 12,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010260747745633125,
+      "searched_error": 0.01013985276222229,
+      "improvement": 0.00012089498341083527,
+      "clipped_row_fraction": 0.40625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.12.mlp.fc1",
+      "block": 12,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008776841685175896,
+      "searched_error": 0.008733909577131271,
+      "improvement": 4.293210804462433e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.12.mlp.fc2",
+      "block": 12,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009360354393720627,
+      "searched_error": 0.009091442450881004,
+      "improvement": 0.0002689119428396225,
+      "clipped_row_fraction": 0.796875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.13.attn.qkv_proj",
+      "block": 13,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008797130547463894,
+      "searched_error": 0.008764015510678291,
+      "improvement": 3.311503678560257e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.13.attn.out_proj",
+      "block": 13,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.01025098841637373,
+      "searched_error": 0.010134506039321423,
+      "improvement": 0.00011648237705230713,
+      "clipped_row_fraction": 0.34375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.13.mlp.fc1",
+      "block": 13,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008742579258978367,
+      "searched_error": 0.008683488704264164,
+      "improvement": 5.909055471420288e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.13.mlp.fc2",
+      "block": 13,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009341541677713394,
+      "searched_error": 0.009044078178703785,
+      "improvement": 0.0002974634990096092,
+      "clipped_row_fraction": 0.90625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.14.attn.qkv_proj",
+      "block": 14,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008731739595532417,
+      "searched_error": 0.00866743829101324,
+      "improvement": 6.430130451917648e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.14.attn.out_proj",
+      "block": 14,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010588740929961205,
+      "searched_error": 0.0104738874360919,
+      "improvement": 0.00011485349386930466,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.14.mlp.fc1",
+      "block": 14,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008739639073610306,
+      "searched_error": 0.008686761371791363,
+      "improvement": 5.2877701818943024e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.14.mlp.fc2",
+      "block": 14,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009477745741605759,
+      "searched_error": 0.009174283593893051,
+      "improvement": 0.0003034621477127075,
+      "clipped_row_fraction": 0.875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.15.attn.qkv_proj",
+      "block": 15,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008885015733540058,
+      "searched_error": 0.00882111955434084,
+      "improvement": 6.389617919921875e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.15.attn.out_proj",
+      "block": 15,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010997327975928783,
+      "searched_error": 0.010905122384428978,
+      "improvement": 9.220559149980545e-05,
+      "clipped_row_fraction": 0.3125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.15.mlp.fc1",
+      "block": 15,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008847352117300034,
+      "searched_error": 0.008780043572187424,
+      "improvement": 6.730854511260986e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.15.mlp.fc2",
+      "block": 15,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009283319115638733,
+      "searched_error": 0.009016971103847027,
+      "improvement": 0.0002663480117917061,
+      "clipped_row_fraction": 0.734375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.16.attn.qkv_proj",
+      "block": 16,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008748023770749569,
+      "searched_error": 0.008716645650565624,
+      "improvement": 3.13781201839447e-05,
+      "clipped_row_fraction": 0.109375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.16.attn.out_proj",
+      "block": 16,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009902860969305038,
+      "searched_error": 0.00981918629258871,
+      "improvement": 8.367467671632767e-05,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.16.mlp.fc1",
+      "block": 16,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008831686340272427,
+      "searched_error": 0.008767331019043922,
+      "improvement": 6.435532122850418e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.16.mlp.fc2",
+      "block": 16,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009359601885080338,
+      "searched_error": 0.009068690240383148,
+      "improvement": 0.00029091164469718933,
+      "clipped_row_fraction": 0.828125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.17.attn.qkv_proj",
+      "block": 17,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008687121793627739,
+      "searched_error": 0.00865284912288189,
+      "improvement": 3.427267074584961e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.17.attn.out_proj",
+      "block": 17,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010405216366052628,
+      "searched_error": 0.010322467423975468,
+      "improvement": 8.274894207715988e-05,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.17.mlp.fc1",
+      "block": 17,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008705413900315762,
+      "searched_error": 0.0086616026237607,
+      "improvement": 4.381127655506134e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.17.mlp.fc2",
+      "block": 17,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009333509020507336,
+      "searched_error": 0.009056181646883488,
+      "improvement": 0.00027732737362384796,
+      "clipped_row_fraction": 0.828125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.18.attn.qkv_proj",
+      "block": 18,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008936939761042595,
+      "searched_error": 0.008889943361282349,
+      "improvement": 4.699639976024628e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.18.attn.out_proj",
+      "block": 18,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009594418108463287,
+      "searched_error": 0.009486166760325432,
+      "improvement": 0.00010825134813785553,
+      "clipped_row_fraction": 0.375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.18.mlp.fc1",
+      "block": 18,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008742792531847954,
+      "searched_error": 0.008695181459188461,
+      "improvement": 4.761107265949249e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.18.mlp.fc2",
+      "block": 18,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009461008943617344,
+      "searched_error": 0.009183678776025772,
+      "improvement": 0.0002773301675915718,
+      "clipped_row_fraction": 0.78125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.19.attn.qkv_proj",
+      "block": 19,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008822006173431873,
+      "searched_error": 0.008770683780312538,
+      "improvement": 5.1322393119335175e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.19.attn.out_proj",
+      "block": 19,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010611477307975292,
+      "searched_error": 0.010500634089112282,
+      "improvement": 0.0001108432188630104,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.19.mlp.fc1",
+      "block": 19,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008817723952233791,
+      "searched_error": 0.008774425834417343,
+      "improvement": 4.329811781644821e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.19.mlp.fc2",
+      "block": 19,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009473009034991264,
+      "searched_error": 0.009183146059513092,
+      "improvement": 0.0002898629754781723,
+      "clipped_row_fraction": 0.84375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.20.attn.qkv_proj",
+      "block": 20,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008687637746334076,
+      "searched_error": 0.008649254217743874,
+      "improvement": 3.838352859020233e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.20.attn.out_proj",
+      "block": 20,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010098835453391075,
+      "searched_error": 0.010017567314207554,
+      "improvement": 8.126813918352127e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.20.mlp.fc1",
+      "block": 20,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00895522441715002,
+      "searched_error": 0.008894613943994045,
+      "improvement": 6.061047315597534e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.20.mlp.fc2",
+      "block": 20,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009419957175850868,
+      "searched_error": 0.009130561724305153,
+      "improvement": 0.00028939545154571533,
+      "clipped_row_fraction": 0.828125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.21.attn.qkv_proj",
+      "block": 21,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00888002384454012,
+      "searched_error": 0.008830714970827103,
+      "improvement": 4.930887371301651e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.21.attn.out_proj",
+      "block": 21,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009559880010783672,
+      "searched_error": 0.009482322260737419,
+      "improvement": 7.75577500462532e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.21.mlp.fc1",
+      "block": 21,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008936901576817036,
+      "searched_error": 0.00889648962765932,
+      "improvement": 4.0411949157714844e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.21.mlp.fc2",
+      "block": 21,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009269020520150661,
+      "searched_error": 0.00896172784268856,
+      "improvement": 0.000307292677462101,
+      "clipped_row_fraction": 0.890625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.22.attn.qkv_proj",
+      "block": 22,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008947743102908134,
+      "searched_error": 0.008884221315383911,
+      "improvement": 6.352178752422333e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.22.attn.out_proj",
+      "block": 22,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009753851220011711,
+      "searched_error": 0.009624251164495945,
+      "improvement": 0.00012960005551576614,
+      "clipped_row_fraction": 0.453125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.22.mlp.fc1",
+      "block": 22,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008831880986690521,
+      "searched_error": 0.008773558773100376,
+      "improvement": 5.832221359014511e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.22.mlp.fc2",
+      "block": 22,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009388533420860767,
+      "searched_error": 0.009097986854612827,
+      "improvement": 0.00029054656624794006,
+      "clipped_row_fraction": 0.84375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.23.attn.qkv_proj",
+      "block": 23,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008868304081261158,
+      "searched_error": 0.008819671347737312,
+      "improvement": 4.863273352384567e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.23.attn.out_proj",
+      "block": 23,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009776268154382706,
+      "searched_error": 0.009708729572594166,
+      "improvement": 6.753858178853989e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.23.mlp.fc1",
+      "block": 23,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008618944324553013,
+      "searched_error": 0.008562471717596054,
+      "improvement": 5.647260695695877e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.23.mlp.fc2",
+      "block": 23,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009360692463815212,
+      "searched_error": 0.009071816690266132,
+      "improvement": 0.0002888757735490799,
+      "clipped_row_fraction": 0.84375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.24.attn.qkv_proj",
+      "block": 24,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008849837817251682,
+      "searched_error": 0.008781054988503456,
+      "improvement": 6.878282874822617e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.24.attn.out_proj",
+      "block": 24,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009803637862205505,
+      "searched_error": 0.009698456153273582,
+      "improvement": 0.00010518170893192291,
+      "clipped_row_fraction": 0.375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.24.mlp.fc1",
+      "block": 24,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008830823004245758,
+      "searched_error": 0.00879497081041336,
+      "improvement": 3.585219383239746e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.24.mlp.fc2",
+      "block": 24,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009445111267268658,
+      "searched_error": 0.009153909049928188,
+      "improvement": 0.00029120221734046936,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.25.attn.qkv_proj",
+      "block": 25,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009023238904774189,
+      "searched_error": 0.008959091268479824,
+      "improvement": 6.414763629436493e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.25.attn.out_proj",
+      "block": 25,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009833511896431446,
+      "searched_error": 0.009738020598888397,
+      "improvement": 9.549129754304886e-05,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.25.mlp.fc1",
+      "block": 25,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008853540755808353,
+      "searched_error": 0.008794158697128296,
+      "improvement": 5.9382058680057526e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.25.mlp.fc2",
+      "block": 25,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009346915408968925,
+      "searched_error": 0.009076721034944057,
+      "improvement": 0.000270194374024868,
+      "clipped_row_fraction": 0.765625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.26.attn.qkv_proj",
+      "block": 26,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008902003057301044,
+      "searched_error": 0.008850892074406147,
+      "improvement": 5.111098289489746e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.26.attn.out_proj",
+      "block": 26,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010004710406064987,
+      "searched_error": 0.009898032993078232,
+      "improvement": 0.00010667741298675537,
+      "clipped_row_fraction": 0.390625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.26.mlp.fc1",
+      "block": 26,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008825123310089111,
+      "searched_error": 0.008754185400903225,
+      "improvement": 7.093790918588638e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.26.mlp.fc2",
+      "block": 26,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.0092239361256361,
+      "searched_error": 0.008974296040832996,
+      "improvement": 0.0002496400848031044,
+      "clipped_row_fraction": 0.765625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.27.attn.qkv_proj",
+      "block": 27,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008917473256587982,
+      "searched_error": 0.008879797533154488,
+      "improvement": 3.767572343349457e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.27.attn.out_proj",
+      "block": 27,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010261861607432365,
+      "searched_error": 0.010153005830943584,
+      "improvement": 0.00010885577648878098,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.27.mlp.fc1",
+      "block": 27,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008872292935848236,
+      "searched_error": 0.008831623010337353,
+      "improvement": 4.066992551088333e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.27.mlp.fc2",
+      "block": 27,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009318964555859566,
+      "searched_error": 0.0090524572879076,
+      "improvement": 0.00026650726795196533,
+      "clipped_row_fraction": 0.78125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.28.attn.qkv_proj",
+      "block": 28,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008684765547513962,
+      "searched_error": 0.008628505282104015,
+      "improvement": 5.626026540994644e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.28.attn.out_proj",
+      "block": 28,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010002732276916504,
+      "searched_error": 0.009931528940796852,
+      "improvement": 7.12033361196518e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.28.mlp.fc1",
+      "block": 28,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008683769032359123,
+      "searched_error": 0.008647016249597073,
+      "improvement": 3.675278276205063e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.28.mlp.fc2",
+      "block": 28,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009296281263232231,
+      "searched_error": 0.00901525653898716,
+      "improvement": 0.0002810247242450714,
+      "clipped_row_fraction": 0.828125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.29.attn.qkv_proj",
+      "block": 29,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008713721297681332,
+      "searched_error": 0.008659077808260918,
+      "improvement": 5.464348942041397e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.29.attn.out_proj",
+      "block": 29,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009850416332483292,
+      "searched_error": 0.009744553826749325,
+      "improvement": 0.00010586250573396683,
+      "clipped_row_fraction": 0.34375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.29.mlp.fc1",
+      "block": 29,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008692266419529915,
+      "searched_error": 0.008643834851682186,
+      "improvement": 4.843156784772873e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.29.mlp.fc2",
+      "block": 29,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009496194310486317,
+      "searched_error": 0.00922020897269249,
+      "improvement": 0.00027598533779382706,
+      "clipped_row_fraction": 0.84375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.30.attn.qkv_proj",
+      "block": 30,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008765683509409428,
+      "searched_error": 0.00874114129692316,
+      "improvement": 2.454221248626709e-05,
+      "clipped_row_fraction": 0.109375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.30.attn.out_proj",
+      "block": 30,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009816651232540607,
+      "searched_error": 0.00971936620771885,
+      "improvement": 9.728502482175827e-05,
+      "clipped_row_fraction": 0.34375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.30.mlp.fc1",
+      "block": 30,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008752512745559216,
+      "searched_error": 0.008692821487784386,
+      "improvement": 5.9691257774829865e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.30.mlp.fc2",
+      "block": 30,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009255063720047474,
+      "searched_error": 0.008998647332191467,
+      "improvement": 0.0002564163878560066,
+      "clipped_row_fraction": 0.75,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.31.attn.qkv_proj",
+      "block": 31,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008724010549485683,
+      "searched_error": 0.008665692992508411,
+      "improvement": 5.8317556977272034e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.31.attn.out_proj",
+      "block": 31,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009994729422032833,
+      "searched_error": 0.009889819659292698,
+      "improvement": 0.00010490976274013519,
+      "clipped_row_fraction": 0.375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.31.mlp.fc1",
+      "block": 31,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00875474326312542,
+      "searched_error": 0.008676552213728428,
+      "improvement": 7.819104939699173e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.31.mlp.fc2",
+      "block": 31,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009443852119147778,
+      "searched_error": 0.009161427617073059,
+      "improvement": 0.0002824245020747185,
+      "clipped_row_fraction": 0.796875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.32.attn.qkv_proj",
+      "block": 32,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008674316108226776,
+      "searched_error": 0.008613810874521732,
+      "improvement": 6.050523370504379e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.32.attn.out_proj",
+      "block": 32,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00985008291900158,
+      "searched_error": 0.009747494012117386,
+      "improvement": 0.00010258890688419342,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.32.mlp.fc1",
+      "block": 32,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008692612871527672,
+      "searched_error": 0.008645152673125267,
+      "improvement": 4.7460198402404785e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.32.mlp.fc2",
+      "block": 32,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00947093777358532,
+      "searched_error": 0.009159333072602749,
+      "improvement": 0.00031160470098257065,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.33.attn.qkv_proj",
+      "block": 33,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008766084909439087,
+      "searched_error": 0.008694433607161045,
+      "improvement": 7.165130227804184e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.33.attn.out_proj",
+      "block": 33,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00954029243439436,
+      "searched_error": 0.009445435367524624,
+      "improvement": 9.485706686973572e-05,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.33.mlp.fc1",
+      "block": 33,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008781595155596733,
+      "searched_error": 0.008732284419238567,
+      "improvement": 4.931073635816574e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.33.mlp.fc2",
+      "block": 33,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009335415437817574,
+      "searched_error": 0.00904041063040495,
+      "improvement": 0.00029500480741262436,
+      "clipped_row_fraction": 0.828125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.34.attn.qkv_proj",
+      "block": 34,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008966388180851936,
+      "searched_error": 0.008931505493819714,
+      "improvement": 3.488268703222275e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.34.attn.out_proj",
+      "block": 34,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009540051221847534,
+      "searched_error": 0.009449652396142483,
+      "improvement": 9.039882570505142e-05,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.34.mlp.fc1",
+      "block": 34,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008829145692288876,
+      "searched_error": 0.008788610808551311,
+      "improvement": 4.053488373756409e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.34.mlp.fc2",
+      "block": 34,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009387649595737457,
+      "searched_error": 0.009096373803913593,
+      "improvement": 0.000291275791823864,
+      "clipped_row_fraction": 0.875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.35.attn.qkv_proj",
+      "block": 35,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008860242553055286,
+      "searched_error": 0.008821065537631512,
+      "improvement": 3.917701542377472e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.35.attn.out_proj",
+      "block": 35,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009603094309568405,
+      "searched_error": 0.009491439908742905,
+      "improvement": 0.00011165440082550049,
+      "clipped_row_fraction": 0.390625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.35.mlp.fc1",
+      "block": 35,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008813166990876198,
+      "searched_error": 0.008791708387434483,
+      "improvement": 2.145860344171524e-05,
+      "clipped_row_fraction": 0.09375,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.35.mlp.fc2",
+      "block": 35,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009444838389754295,
+      "searched_error": 0.009172103367745876,
+      "improvement": 0.00027273502200841904,
+      "clipped_row_fraction": 0.765625,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.36.attn.qkv_proj",
+      "block": 36,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008860931731760502,
+      "searched_error": 0.00881150271743536,
+      "improvement": 4.942901432514191e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.36.attn.out_proj",
+      "block": 36,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009988026693463326,
+      "searched_error": 0.009919547475874424,
+      "improvement": 6.847921758890152e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.36.mlp.fc1",
+      "block": 36,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.0088988421484828,
+      "searched_error": 0.008851088583469391,
+      "improvement": 4.775356501340866e-05,
+      "clipped_row_fraction": 0.1875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.36.mlp.fc2",
+      "block": 36,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009266898967325687,
+      "searched_error": 0.008992289192974567,
+      "improvement": 0.00027460977435112,
+      "clipped_row_fraction": 0.796875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.37.attn.qkv_proj",
+      "block": 37,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008839167654514313,
+      "searched_error": 0.00880094151943922,
+      "improvement": 3.8226135075092316e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.37.attn.out_proj",
+      "block": 37,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010024740360677242,
+      "searched_error": 0.009966987185180187,
+      "improvement": 5.7753175497055054e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.37.mlp.fc1",
+      "block": 37,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008853678591549397,
+      "searched_error": 0.008804235607385635,
+      "improvement": 4.944298416376114e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.37.mlp.fc2",
+      "block": 37,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009491628967225552,
+      "searched_error": 0.009205091744661331,
+      "improvement": 0.00028653722256422043,
+      "clipped_row_fraction": 0.8125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.38.attn.qkv_proj",
+      "block": 38,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008884002454578876,
+      "searched_error": 0.008830550126731396,
+      "improvement": 5.3452327847480774e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.38.attn.out_proj",
+      "block": 38,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.01087699644267559,
+      "searched_error": 0.01077630091458559,
+      "improvement": 0.00010069552809000015,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.38.mlp.fc1",
+      "block": 38,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008931271731853485,
+      "searched_error": 0.008866948075592518,
+      "improvement": 6.432365626096725e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.38.mlp.fc2",
+      "block": 38,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009255966171622276,
+      "searched_error": 0.008989330381155014,
+      "improvement": 0.00026663579046726227,
+      "clipped_row_fraction": 0.796875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.39.attn.qkv_proj",
+      "block": 39,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008898977190256119,
+      "searched_error": 0.008829842321574688,
+      "improvement": 6.913486868143082e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.39.attn.out_proj",
+      "block": 39,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00986478291451931,
+      "searched_error": 0.00979786366224289,
+      "improvement": 6.69192522764206e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.39.mlp.fc1",
+      "block": 39,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008810189552605152,
+      "searched_error": 0.008753194473683834,
+      "improvement": 5.6995078921318054e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.39.mlp.fc2",
+      "block": 39,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009537908248603344,
+      "searched_error": 0.009237056598067284,
+      "improvement": 0.00030085165053606033,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.40.attn.qkv_proj",
+      "block": 40,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008767694234848022,
+      "searched_error": 0.00870572030544281,
+      "improvement": 6.19739294052124e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.40.attn.out_proj",
+      "block": 40,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009701002389192581,
+      "searched_error": 0.009602167643606663,
+      "improvement": 9.883474558591843e-05,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.40.mlp.fc1",
+      "block": 40,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008829804137349129,
+      "searched_error": 0.008786809630692005,
+      "improvement": 4.2994506657123566e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.40.mlp.fc2",
+      "block": 40,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009279806166887283,
+      "searched_error": 0.009015350602567196,
+      "improvement": 0.00026445556432008743,
+      "clipped_row_fraction": 0.78125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.41.attn.qkv_proj",
+      "block": 41,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00888835359364748,
+      "searched_error": 0.008865226991474628,
+      "improvement": 2.3126602172851562e-05,
+      "clipped_row_fraction": 0.09375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.41.attn.out_proj",
+      "block": 41,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009856064803898335,
+      "searched_error": 0.009737283922731876,
+      "improvement": 0.00011878088116645813,
+      "clipped_row_fraction": 0.40625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.41.mlp.fc1",
+      "block": 41,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008642565459012985,
+      "searched_error": 0.008587867952883244,
+      "improvement": 5.469750612974167e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.41.mlp.fc2",
+      "block": 41,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009489201940596104,
+      "searched_error": 0.009183059446513653,
+      "improvement": 0.00030614249408245087,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.42.attn.qkv_proj",
+      "block": 42,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00878732930868864,
+      "searched_error": 0.008722234517335892,
+      "improvement": 6.509479135274887e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.42.attn.out_proj",
+      "block": 42,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009849688038229942,
+      "searched_error": 0.009761529974639416,
+      "improvement": 8.815806359052658e-05,
+      "clipped_row_fraction": 0.3125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.42.mlp.fc1",
+      "block": 42,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00881112739443779,
+      "searched_error": 0.008781219832599163,
+      "improvement": 2.990756183862686e-05,
+      "clipped_row_fraction": 0.140625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.42.mlp.fc2",
+      "block": 42,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009377618320286274,
+      "searched_error": 0.009100445546209812,
+      "improvement": 0.0002771727740764618,
+      "clipped_row_fraction": 0.8125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.43.attn.qkv_proj",
+      "block": 43,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00880368147045374,
+      "searched_error": 0.00876226183027029,
+      "improvement": 4.141964018344879e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.43.attn.out_proj",
+      "block": 43,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010473590344190598,
+      "searched_error": 0.010342192836105824,
+      "improvement": 0.00013139750808477402,
+      "clipped_row_fraction": 0.40625,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.43.mlp.fc1",
+      "block": 43,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00889844261109829,
+      "searched_error": 0.008808812126517296,
+      "improvement": 8.963048458099365e-05,
+      "clipped_row_fraction": 0.34375,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.43.mlp.fc2",
+      "block": 43,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009177000261843204,
+      "searched_error": 0.008896099403500557,
+      "improvement": 0.00028090085834264755,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.44.attn.qkv_proj",
+      "block": 44,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008935483172535896,
+      "searched_error": 0.008860749192535877,
+      "improvement": 7.473398000001907e-05,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.44.attn.out_proj",
+      "block": 44,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010236470960080624,
+      "searched_error": 0.010147100314497948,
+      "improvement": 8.937064558267593e-05,
+      "clipped_row_fraction": 0.3125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.44.mlp.fc1",
+      "block": 44,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008784499950706959,
+      "searched_error": 0.00872789416462183,
+      "improvement": 5.6605786085128784e-05,
+      "clipped_row_fraction": 0.21875,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.44.mlp.fc2",
+      "block": 44,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009541667997837067,
+      "searched_error": 0.009210311807692051,
+      "improvement": 0.0003313561901450157,
+      "clipped_row_fraction": 0.953125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.45.attn.qkv_proj",
+      "block": 45,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008662065491080284,
+      "searched_error": 0.008622739464044571,
+      "improvement": 3.9326027035713196e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.45.attn.out_proj",
+      "block": 45,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010617692954838276,
+      "searched_error": 0.010556809604167938,
+      "improvement": 6.088335067033768e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.45.mlp.fc1",
+      "block": 45,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00887010246515274,
+      "searched_error": 0.008804753422737122,
+      "improvement": 6.53490424156189e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.45.mlp.fc2",
+      "block": 45,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009545751847326756,
+      "searched_error": 0.009240850806236267,
+      "improvement": 0.00030490104109048843,
+      "clipped_row_fraction": 0.859375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.46.attn.qkv_proj",
+      "block": 46,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008876703679561615,
+      "searched_error": 0.008820494636893272,
+      "improvement": 5.620904266834259e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.46.attn.out_proj",
+      "block": 46,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010161706246435642,
+      "searched_error": 0.010050925426185131,
+      "improvement": 0.00011078082025051117,
+      "clipped_row_fraction": 0.359375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.46.mlp.fc1",
+      "block": 46,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008911539800465107,
+      "searched_error": 0.008827130310237408,
+      "improvement": 8.440949022769928e-05,
+      "clipped_row_fraction": 0.265625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.46.mlp.fc2",
+      "block": 46,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009484718553721905,
+      "searched_error": 0.009192200377583504,
+      "improvement": 0.00029251817613840103,
+      "clipped_row_fraction": 0.828125,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.47.attn.qkv_proj",
+      "block": 47,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008795163594186306,
+      "searched_error": 0.00872830580919981,
+      "improvement": 6.685778498649597e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.47.attn.out_proj",
+      "block": 47,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010367481037974358,
+      "searched_error": 0.010297443717718124,
+      "improvement": 7.003732025623322e-05,
+      "clipped_row_fraction": 0.234375,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.47.mlp.fc1",
+      "block": 47,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008772429078817368,
+      "searched_error": 0.00872031506150961,
+      "improvement": 5.211401730775833e-05,
+      "clipped_row_fraction": 0.203125,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.47.mlp.fc2",
+      "block": 47,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00934167392551899,
+      "searched_error": 0.009070958010852337,
+      "improvement": 0.0002707159146666527,
+      "clipped_row_fraction": 0.796875,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.48.attn.qkv_proj",
+      "block": 48,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.00887906365096569,
+      "searched_error": 0.008829780854284763,
+      "improvement": 4.9282796680927277e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.48.attn.out_proj",
+      "block": 48,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009912649169564247,
+      "searched_error": 0.009812348522245884,
+      "improvement": 0.00010030064731836319,
+      "clipped_row_fraction": 0.328125,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.48.mlp.fc1",
+      "block": 48,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008999514393508434,
+      "searched_error": 0.008927279151976109,
+      "improvement": 7.223524153232574e-05,
+      "clipped_row_fraction": 0.25,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.48.mlp.fc2",
+      "block": 48,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009443627670407295,
+      "searched_error": 0.009146802127361298,
+      "improvement": 0.0002968255430459976,
+      "clipped_row_fraction": 0.84375,
+      "bf16_delta_bytes": 77048760
+    },
+    {
+      "layer": "blocks.49.attn.qkv_proj",
+      "block": 49,
+      "kind": "attn.qkv_proj",
+      "shape": [
+        21504,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008813359774649143,
+      "searched_error": 0.008786115795373917,
+      "improvement": 2.7243979275226593e-05,
+      "clipped_row_fraction": 0.171875,
+      "bf16_delta_bytes": 115519416
+    },
+    {
+      "layer": "blocks.49.attn.out_proj",
+      "block": 49,
+      "kind": "attn.out_proj",
+      "shape": [
+        5376,
+        7168
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.010824794881045818,
+      "searched_error": 0.010720481164753437,
+      "improvement": 0.00010431371629238129,
+      "clipped_row_fraction": 0.296875,
+      "bf16_delta_bytes": 38513592
+    },
+    {
+      "layer": "blocks.49.mlp.fc1",
+      "block": 49,
+      "kind": "mlp.fc1",
+      "shape": [
+        28672,
+        5376
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.008785880170762539,
+      "searched_error": 0.008741860277950764,
+      "improvement": 4.401989281177521e-05,
+      "clipped_row_fraction": 0.15625,
+      "bf16_delta_bytes": 154025912
+    },
+    {
+      "layer": "blocks.49.mlp.fc2",
+      "block": 49,
+      "kind": "mlp.fc2",
+      "shape": [
+        5376,
+        14336
+      ],
+      "sample_rows": 64,
+      "absmax_error": 0.009804457426071167,
+      "searched_error": 0.009507114998996258,
+      "improvement": 0.0002973424270749092,
+      "clipped_row_fraction": 0.8125,
+      "bf16_delta_bytes": 77048760
+    }
+  ]
+}

reports/validation.json

@@ -0,0 +1,46 @@
+{
+  "release_date": "2026-08-04",
+  "checkpoint": "FL2VA/minimax-h3-fl2va-int8-lean-convrot-dynamic-k16-quality21.safetensors",
+  "bytes": 22547336976,
+  "gib": 20.998843923211098,
+  "sha256": "c57e85fc299ca399a5c84e7888b0f61c532da05ddbf3f92e521690b07cb72b0a",
+  "tensor_keys": 877,
+  "dtype_key_counts": {
+    "F32": 287,
+    "BF16": 250,
+    "I8": 170,
+    "U8": 170
+  },
+  "checks": {
+    "safetensors_open": "pass",
+    "int8_quant_blobs": "170/170, ConvRot group size 256",
+    "bf16_main_policy": "30/30 present and bitwise equal to raw HF",
+    "fp32_time_embedder": "4/4 tensors bitwise equal to raw HF",
+    "basis_orthogonality_max_abs": 5.364418029785156e-7,
+    "adaln_relative_error_9_timesteps": {
+      "block_0": 3.260e-7,
+      "block_24": 3.290e-7,
+      "block_49": 3.192e-7,
+      "final": 2.820e-7
+    },
+    "comfyui_cpu_load": "pass: ModelPatcher -> MiniMaxH3Model; dynamic basis enabled; table mode disabled",
+    "comfyui_tested_commit": "14b05228cef127ce529bc0c08660770d4af3e9a8"
+  },
+  "sampled_main_matrix_proxy": {
+    "method": "deterministic 64 output rows per matrix, all input columns, 200/200 main matrices",
+    "official_absmax_mean_relative_error_percent": 0.934502442367375,
+    "quality21_effective_mean_relative_error_percent": 0.7638806365430355,
+    "relative_reduction_percent": 18.258037442053465,
+    "selected_bf16_official_proxy_mean_percent": 1.0684306019296248,
+    "remaining_int8_absmax_mean_percent": 0.9108680612681544,
+    "remaining_int8_searched_scale_mean_percent": 0.898683101815336,
+    "remaining_int8_relative_reduction_percent": 1.3377304541619235,
+    "warning": "This is a weight-reconstruction proxy, not an end-to-end generation or perceptual benchmark."
+  },
+  "not_yet_tested": [
+    "GPU load through ComfyUI",
+    "peak VRAM at a target resolution/frame count",
+    "end-to-end FL2VA generation",
+    "same-seed visual/audio A/B against BF16 and official pruned checkpoints"
+  ]
+}

requirements.txt

@@ -0,0 +1,3 @@
+torch
+safetensors
+comfy-kitchen

tools/README.md

@@ -0,0 +1,49 @@
+# Reproduction tools
+
+These are the exact converter, profiler, and validator used for this release,
+with local paths replaced by CLI arguments. They are research utilities, not a
+general MiniMax-H3 conversion library.
+
+Requirements:
+
+- Python 3.10+
+- PyTorch
+- `safetensors`
+- `comfy-kitchen` from a current ComfyUI environment
+
+The converter reads the original top-level Diffusers shards directly; it does
+not need a merged BF16 file. Use `MiniMaxAI/MiniMax-H3`'s `transformer/` folder,
+not the nested task folder whose already-packed QKV uses a different row order.
+It also uses the official pruned ComfyOrg file as a structural reference and to
+copy `rope.inv_freq`, which is absent from the raw Diffusers state dict.
+
+Dry run:
+
+```bash
+python tools/mm_quantize_lean.py fl2va \
+  --src /path/to/MiniMax-H3/transformer \
+  --reference /path/to/minimax_h3_fl2va_pruned_int8_convrot.safetensors \
+  --dst /path/to/output.safetensors \
+  --profile quality21 --time-mode dynamic --rank 16 --device cpu --dry-run
+```
+
+Build on CPU:
+
+```bash
+python tools/mm_quantize_lean.py fl2va \
+  --src /path/to/MiniMax-H3/transformer \
+  --reference /path/to/minimax_h3_fl2va_pruned_int8_convrot.safetensors \
+  --dst /path/to/output.safetensors \
+  --profile quality21 --time-mode dynamic --rank 16 --device cpu --overwrite
+```
+
+Validate:
+
+```bash
+python tools/mm_validate_dynamic_built.py fl2va /path/to/output.safetensors \
+  --src /path/to/MiniMax-H3/transformer --profile quality21
+```
+
+The public scripts preserve the exact mapping and quantization behavior used by
+the release. Some diagnostic messages remain in Russian because these files are
+the audited build sources rather than a rewritten approximation.

tools/convert_int8_convrot.py

@@ -0,0 +1,556 @@
+# -*- coding: utf-8 -*-
+r"""Конвертер моделей ComfyUI в INT8 ConvRot.
+
+Берёт safetensors (bf16/fp16/fp32) и квантует линейные слои в int8 с поворотом
+Адамара, как это делают официальные сборки Comfy-Org (int8_tensorwise + convrot).
+
+Не трогает: нормализации, эмбеддеры, bias, 1D-тензоры и матрицы, у которых
+входная размерность не кратна размеру группы — они остаются в исходной точности.
+
+Запуск:
+  python_embeded\python.exe -s tools\convert_int8_convrot.py <вход.safetensors> <выход.safetensors>
+     [--groupsize 256] [--device cuda:0] [--dry-run]
+"""
+import argparse
+import json
+import os
+import re
+import sys
+import time
+
+import torch
+from safetensors import safe_open
+from safetensors.torch import save_file
+
+
+class HFShardReader:
+    """Читает HF-репозиторий (папку с шардами) так же, как safe_open один файл.
+
+    Нужно, чтобы квантовать прямо из оригинала, не складывая на диск
+    промежуточный файл на десятки гигабайт. Значения при этом те же самые:
+    склейка ничего не меняла, но лишняя запись и чтение никому не нужны.
+
+    Имена приводятся к раскладке ComfyUI теми же правилами, что в
+    merge_hf_to_comfy.py, визуальная часть остаётся на месте.
+    """
+
+    RENAME = [
+        ("model.language_model.", "model."),
+        ("language_model.model.", "model."),
+        ("language_model.", ""),
+        ("vision_tower.", ""),
+    ]
+
+    def __init__(self, path: str):
+        import glob
+        self._files = {}
+        self._map = {}
+        shards = sorted(glob.glob(os.path.join(path, "*.safetensors")))
+        if not shards:
+            raise SystemExit(f"в папке нет файлов safetensors: {path}")
+        for shard in shards:
+            f = safe_open(shard, framework="pt")
+            self._files[shard] = f
+            for k in f.keys():
+                self._map[self._rename(k)] = (shard, k)
+        print(f"  прочитано шардов: {len(shards)}, тензоров: {len(self._map)}")
+
+    @classmethod
+    def _rename(cls, key: str) -> str:
+        for old, new in cls.RENAME:
+            if key.startswith(old):
+                rest = key[len(old):]
+                return rest if rest.startswith("model.") or not new else new + rest
+        return key
+
+    def keys(self):
+        return list(self._map)
+
+    def get_tensor(self, key: str):
+        shard, orig = self._map[key]
+        return self._files[shard].get_tensor(orig)
+
+    def metadata(self):
+        return {"format": "pt"}
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self._files.clear()
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "ComfyUI"))
+
+# Слои, которые официальные сборки Comfy-Org оставляют в исходной точности:
+# нормализации, эмбеддеры, входной/выходной слой. Их квантование заметно бьёт по качеству.
+SKIP_TOKENS = (
+    # диффузионные трансформеры
+    # "_emb." с точкой, а не "_emb": иначе под запрет попадают модули вида
+    # video_embeddings_connector - а это обычные блоки внимания и полносвязные
+    # слои на 4 ГБ, которые квантовать можно и нужно
+    "norm", "embedder", "pad_token", "emb.", "_emb.",
+    "final_layer", "x_embedder", "proj_out", "time_in", "vector_in",
+    # Слои модуляции: выдают масштаб и сдвиг для каждого блока, поэтому ошибка
+    # в них умножается на всю сеть. Мы их не квантуем НИКОГДА - это наше решение
+    # по замеру, а не подражание чужим сборкам.
+    #
+    # Единодушия у авторов тут нет, пересчитано по файлам на диске 31.07.2026:
+    #   LTX 2.3      0 из 24  квантовано
+    #   Anima        0 из 170
+    #   Z-Image     32 из 33  <- квантует, вопреки прежней записи в этом коде
+    # Поэтому по Z-Image и Ideogram сверка audit_reference_int8.py всегда будет
+    # показывать ~84 %, и это ОСОЗНАННОЕ расхождение, а не промах правила.
+    "adaln", "modulation",
+    # входные проекции (diffusers-нейминг): в эталонных сборках Comfy-Org,
+    # obsxrver и supermind они всегда остаются в исходной точности - проверено
+    # по файлам LTX 2.3, Z-Image, Krea 2 и Qwen-Image
+    "img_in", "txt_in", "patch_embed", "context_embedder",
+    # языковые модели (текст-энкодеры)
+    "lm_head", "embed_tokens", "token_embd", "shared.", "wte", "wpe",
+    # части полных чекпоинтов, которые квантовать нельзя: VAE свёрточный и к
+    # int8 чувствителен, текстовая проекция маленькая и стоит на входе, а
+    # per_channel_statistics - это вообще не веса, а нормировочные константы
+    "vae.", "text_embedding_projection", "per_channel_statistics", "vocoder.",
+)
+
+# Коэффициенты подрезания выбросов при подборе масштаба.
+# У диффузионных моделей оптимум почти всегда в 0.95-1.00 (медиана 0.982), поэтому
+# основная часть сетки плотная: шаг 0.001 в диапазоне 1.000-0.940. Но у текст-энкодеров
+# хвосты тяжелее: у qwen2.5-VL 3.2% строк упирались в край 0.940, то есть их оптимум
+# лежал ещё ниже и просто не находился. Поэтому дальше идёт разреженный хвост до 0.80 -
+# он почти не стоит времени, зато снимает обрезание перебора. См. tools/check_range.py.
+def build_ratios(lo: float = 0.80) -> tuple:
+    """Сетка от 1.0 вниз до lo: плотно у единицы, дальше всё разреженнее."""
+    out = [round(1.0 - i * 0.001, 4) for i in range(61)]       # 1.000 .. 0.940
+    out += [round(0.938 - i * 0.002, 4) for i in range(20)]    # 0.938 .. 0.900
+    out += [round(0.895 - i * 0.005, 4) for i in range(20)]    # 0.895 .. 0.800
+    return tuple(r for r in out if r >= lo - 1e-9)
+
+
+SEARCH_RATIOS = build_ratios()
+
+
+# Поворот Адамара строится удвоением матрицы 4x4, поэтому размер группы обязан
+# быть степенью четвёрки (см. _build_hadamard: "Regular Hadamard size must be a
+# power of 4"). Отсюда и лесенка: 256 -> 64 -> 16.
+GROUPSIZE_LADDER = (256, 64, 16)
+
+_DIGITS = re.compile(r"\d+")
+# Порог повторяемости. Два - это ещё не стопка: linear_fc1/linear_fc2 одного
+# модуля дают ровно два совпадения по шаблону.
+REPEAT_MIN = 3
+
+
+def block_patterns(layer: str) -> tuple[str, ...]:
+    """Варианты имени, где обезличена ровно одна числовая позиция.
+
+    Одновременная замена всех цифр смешивала независимые роли. Например,
+    ``blocks.0.mlp.fc1`` и ``blocks.1.mlp.fc2`` превращались в один шаблон.
+    Из-за этого два блока token_refiner с fc1/fc2 давали ложную стопку из
+    четырёх слоёв и проходили порог повторяемости 3.
+    """
+    return tuple(layer[:m.start()] + "#" + layer[m.end():] for m in _DIGITS.finditer(layer))
+
+
+def repeated_layers(layer_names, repeat_min: int = REPEAT_MIN) -> set:
+    """Слои, которые входят в повторяющуюся стопку блоков.
+
+    Зачем это вместо списка подстрок. Эталонные сборки квантуют тело сети и
+    оставляют в исходной точности края: входные проекции, выходные головы,
+    таблицы вложений, мост зрение->язык. Объединяет их не название, а то, что
+    они существуют в единственном экземпляре, тогда как тело - это одна и та же
+    ноd, повторённая по числу блоков. Номер блока в имени и есть тот признак,
+    который отличает тело от края, и он не зависит от того, как автор модели
+    назвал свои модули.
+
+    Проверено сверкой с эталонами (tools/audit_reference_int8.py): по этому
+    признаку сами собой отсеиваются lm_head, embed_tokens, patchify_proj,
+    visual.merger, visual.pos_embed, adaln_single.emb.* - всё то, что раньше
+    приходилось перечислять руками.
+    """
+    counts: dict[str, int] = {}
+    for name in layer_names:
+        for pattern in set(block_patterns(name)):
+            counts[pattern] = counts.get(pattern, 0) + 1
+    return {
+        name for name in layer_names
+        if any(counts[pattern] >= repeat_min for pattern in block_patterns(name))
+    }
+
+
+def pick_groupsize(out_f: int, in_f: int, groupsize) -> int | None:
+    """Какую группу взять этому слою. Число - взять его же или отказать.
+
+    "auto" спускается по лесенке до первой группы, на которую делится входная
+    размерность. Это нужно зрительным башням: у Qwen3-VL ширина 1152 и 4304, ни
+    одна из них не кратна 256, поэтому при фиксированной группе всё зрение
+    оставалось в bf16. Эталонные сборки supermind делают ровно так же - проверено
+    по comfy_quant в qwen3vl_8b_int8_convrot: 256 у языковой части, 64 у
+    visual.attn, 16 у visual.mlp.linear_fc2.
+    """
+    if groupsize != "auto":
+        g = int(groupsize)
+        return g if in_f % g == 0 and min(out_f, in_f) >= g else None
+    # Мелкая группа - способ достать слой с неудобной шириной, а не разрешение
+    # квантовать что угодно узкое. Порог по узкой стороне остаётся базовым (256),
+    # иначе в отбор лезут краевые слои: gate_logits (32 x 4096) и входные
+    # проекции с пикселей patchify_proj (4096 x 128). Эталонные сборки LTX их не
+    # берут - сверено поимённо в tools/audit_reference_int8.py.
+    if min(out_f, in_f) < GROUPSIZE_LADDER[0]:
+        return None
+    for g in GROUPSIZE_LADDER:
+        if in_f % g == 0:
+            return g
+    return None
+
+
+def should_quantize(name: str, t: torch.Tensor, groupsize,
+                    skip_tokens=None, repeated=None) -> tuple[bool, str, int]:
+    if not name.endswith(".weight"):
+        return False, "не weight", 0
+    if t.ndim != 2:
+        return False, f"ndim={t.ndim}", 0
+    if repeated is not None and name[: -len(".weight")] not in repeated:
+        return False, "одиночный слой (не повторяется по блокам)", 0
+    low = name.lower()
+    for tok in (SKIP_TOKENS if skip_tokens is None else skip_tokens):
+        if tok in low:
+            return False, f"имя содержит '{tok}'", 0
+    out_f, in_f = t.shape
+    g = pick_groupsize(out_f, in_f, groupsize)
+    if g is None:
+        if in_f % (int(groupsize) if groupsize != "auto" else GROUPSIZE_LADDER[-1]):
+            return False, f"in_features {in_f} не кратно {groupsize}", 0
+        return False, f"слишком маленький слой {tuple(t.shape)}", 0
+    return True, "", g
+
+
+def _cost(residual: torch.Tensor, objective: str, step: torch.Tensor,
+          chan_w: torch.Tensor | None = None) -> torch.Tensor:
+    """Во что нам обходится остаток. Сетка значений всегда равномерная - ядро
+    разжимает строго как q*scale, кодбука в формате нет. Свободен только критерий,
+    по которому выбирается точка подрезания, и от него зависит, насколько сильно
+    мы готовы жертвовать выбросами ради основной массы весов.
+
+      mse   - квадрат: выбросы дороги, подрезаем осторожно
+      l1    - модуль: выбросы дешевле, подрезаем смелее
+      huber - квадрат вблизи нуля, модуль дальше: компромисс
+    """
+    # Взвешивание по каналам (AWQ-стиль): ошибка в канале, по которому приходят
+    # большие активации, стоит дороже. chan_w - средний квадрат входа по каналам,
+    # снятый capture_activations.py уже в повёрнутом пространстве. Это в точности
+    # диагональ гессиана слоя, то есть переход от "ошибки весов" к "ошибке выхода".
+    if objective == "mse":
+        sq = residual ** 2
+        if chan_w is not None:
+            sq = sq * chan_w
+        return sq.sum(dim=1, keepdim=True)
+    if objective == "l1":
+        a = residual.abs()
+        if chan_w is not None:
+            a = a * chan_w
+        return a.sum(dim=1, keepdim=True)
+    if objective == "huber":
+        d = step                      # порог - один шаг кванта
+        a = residual.abs()
+        quad = torch.minimum(a, d)
+        h = 0.5 * quad ** 2 + d * (a - quad)
+        if chan_w is not None:
+            h = h * chan_w
+        return h.sum(dim=1, keepdim=True)
+    raise SystemExit(f"неизвестный критерий {objective}")
+
+
+def quantize_search(w: torch.Tensor, groupsize: int, ratios,
+                    objective: str = "mse",
+                    qmin: int = -127,
+                    sign_aware: bool = False,
+                    ls_refit: bool = False,
+                    chan_w: torch.Tensor | None = None,
+                    clip_margin: float = 0.0) -> tuple[torch.Tensor, torch.Tensor]:
+    """INT8 ConvRot с подбором масштаба по минимуму ошибки (вместо простого absmax).
+
+    Официальные сборки берут scale = absmax/127. Небольшое подрезание выбросов
+    почти всегда уменьшает суммарную ошибку: редкие большие веса округляются
+    чуть грубее, зато основная масса значений ложится на сетку точнее.
+    """
+    from comfy_kitchen.backends.eager.quantization import _build_hadamard, _rotate_weight
+
+    h = _build_hadamard(groupsize, device=w.device, dtype=w.dtype)
+    w_rot = _rotate_weight(w, h, groupsize)
+
+    absmax = w_rot.abs().amax(dim=1, keepdim=True).clamp(min=1e-12)
+    best_scale = absmax / 127.0
+    best_err = torch.full_like(absmax, float("inf"))
+
+    if sign_aware:
+        # Единственный честный способ дотянуться до -128: разрешать его только
+        # тем строкам, у которых отрицательный хвост и так длиннее положительного.
+        # Тогда несимметричная сетка не создаёт перекос, а повторяет уже имеющийся.
+        neg_heavy = w_rot.amin(dim=1, keepdim=True).abs() > w_rot.amax(dim=1, keepdim=True)
+        lo = torch.where(neg_heavy, -128.0, -127.0).to(w_rot.dtype)
+    else:
+        lo = torch.full_like(absmax, float(qmin))
+    hi = torch.full_like(absmax, 127.0)
+
+    # qmin=-127 (симметрично) по умолчанию. Значение -128 формально доступно и
+    # уменьшает ошибку весов, но вносит односторонний сдвиг: сетка перестаёт быть
+    # симметричной, у ошибки появляется ненулевое среднее, и на генерации это
+    # выходит дороже выигрыша. Проверено на стенде - см. bench_quant.py.
+    for r in ratios:
+        scale = absmax * r / 127.0
+        q = torch.minimum(torch.maximum(torch.round(w_rot / scale), lo), hi)
+        err = _cost(q * scale - w_rot, objective, scale, chan_w)
+        better = err < best_err
+        best_err = torch.where(better, err, best_err)
+        best_scale = torch.where(better, scale, best_scale)
+
+    if clip_margin > 0.0:
+        # Порог на подрезание. Эталонные сборки оставляют без подрезания заметно
+        # больше строк, чем даёт чистый минимум MSE (у qwen3-4b 9.4% против наших
+        # 2-3%), и на выходе энкодера это оказывается лучше. Похоже, у выбросов
+        # есть функциональная роль, которую квадрат ошибки не видит. Поэтому режем
+        # только там, где выигрыш действительно заметный.
+        s0 = absmax / 127.0
+        q0 = torch.minimum(torch.maximum(torch.round(w_rot / s0), lo), hi)
+        e0 = _cost(q0 * s0 - w_rot, objective, s0, chan_w)
+        keep = best_err >= e0 * (1.0 - clip_margin)
+        best_scale = torch.where(keep, s0, best_scale)
+        del q0
+
+    q = torch.minimum(torch.maximum(torch.round(w_rot / best_scale), lo), hi)
+
+    if ls_refit:
+        # При фиксированных целых q оптимальный по МНК масштаб - это (q·w)/(q·q),
+        # а не absmax/127. Пересчёт убирает систематический сдвиг реконструкции,
+        # который и появляется, когда сетка перестаёт быть симметричной.
+        num = (q * w_rot).sum(dim=1, keepdim=True)
+        den = (q * q).sum(dim=1, keepdim=True).clamp(min=1.0)
+        best_scale = torch.where(num > 0, num / den, best_scale)
+
+    return q.to(torch.int8), best_scale.to(torch.float32)
+
+
+def quantize_int4(w: torch.Tensor, groupsize: int):
+    """Тот же поворот Адамара, но 4 бита вместо 8.
+
+    Ядро читает такой слой по маркеру format=convrot_w4a4 и жёстко ожидает
+    quant_group_size=64 (см. comfy/ops.py, ветка convrot_w4a4), поэтому размер
+    группы квантования не настраиваем.
+    """
+    from comfy_kitchen.tensor.convrot_w4a4 import TensorCoreConvRotW4A4Layout
+    qdata, params = TensorCoreConvRotW4A4Layout.quantize(
+        w, convrot_groupsize=groupsize, quant_group_size=64, linear_dtype="int4")
+    return qdata, params.scale
+
+
+def int4_error(w: torch.Tensor, groupsize: int) -> float:
+    """Во сколько раз 4 бита дороже 8 на этом слое. Нужно, чтобы выбрать,
+    какие слои не жалко ужать сильнее."""
+    from comfy_kitchen.tensor.convrot_w4a4 import TensorCoreConvRotW4A4Layout
+    q8, s8 = quantize_search(w, groupsize, SEARCH_RATIOS)
+    from comfy_kitchen.tensor.int8 import TensorWiseINT8Layout
+    p8 = TensorWiseINT8Layout.Params(scale=s8, orig_dtype=torch.float32,
+                                     orig_shape=tuple(q8.shape), is_weight=True,
+                                     convrot=True, convrot_groupsize=groupsize)
+    e8 = (TensorWiseINT8Layout.dequantize(q8.to(w.device), p8) - w).norm().item()
+
+    q4, params4 = TensorCoreConvRotW4A4Layout.quantize(
+        w, convrot_groupsize=groupsize, quant_group_size=64, linear_dtype="int4")
+    e4 = (TensorCoreConvRotW4A4Layout.dequantize(q4, params4).float() - w).norm().item()
+    return e4 / max(e8, 1e-12)
+
+
+def load_calib(path: str, alpha: float, device: str):
+    """Статистика активаций из capture_activations.py -> веса каналов."""
+    if not path:
+        return None
+    blob = torch.load(path, map_location="cpu")
+    stats = blob["stats"]
+    out = {}
+    for name, v in stats.items():
+        w = v.to(device=device, dtype=torch.float32).clamp(min=1e-12)
+        w = w / w.mean()                       # нормируем, чтобы масштаб ошибки не поехал
+        out[name] = w.pow(alpha).reshape(1, -1)
+    print(f"калибровка: {path}\n  слоёв {len(out)}, промптов {blob.get('prompts')}, "
+          f"шагов {blob.get('steps')}, показатель {alpha}")
+    return out
+
+
+def calib_for(calib, tensor_name: str):
+    """Ключи калибровки - пути модулей, ключи файла - они же плюс '.weight'."""
+    if not calib:
+        return None
+    layer = tensor_name[: -len(".weight")]
+    if layer in calib:
+        return calib[layer]
+    for prefix in ("model.diffusion_model.", "diffusion_model.", "model."):
+        if layer.startswith(prefix) and layer[len(prefix):] in calib:
+            return calib[layer[len(prefix):]]
+    return None
+
+
+def convert(src: str, dst: str, groupsize: int, device: str, dry_run: bool,
+            search: bool = False, objective: str = "mse", qmin: int = -127,
+            sign_aware: bool = False, ls_refit: bool = False,
+            calib_path: str = "", calib_alpha: float = 1.0,
+            search_min: float = 0.80, clip_margin: float = 0.0,
+            quant_adaln: bool = False, skip_connectors: bool = False,
+            select: str = "names", drop_prefixes: tuple = (),
+            passthrough_dtype: str = "") -> None:
+    t0 = time.time()
+    ratios = build_ratios(search_min)
+    skip = SKIP_TOKENS
+    if skip_connectors:
+        # Вернуть старое поведение: не трогать *_embeddings_connector. Это 96 слоёв
+        # обычного внимания и полносвязных на 4 ГБ, которые эталонные сборки
+        # пропускают. Нужно, чтобы отделить вклад коннекторов от вклада подрезания.
+        skip = tuple(t for t in skip if t != "_emb.") + ("_emb",)
+        print("режим: коннекторы НЕ квантуются (как в эталонных сборках)")
+    if quant_adaln:
+        # AdaLN задаёт масштаб и сдвиг каждому блоку, поэтому его везде защищают.
+        # Но это восьмибитный шаг, а не четырёхбитный - проверяем замером, а не верой.
+        skip = tuple(t for t in SKIP_TOKENS if t not in ("adaln", "modulation"))
+        print("режим: AdaLN тоже квантуется")
+    if groupsize == "auto":
+        print(f"режим: группа подбирается послойно по лесенке {GROUPSIZE_LADDER}")
+    out: dict[str, torch.Tensor] = {}
+    quantized = skipped = 0
+    skip_reasons: dict[str, int] = {}
+    gs_used: dict[int, int] = {}
+    calib = load_calib(calib_path, calib_alpha, device)
+    calib_hits = 0
+
+    # папка = HF-репозиторий, читаем шарды напрямую; файл = как раньше
+    opener = HFShardReader(src) if os.path.isdir(src) else safe_open(src, framework="pt")
+    with opener as f:
+        keys = list(f.keys())
+        # ComfyUI читает конфигурацию модели из метаданных файла (model_detection.py:
+        # dit_config.update(json.loads(metadata["config"])...). Без них он строит
+        # ��одель по умолчанию, и чекпоинт не грузится: "size mismatch for
+        # scale_shift_table: [9, 4096] vs [6, 4096]". Переносим как есть.
+        meta = f.metadata()
+        print(f"вход: {src}\n  тензоров: {len(keys)}"
+              f"{', метаданных: ' + str(len(meta)) if meta else ', метаданных нет'}")
+
+        repeated = None
+        if select in ("structure", "both"):
+            names = [k[: -len(".weight")] for k in keys if k.endswith(".weight")]
+            repeated = repeated_layers(names)
+            print(f"  повторяющихся по блокам слоёв: {len(repeated)} из {len(names)}")
+        if select == "structure":
+            skip = ()  # имена больше не участвуют, отбор чисто структурный
+
+        for i, k in enumerate(keys, 1):
+            if drop_prefixes and k.startswith(drop_prefixes):
+                skip_reasons["выброшен(--drop)"] = skip_reasons.get("выброшен(--drop)", 0) + 1
+                continue
+            t = f.get_tensor(k)
+            ok, why, gs = should_quantize(k, t, groupsize, skip, repeated)
+            if not ok:
+                skipped += 1
+                skip_reasons[why.split()[0]] = skip_reasons.get(why.split()[0], 0) + 1
+                if passthrough_dtype == "bf16" and t.dtype == torch.float32:
+                    t = t.to(torch.bfloat16)
+                out[k] = t
+                continue
+            gs_used[gs] = gs_used.get(gs, 0) + 1
+
+            if dry_run:
+                quantized += 1
+                continue
+
+            # поворот и подбор масштаба считаем в float32: в bf16 сама ротация
+            # вносит заметную ошибку (проверено на эталонных сборках)
+            w = t.to(device=device, dtype=torch.float32)
+            # оба режима идут через один и тот же код: absmax - это просто подбор
+            # по единственному коэффициенту 1.0
+            cw = calib_for(calib, k)
+            calib_hits += cw is not None
+            qdata, scale = quantize_search(
+                w, gs, ratios if search else (1.0,), objective, qmin,
+                sign_aware, ls_refit, cw, clip_margin)
+            layer = k[: -len(".weight")]
+            out[k] = qdata.cpu()
+            out[f"{layer}.weight_scale"] = scale.cpu()
+            conf = {"format": "int8_tensorwise", "convrot": True, "convrot_groupsize": gs}
+            out[f"{layer}.comfy_quant"] = torch.tensor(
+                list(json.dumps(conf).encode("utf-8")), dtype=torch.uint8)
+            quantized += 1
+            del w, qdata, scale
+
+            if i % 50 == 0 or i == len(keys):
+                done = quantized + skipped
+                print(f"  [{done}/{len(keys)}] квантовано {quantized}, пропущено {skipped}",
+                      flush=True)
+
+    print(f"\nитог: квантовано {quantized}, оставлено {skipped}")
+    print("  причины пропуска:", skip_reasons)
+    print("  размеры групп:", dict(sorted(gs_used.items(), reverse=True)))
+    if calib:
+        print(f"  калибровка нашлась для {calib_hits} из {quantized} слоёв")
+        if calib_hits < quantized:
+            print("  ВНИМАНИЕ: часть слоёв квантована без калибровки - проверь имена")
+    if dry_run:
+        print("(dry-run: файл не записан)")
+        return
+
+    os.makedirs(os.path.dirname(os.path.abspath(dst)), exist_ok=True)
+    save_file(out, dst, metadata=meta if meta else None)
+    src_gb = os.path.getsize(src) / 1e9
+    dst_gb = os.path.getsize(dst) / 1e9
+    print(f"\nзаписано: {dst}\n  {src_gb:.2f} GB -> {dst_gb:.2f} GB  за {time.time()-t0:.0f} c")
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("src")
+    ap.add_argument("dst")
+    ap.add_argument("--groupsize", default=256,
+                    type=lambda v: v if v == "auto" else int(v),
+                    help="число или auto — тогда группа подбирается послойно "
+                         f"по лесенке {GROUPSIZE_LADDER}, как в эталонных сборках")
+    ap.add_argument("--device", default="cuda:0")
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--no-search-scale", action="store_true",
+                    help="взять простой absmax вместо подбора масштаба (быстрее, но хуже эталона)")
+    ap.add_argument("--objective", default="mse", choices=("mse", "l1", "huber"),
+                    help="критерий выбора точки подрезания выбросов")
+    ap.add_argument("--asymmetric", action="store_true",
+                    help="р��зрешить -128 всем строкам (ошибка весов меньше, на генерации хуже)")
+    ap.add_argument("--sign-aware", action="store_true",
+                    help="разрешать -128 только строкам с длинным отрицательным хвостом")
+    ap.add_argument("--ls-refit", action="store_true",
+                    help="пересчитать масштаб по МНК после выбора целых значений")
+    ap.add_argument("--calib", default="",
+                    help="файл статистики активаций от capture_activations.py")
+    ap.add_argument("--calib-alpha", type=float, default=1.0,
+                    help="показатель степени для веса канала: 1.0 - диагональ гессиана, "
+                         "0.5 - мягче, 0.0 - как без калибровки")
+    ap.add_argument("--search-min", type=float, default=0.80,
+                    help="нижняя граница перебора коэффициентов подрезания")
+    ap.add_argument("--skip-connectors", action="store_true",
+                    help="не квантовать *_embeddings_connector, как в эталонных сборках")
+    ap.add_argument("--quant-adaln", action="store_true",
+                    help="квантовать и слои модуляции AdaLN (ещё ~0.34 ГБ экономии)")
+    ap.add_argument("--clip-margin", type=float, default=0.0,
+                    help="подрезать строку, только если ошибка падает больше чем на эту долю "
+                         "(0.03 = на 3%%); иначе оставить absmax")
+    ap.add_argument("--select", default="names", choices=("names", "structure", "both"),
+                    help="как отбирать слои: names — по списку подстрок (как раньше); "
+                         "structure — по повторяемости в стопке блоков, без имён; "
+                         "both — оба условия сразу")
+    ap.add_argument("--drop-prefixes", default="",
+                    help="префиксы через запятую: такие тензоры НЕ переносить в выход "
+                         "вовсе (для LTX: vae.,audio_vae.,vocoder.,text_embedding_projection. "
+                         "— компоненты лежат отдельными файлами, дубли не нужны)")
+    ap.add_argument("--passthrough-dtype", default="", choices=("", "bf16"),
+                    help="во что кастовать НЕквантуемые тензоры (для fp32-исходников "
+                         "вроде HiDream-O1: без этого эмбеддинги уедут в выход в fp32)")
+    a = ap.parse_args()
+    convert(a.src, a.dst, a.groupsize, a.device, a.dry_run,
+            not a.no_search_scale, a.objective, -128 if a.asymmetric else -127,
+            a.sign_aware, a.ls_refit, a.calib, a.calib_alpha, a.search_min,
+            a.clip_margin, a.quant_adaln, a.skip_connectors, a.select,
+            tuple(p for p in a.drop_prefixes.split(",") if p),
+            a.passthrough_dtype)

tools/mm_profile_main_quant.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+"""Profile sampled INT8 convrot reconstruction error for all MiniMax-H3 DiT weights.
+
+The profiler keeps every input column (so Hadamard rotation is exact) but samples
+output rows deterministically.  It is intended for choosing a small BF16 island;
+the final converter still quantizes every retained INT8 tensor in full.
+"""
+import argparse
+import json
+import os
+import sys
+import time
+
+import torch
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.environ.get("MINIMAX_H3_ROOT", os.getcwd())
+TOOLS = SCRIPT_DIR
+sys.path.insert(0, TOOLS)
+
+from convert_int8_convrot import build_ratios, quantize_search  # noqa: E402
+from mm_quantize_lean import ShardReader  # noqa: E402
+from comfy_kitchen.backends.eager.quantization import _build_hadamard, _rotate_weight  # noqa: E402
+
+sys.stdout.reconfigure(encoding="utf-8")
+torch.set_grad_enabled(False)
+
+
+SHAPES = {
+    "attn.qkv_proj": (21504, 5376),
+    "attn.out_proj": (5376, 7168),
+    "mlp.fc1": (28672, 5376),
+    "mlp.fc2": (5376, 14336),
+}
+
+
+def source_weight(reader, block, kind):
+    prefix = f"transformer_blocks.{block}"
+    if kind == "attn.qkv_proj":
+        return torch.cat([reader.get_tensor(f"{prefix}.attn.to_{part}.weight") for part in "qkv"], dim=0)
+    if kind == "attn.out_proj":
+        return reader.get_tensor(f"{prefix}.attn.to_out.0.weight")
+    if kind == "mlp.fc1":
+        weight = reader.get_tensor(f"{prefix}.ff.net.0.proj.weight")
+        half = weight.shape[0] // 2
+        return torch.cat((weight[half:], weight[:half]), dim=0)
+    if kind == "mlp.fc2":
+        return reader.get_tensor(f"{prefix}.ff.net.2.weight")
+    raise ValueError(kind)
+
+
+def sampled_rows(weight, count):
+    if weight.shape[0] <= count:
+        return weight
+    index = torch.linspace(0, weight.shape[0] - 1, count, dtype=torch.float64).round().long()
+    return weight.index_select(0, index)
+
+
+def profile(weight, groupsize, rows, ratios, device, clip_margin):
+    sample = sampled_rows(weight, rows).to(device=device, dtype=torch.float32)
+    hadamard = _build_hadamard(groupsize, device=sample.device, dtype=sample.dtype)
+    rotated = _rotate_weight(sample, hadamard, groupsize)
+    absmax = rotated.abs().amax(dim=1, keepdim=True).clamp(min=1e-12)
+    scale0 = absmax / 127.0
+    q0 = torch.round(rotated / scale0).clamp(-127, 127)
+    err0 = ((q0 * scale0 - rotated).norm() / rotated.norm()).item()
+    q, scale = quantize_search(sample, groupsize, ratios, clip_margin=clip_margin)
+    err = ((q.float() * scale - rotated).norm() / rotated.norm()).item()
+    clipped = (scale < scale0 * 0.9999).float().mean().item()
+    del sample, hadamard, rotated, absmax, scale0, q0, q, scale
+    return err0, err, clipped
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("variant", choices=("fl2va", "ref2va"))
+    ap.add_argument("--src", default="", help="raw diffusers transformer directory")
+    ap.add_argument("--device", default="cuda:1")
+    ap.add_argument("--rows", type=int, default=192)
+    ap.add_argument("--blocks", type=int, default=50,
+                    help="число первых блоков; только для короткой проверки профайлера")
+    ap.add_argument("--groupsize", type=int, choices=(16, 64, 256), default=256)
+    ap.add_argument("--search-min", type=float, default=0.80)
+    ap.add_argument("--clip-margin", type=float, default=0.05)
+    ap.add_argument("--out", default="")
+    args = ap.parse_args()
+
+    source = args.src or os.path.join(ROOT, "HF",
+                                     "transformer" if args.variant == "fl2va" else "transformer_ref")
+    out = args.out or os.path.join(ROOT, "comfy_headless", f"mm_quant_profile_{args.variant}.json")
+    ratios = build_ratios(args.search_min)
+    results = []
+    started = time.time()
+    print(f"source={source}\ndevice={args.device} rows={args.rows} g={args.groupsize}\nout={out}", flush=True)
+
+    with ShardReader(source) as reader:
+        for block in range(args.blocks):
+            block_started = time.time()
+            for kind, shape in SHAPES.items():
+                weight = source_weight(reader, block, kind)
+                if tuple(weight.shape) != shape:
+                    raise RuntimeError(f"blocks.{block}.{kind}: {tuple(weight.shape)} != {shape}")
+                err0, err, clipped = profile(weight, args.groupsize, args.rows, ratios,
+                                             args.device, args.clip_margin)
+                count = weight.numel()
+                out_features = weight.shape[0]
+                int8_bytes = count + out_features * 4 + len(json.dumps({
+                    "format": "int8_tensorwise", "convrot": True,
+                    "convrot_groupsize": args.groupsize}).encode("utf-8"))
+                bf16_delta = count * 2 - int8_bytes
+                results.append({
+                    "layer": f"blocks.{block}.{kind}",
+                    "block": block,
+                    "kind": kind,
+                    "shape": list(weight.shape),
+                    "sample_rows": min(args.rows, weight.shape[0]),
+                    "absmax_error": err0,
+                    "searched_error": err,
+                    "improvement": err0 - err,
+                    "clipped_row_fraction": clipped,
+                    "bf16_delta_bytes": bf16_delta,
+                })
+                del weight
+            print(f"block {block:02d}/49: {time.time() - block_started:.1f}s, total {time.time() - started:.0f}s",
+                  flush=True)
+
+    payload = {
+        "variant": args.variant,
+        "source": source,
+        "groupsize": args.groupsize,
+        "rows": args.rows,
+        "search_min": args.search_min,
+        "clip_margin": args.clip_margin,
+        "elapsed_seconds": time.time() - started,
+        "layers": results,
+    }
+    with open(out, "w", encoding="utf-8") as stream:
+        json.dump(payload, stream, ensure_ascii=False, indent=2)
+    print(f"готово: {out}; слоёв={len(results)}, {time.time() - started:.0f}s", flush=True)
+
+
+if __name__ == "__main__":
+    main()

tools/mm_quantize_lean.py

@@ -0,0 +1,562 @@
+# -*- coding: utf-8 -*-
+"""Build MiniMax-H3 INT8 lean-convrot + high-precision adaLN curve.
+
+The input is the original diffusers transformer/transformer_ref directory.
+Q/K/V packing and fc1 ordering are converted while streaming, so the script
+does not need a 61.7 GiB merged BF16 file or a 20-44 GiB tensor dictionary in
+RAM.
+"""
+import argparse
+import json
+import math
+import os
+import re
+import struct
+import sys
+import time
+
+import torch
+import torch.nn.functional as F
+from safetensors import safe_open
+
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.environ.get("MINIMAX_H3_ROOT", os.getcwd())
+HF = os.path.join(ROOT, "HF")
+COMFYORG = os.path.join(ROOT, "comfyorg")
+TOOLS = SCRIPT_DIR
+MODELS = os.path.join(ROOT, "output")
+
+sys.path.insert(0, TOOLS)
+from convert_int8_convrot import build_ratios, quantize_search  # noqa: E402
+
+sys.stdout.reconfigure(encoding="utf-8")
+torch.set_grad_enabled(False)
+
+
+DTYPE_BYTES = {"F64": 8, "F32": 4, "F16": 2, "BF16": 2, "I64": 8,
+               "I32": 4, "I16": 2, "I8": 1, "U8": 1, "BOOL": 1}
+TORCH_TO_ST = {torch.float64: "F64", torch.float32: "F32", torch.float16: "F16",
+               torch.bfloat16: "BF16", torch.int64: "I64", torch.int32: "I32",
+               torch.int16: "I16", torch.int8: "I8", torch.uint8: "U8",
+               torch.bool: "BOOL"}
+def quant_blob(groupsize):
+    return json.dumps({"format": "int8_tensorwise", "convrot": True,
+                       "convrot_groupsize": groupsize}).encode("utf-8")
+
+
+def block_layers(blocks, suffix):
+    return tuple(f"blocks.{block}.{suffix}" for block in blocks)
+
+
+# Deterministic 64-row/full-column FL2VA audit.  Attention output projections
+# are both the most error-prone family and the cheapest useful BF16 upgrade.
+OUT_PROJ_ERR_GE_105 = (2, 1, 0, 3, 5, 7, 15, 38, 49, 6, 9, 45, 4, 19)
+OUT_PROJ_ERR_GE_100 = OUT_PROJ_ERR_GE_105 + (14, 43, 8, 17, 10, 11, 47, 27, 44, 12, 13, 46, 20)
+TOP_FC2 = (49, 45, 39, 29, 44)
+
+QUALITY_PROFILES = {
+    "compact": (),
+    # ~20.39 GiB with dynamic rank16.
+    "quality20": block_layers(OUT_PROJ_ERR_GE_105, "attn.out_proj")
+                 + block_layers(TOP_FC2[:1], "mlp.fc2"),
+    # ~21.00 GiB: recommended first 24 GiB load/generation candidate.
+    "quality21": block_layers(OUT_PROJ_ERR_GE_100, "attn.out_proj")
+                 + block_layers(TOP_FC2[:3], "mlp.fc2"),
+    # ~21.97 GiB: only after quality21 demonstrates enough activation headroom.
+    "quality22": block_layers(range(50), "attn.out_proj")
+                 + block_layers(TOP_FC2, "mlp.fc2"),
+}
+def tensor_bytes(dtype, shape):
+    total = DTYPE_BYTES[dtype]
+    for dim in shape:
+        total *= dim
+    return total
+
+
+class ShardReader:
+    def __init__(self, path):
+        self.path = os.path.abspath(path)
+        indexes = [name for name in os.listdir(self.path) if name.endswith(".safetensors.index.json")]
+        if len(indexes) != 1:
+            raise SystemExit(f"ожидался один *.safetensors.index.json в {self.path}, найдено {len(indexes)}")
+        index = json.load(open(os.path.join(self.path, indexes[0]), encoding="utf-8"))
+        self.weight_map = index["weight_map"]
+        self._files = {}
+        for name in sorted(set(self.weight_map.values())):
+            full = os.path.join(self.path, name)
+            if not os.path.isfile(full):
+                raise SystemExit(f"нет шарда из index: {full}")
+            self._files[name] = safe_open(full, framework="pt")
+
+    def keys(self):
+        return list(self.weight_map)
+
+    def get_slice(self, key):
+        return self._files[self.weight_map[key]].get_slice(key)
+
+    def get_tensor(self, key):
+        return self._files[self.weight_map[key]].get_tensor(key)
+
+    def close(self):
+        self._files.clear()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, traceback):
+        self.close()
+
+
+def validate_source(reader):
+    keys = set(reader.keys())
+    if len(keys) != 638:
+        raise SystemExit(f"неожиданное число исходных тензоров: {len(keys)}, ожидалось 638")
+    shapes = {
+        "transformer_blocks.0.attn.to_q.weight": [7168, 5376],
+        "transformer_blocks.0.attn.to_k.weight": [7168, 5376],
+        "transformer_blocks.0.attn.to_v.weight": [7168, 5376],
+        "transformer_blocks.0.attn.to_out.0.weight": [5376, 7168],
+        "transformer_blocks.0.ff.net.0.proj.weight": [28672, 5376],
+        "transformer_blocks.0.ff.net.2.weight": [5376, 14336],
+        "transformer_blocks.0.adaln_proj.linear.weight": [96768, 2688],
+        "norm_out.linear.weight": [10752, 2688],
+        "time_embedder.linear_1.weight": [5376, 256],
+        "time_embedder.linear_2.weight": [2688, 5376],
+    }
+    for key, expected_shape in shapes.items():
+        if key not in keys:
+            raise SystemExit(f"в источнике нет {key}")
+        actual = reader.get_slice(key).get_shape()
+        if actual != expected_shape:
+            raise SystemExit(f"форма {key}: {actual}, ожидалось {expected_shape}")
+    print("источник diffusers: 638 тензоров, 50 DiT-блоков, формы верны")
+
+
+def task(kind, entries, source=None, prefix=None, **extra):
+    out = {"kind": kind, "entries": entries, "source": source, "prefix": prefix}
+    out.update(extra)
+    return out
+
+
+def build_tasks(reader, rank, grid, time_mode="dynamic", bf16_layers=(), groupsize=256):
+    tasks = []
+    used = set()
+    quant_count = curve_count = 0
+    bf16_layers = set(bf16_layers)
+    seen_main_layers = set()
+
+    def add_copy(out_key, src_key, kind="copy"):
+        sl = reader.get_slice(src_key)
+        tasks.append(task(kind, [(out_key, sl.get_dtype(), sl.get_shape())], source=src_key))
+        used.add(src_key)
+
+    def add_qkv(out_key, src_prefix, quantized, groupsize=256):
+        sources = tuple(src_prefix + f".attn.to_{name}.weight" for name in ("q", "k", "v"))
+        shape = reader.get_slice(sources[0]).get_shape()
+        out_shape = [shape[0] * 3, shape[1]]
+        if quantized:
+            layer = out_key[:-len(".weight")]
+            blob = quant_blob(groupsize)
+            entries = [(out_key, "I8", out_shape),
+                       (layer + ".weight_scale", "F32", [out_shape[0], 1]),
+                       (layer + ".comfy_quant", "U8", [len(blob)])]
+            tasks.append(task("quant_qkv", entries, source=sources, groupsize=groupsize, blob=blob))
+        else:
+            tasks.append(task("copy_qkv", [(out_key, reader.get_slice(sources[0]).get_dtype(), out_shape)], source=sources))
+        used.update(sources)
+
+    def add_quant(out_key, src_key, kind="quant", groupsize=256):
+        nonlocal quant_count
+        shape = reader.get_slice(src_key).get_shape()
+        layer = out_key[:-len(".weight")]
+        blob = quant_blob(groupsize)
+        entries = [(out_key, "I8", shape),
+                   (layer + ".weight_scale", "F32", [shape[0], 1]),
+                   (layer + ".comfy_quant", "U8", [len(blob)])]
+        tasks.append(task(kind, entries, source=src_key, groupsize=groupsize, blob=blob))
+        used.add(src_key)
+        quant_count += 1
+
+    def add_main_qkv(out_key, src_prefix):
+        nonlocal quant_count
+        layer = out_key[:-len(".weight")]
+        seen_main_layers.add(layer)
+        quantized = layer not in bf16_layers
+        add_qkv(out_key, src_prefix, quantized=quantized, groupsize=groupsize)
+        if quantized:
+            quant_count += 1
+
+    def add_main(out_key, src_key, quant_kind="quant", copy_kind="copy"):
+        layer = out_key[:-len(".weight")]
+        seen_main_layers.add(layer)
+        if layer in bf16_layers:
+            add_copy(out_key, src_key, kind=copy_kind)
+        else:
+            add_quant(out_key, src_key, kind=quant_kind, groupsize=groupsize)
+
+    def add_curve(out_prefix, src_prefix):
+        nonlocal curve_count
+        weight_key, bias_key = src_prefix + ".weight", src_prefix + ".bias"
+        out_features = reader.get_slice(weight_key).get_shape()[0]
+        tasks.append(task("curve", [(out_prefix + ".weight", "F32", [out_features, rank]),
+                                     (out_prefix + ".bias", "F32", [out_features])],
+                          source=src_prefix, prefix=out_prefix))
+        used.update((weight_key, bias_key))
+        curve_count += 1
+
+    for block in range(50):
+        src = f"transformer_blocks.{block}"
+        out = f"blocks.{block}"
+        add_main_qkv(out + ".attn.qkv_proj.weight", src)
+        add_main(out + ".attn.out_proj.weight", src + ".attn.to_out.0.weight")
+        add_copy(out + ".attn.q_norm.weight", src + ".attn.norm_q.weight")
+        add_copy(out + ".attn.k_norm.weight", src + ".attn.norm_k.weight")
+        add_main(out + ".mlp.fc1.weight", src + ".ff.net.0.proj.weight",
+                 quant_kind="quant_fc1", copy_kind="copy_fc1")
+        add_main(out + ".mlp.fc2.weight", src + ".ff.net.2.weight")
+        add_copy(out + ".norm1.weight", src + ".norm1.weight")
+        add_copy(out + ".norm2.weight", src + ".norm2.weight")
+        add_curve(out + ".adaln_proj.linear", src + ".adaln_proj.linear")
+
+    for block in range(2):
+        src = f"token_refiner.refiner_blocks.{block}"
+        out = f"token_refiner.blocks.{block}"
+        add_qkv(out + ".attn.qkv_proj.weight", src, quantized=False)
+        add_copy(out + ".attn.out_proj.weight", src + ".attn.to_out.0.weight")
+        add_copy(out + ".attn.q_norm.weight", src + ".attn.norm_q.weight")
+        add_copy(out + ".attn.k_norm.weight", src + ".attn.norm_k.weight")
+        add_copy(out + ".mlp.fc1.weight", src + ".ff.net.0.proj.weight", kind="copy_fc1")
+        add_copy(out + ".mlp.fc2.weight", src + ".ff.net.2.weight")
+        add_copy(out + ".norm1.weight", src + ".norm1.weight")
+        add_copy(out + ".norm2.weight", src + ".norm2.weight")
+
+    add_copy("token_refiner.final_norm.weight", "token_refiner.final_norm.weight")
+    for out_key, src_key in (
+        ("condition_proj.weight", "context_embedder.weight"),
+        ("condition_proj.bias", "context_embedder.bias"),
+        ("video_patch_proj.weight", "proj_in.weight"),
+        ("video_patch_proj.bias", "proj_in.bias"),
+        ("audio_patch_proj.weight", "audio_proj_in.weight"),
+        ("audio_patch_proj.bias", "audio_proj_in.bias"),
+        ("final_layer.video_out.weight", "proj_out.weight"),
+        ("final_layer.video_out.bias", "proj_out.bias"),
+        ("final_layer.audio_out.weight", "audio_proj_out.weight"),
+        ("final_layer.audio_out.bias", "audio_proj_out.bias"),
+        ("final_layer.norm.weight", "norm_out.norm.weight"),
+    ):
+        add_copy(out_key, src_key)
+    add_curve("final_layer.adaln_proj.linear", "norm_out.linear")
+
+    time_pairs = (
+        ("time_embedder.proj_in.weight", "time_embedder.linear_1.weight"),
+        ("time_embedder.proj_in.bias", "time_embedder.linear_1.bias"),
+        ("time_embedder.proj_out.weight", "time_embedder.linear_2.weight"),
+        ("time_embedder.proj_out.bias", "time_embedder.linear_2.bias"),
+    )
+    if time_mode == "dynamic":
+        for out_key, src_key in time_pairs:
+            add_copy(out_key, src_key)
+        tasks.append(task("basis", [("adaln_curve_basis", "F32", [2688, rank]),
+                                    ("adaln_curve_mean", "F32", [2688])]))
+    elif time_mode == "table":
+        used.update(src for _, src in time_pairs)
+        tasks.append(task("table", [("adaln_t_table", "F32", [grid, rank])]))
+    else:
+        raise ValueError(time_mode)
+    missing, extra = set(reader.keys()) - used, used - set(reader.keys())
+    if missing or extra:
+        raise SystemExit(f"маппинг diffusers неполон: не использовано {len(missing)}, неизвестных {len(extra)}; {sorted(missing)[:3]}")
+    tasks.append(task("rope", [("rope.inv_freq", "F32", [16])]))
+    unknown_bf16 = bf16_layers - seen_main_layers
+    if unknown_bf16:
+        raise SystemExit(f"неизвестные BF16-слои: {sorted(unknown_bf16)}")
+    expected_quant = 200 - len(bf16_layers)
+    if quant_count != expected_quant or curve_count != 51:
+        raise SystemExit(f"план неполон: INT8={quant_count}/{expected_quant}, adaLN={curve_count}/51")
+    entries = [entry for item in tasks for entry in item["entries"]]
+    expected_entries = (937 if time_mode == "dynamic" else 932) - 2 * len(bf16_layers)
+    if len(entries) != expected_entries or len({entry[0] for entry in entries}) != len(entries):
+        raise SystemExit(f"неверный выходной keyset: {len(entries)} вместо {expected_entries}")
+    return tasks
+
+
+def inspect_reference(tasks, path, time_mode="dynamic", bf16_layers=()):
+    planned = {key: (dtype, shape) for item in tasks for key, dtype, shape in item["entries"]}
+    bf16_layers = set(bf16_layers)
+    with safe_open(path, framework="pt") as ref:
+        ref_keys = set(ref.keys())
+        expected_missing = set()
+        for layer in bf16_layers:
+            expected_missing.update((layer + ".weight_scale", layer + ".comfy_quant"))
+        expected_extra = set()
+        if time_mode == "dynamic":
+            expected_missing.add("adaln_t_table")
+            expected_extra.update({"adaln_curve_basis", "adaln_curve_mean",
+                                   "time_embedder.proj_in.weight", "time_embedder.proj_in.bias",
+                                   "time_embedder.proj_out.weight", "time_embedder.proj_out.bias"})
+        actual_missing = ref_keys - set(planned)
+        actual_extra = set(planned) - ref_keys
+        if actual_missing != expected_missing or actual_extra != expected_extra:
+            raise SystemExit("keyset расходится с ожидаемым расширением pruned-формата: "
+                             f"missing={sorted(actual_missing ^ expected_missing)[:5]} "
+                             f"extra={sorted(actual_extra ^ expected_extra)[:5]}")
+        mismatches = []
+        for key, (dtype, shape) in planned.items():
+            if key not in ref_keys or "adaln_proj.linear" in key or key == "adaln_t_table":
+                continue
+            sl = ref.get_slice(key)
+            layer = key[:-len(".weight")] if key.endswith(".weight") else ""
+            dtype_mismatch = sl.get_dtype() != dtype and layer not in bf16_layers
+            if dtype_mismatch or sl.get_shape() != shape:
+                mismatches.append((key, dtype, shape, sl.get_dtype(), sl.get_shape()))
+        if mismatches:
+            raise SystemExit(f"формат расходится с pruned-эталоном вне curve-части: {mismatches[:3]}")
+    print(f"эталон comfyorg-pruned: общие формы совпадают; dynamic={time_mode == 'dynamic'}, "
+          f"BF16 main={len(bf16_layers)}")
+
+
+def make_curve(reader, rank, grid, device):
+    w1 = reader.get_tensor("time_embedder.linear_1.weight").to(device=device, dtype=torch.float32)
+    b1 = reader.get_tensor("time_embedder.linear_1.bias").to(device=device, dtype=torch.float32)
+    w2 = reader.get_tensor("time_embedder.linear_2.weight").to(device=device, dtype=torch.float32)
+    b2 = reader.get_tensor("time_embedder.linear_2.bias").to(device=device, dtype=torch.float32)
+    half = 128
+    freqs = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=torch.float32, device=device) / half)
+
+    def evaluate(t):
+        args = t[:, None] * freqs[None]
+        emb = torch.cat((torch.cos(args), torch.sin(args)), dim=1)
+        return F.silu(F.linear(F.silu(F.linear(emb, w1, b1)), w2, b2))
+
+    # 2049 points are sufficient to determine the shared subspace.  The output
+    # table may be denser: Comfy derives the grid length from table.shape[0].
+    fit_t = torch.linspace(0.0, 1.0, 2049, dtype=torch.float32, device=device)
+    curve = evaluate(fit_t)
+    # Evaluate the real runtime formula in F32, then solve the tiny singular
+    # directions in F64 on CPU.  F32 SVD bottoms out at ~1.09e-6 relative error
+    # for rank 16; the F64 solve followed by F32 storage reaches ~2.72e-7.
+    curve_cpu = curve.cpu()
+    curve64 = curve_cpu.double()
+    mean64 = curve64.mean(0)
+    centered64 = curve64 - mean64
+    _, singular, vh = torch.linalg.svd(centered64, full_matrices=False)
+    basis64 = vh[:rank].T.contiguous()
+    basis = basis64.to(device=device, dtype=torch.float32)
+    mean = mean64.to(device=device, dtype=torch.float32)
+    table_t = torch.linspace(0.0, 1.0, grid, dtype=torch.float32, device=device)
+    table_curve = evaluate(table_t)
+    table = ((table_curve.cpu().double() - mean64) @ basis64).to(torch.float32)
+    energy = (singular[:rank].square().sum() / singular.square().sum()).item()
+    reconstruction = table @ basis.cpu().T + mean.cpu()
+    grid_error = ((reconstruction - table_curve.cpu()).norm() / table_curve.cpu().norm()).item()
+    # Real runtime values usually lie between table rows.  Midpoints provide a
+    # sensitive deterministic check of the linear interpolation error.
+    mid_t = (torch.arange(grid - 1, dtype=torch.float32, device=device) + 0.5) / (grid - 1)
+    mid_curve = evaluate(mid_t).cpu()
+    mid_coords = (table[:-1] + table[1:]) * 0.5
+    mid_reconstruction = mid_coords @ basis.cpu().T + mean.cpu()
+    midpoint_error = ((mid_reconstruction - mid_curve).norm() / mid_curve.norm()).item()
+    midpoint_max = ((mid_reconstruction - mid_curve).norm(dim=1) /
+                    mid_curve.norm(dim=1).clamp(min=1e-12)).max().item()
+    projection = torch.cat((basis, mean[:, None]), dim=1)
+    del w1, b1, w2, b2, curve, curve_cpu, curve64, centered64, vh, basis64
+    del table_curve, reconstruction, mid_curve, mid_reconstruction, mid_coords
+    print(f"adaLN curve: rank={rank}, grid={grid}, энергия={energy:.10f}, "
+          f"grid err={grid_error:.8%}, midpoint err={midpoint_error:.8%}, "
+          f"max={midpoint_max:.8%}")
+    return projection, table
+
+
+def make_header(tasks):
+    header = {}
+    offset = 0
+    for item in tasks:
+        for key, dtype, shape in item["entries"]:
+            size = tensor_bytes(dtype, shape)
+            header[key] = {"dtype": dtype, "shape": shape, "data_offsets": [offset, offset + size]}
+            offset += size
+    raw = json.dumps(header, separators=(",", ":")).encode("utf-8")
+    raw += b" " * ((-len(raw)) % 8)
+    return raw, offset
+
+
+def raw_bytes(tensor):
+    tensor = tensor.detach().to(device="cpu").contiguous()
+    if tensor.dtype not in TORCH_TO_ST:
+        raise TypeError(f"неподдерживаемый dtype {tensor.dtype}")
+    return tensor.view(torch.uint8).numpy().tobytes()
+
+
+def write_tensor(stream, tensor, expected):
+    key, dtype, shape = expected
+    actual_dtype = TORCH_TO_ST.get(tensor.dtype)
+    if actual_dtype != dtype or list(tensor.shape) != shape:
+        raise RuntimeError(f"{key}: получили {actual_dtype} {list(tensor.shape)}, ожидалось {dtype} {shape}")
+    blob = raw_bytes(tensor)
+    expected_bytes = tensor_bytes(dtype, shape)
+    if len(blob) != expected_bytes:
+        raise RuntimeError(f"{key}: байт {len(blob)}, ожидалось {expected_bytes}")
+    stream.write(blob)
+
+
+def build(reader, tasks, reference, dst, rank, grid, device, search_min, clip_margin, overwrite):
+    partial = dst + ".partial"
+    if (os.path.exists(dst) or os.path.exists(partial)) and not overwrite:
+        raise SystemExit(f"выход или partial уже существует; используйте --overwrite: {dst}")
+    os.makedirs(os.path.dirname(os.path.abspath(dst)), exist_ok=True)
+    header, data_size = make_header(tasks)
+    projection, table = make_curve(reader, rank, grid, device)
+    ratios = build_ratios(search_min)
+    t0 = time.time()
+    quant_done = curve_done = 0
+    expected_quant = sum(item["kind"] in ("quant", "quant_fc1", "quant_qkv") for item in tasks)
+
+    def report_block(key):
+        match = re.fullmatch(r"blocks\.(\d+)\.mlp\.fc2\.weight", key)
+        if match:
+            print(f"  DiT block {int(match.group(1)):02d}/49: INT8 {quant_done}/{expected_quant}, "
+                  f"{time.time() - t0:.0f} c", flush=True)
+
+    with safe_open(reference, framework="pt") as ref, open(partial, "wb") as stream:
+        stream.write(struct.pack("<Q", len(header)))
+        stream.write(header)
+        for item in tasks:
+            if item["kind"] == "copy":
+                tensor = reader.get_tensor(item["source"])
+                write_tensor(stream, tensor, item["entries"][0])
+                del tensor
+                report_block(item["entries"][0][0])
+            elif item["kind"] in ("copy_qkv", "quant_qkv"):
+                weight = torch.cat([reader.get_tensor(key) for key in item["source"]], dim=0)
+                if item["kind"] == "copy_qkv":
+                    write_tensor(stream, weight, item["entries"][0])
+                    del weight
+                    continue
+                weight = weight.to(device=device, dtype=torch.float32)
+                qdata, scale = quantize_search(weight, item["groupsize"], ratios, clip_margin=clip_margin)
+                write_tensor(stream, qdata.cpu(), item["entries"][0])
+                write_tensor(stream, scale.cpu(), item["entries"][1])
+                blob = torch.tensor(list(item["blob"]), dtype=torch.uint8)
+                write_tensor(stream, blob, item["entries"][2])
+                quant_done += 1
+                del weight, qdata, scale, blob
+            elif item["kind"] in ("copy_fc1", "quant_fc1"):
+                weight = reader.get_tensor(item["source"])
+                half = weight.shape[0] // 2
+                weight = torch.cat((weight[half:], weight[:half]), dim=0)
+                if item["kind"] == "copy_fc1":
+                    write_tensor(stream, weight, item["entries"][0])
+                    del weight
+                    continue
+                weight = weight.to(device=device, dtype=torch.float32)
+                qdata, scale = quantize_search(weight, item["groupsize"], ratios, clip_margin=clip_margin)
+                write_tensor(stream, qdata.cpu(), item["entries"][0])
+                write_tensor(stream, scale.cpu(), item["entries"][1])
+                blob = torch.tensor(list(item["blob"]), dtype=torch.uint8)
+                write_tensor(stream, blob, item["entries"][2])
+                quant_done += 1
+                del weight, qdata, scale, blob
+            elif item["kind"] == "quant":
+                weight = reader.get_tensor(item["source"]).to(device=device, dtype=torch.float32)
+                qdata, scale = quantize_search(weight, item["groupsize"], ratios, clip_margin=clip_margin)
+                write_tensor(stream, qdata.cpu(), item["entries"][0])
+                write_tensor(stream, scale.cpu(), item["entries"][1])
+                blob = torch.tensor(list(item["blob"]), dtype=torch.uint8)
+                write_tensor(stream, blob, item["entries"][2])
+                quant_done += 1
+                del weight, qdata, scale, blob
+                report_block(item["entries"][0][0])
+            elif item["kind"] == "curve":
+                source = item["source"]
+                weight = reader.get_tensor(source + ".weight").to(device=device, dtype=torch.float32)
+                bias = reader.get_tensor(source + ".bias").to(device=device, dtype=torch.float32)
+                packed = weight @ projection
+                curve_weight = packed[:, :rank]
+                curve_bias = bias + packed[:, rank]
+                write_tensor(stream, curve_weight.cpu(), item["entries"][0])
+                write_tensor(stream, curve_bias.cpu(), item["entries"][1])
+                curve_done += 1
+                del weight, bias, packed, curve_weight, curve_bias
+            elif item["kind"] == "table":
+                write_tensor(stream, table.cpu(), item["entries"][0])
+            elif item["kind"] == "basis":
+                write_tensor(stream, projection[:, :rank].cpu(), item["entries"][0])
+                write_tensor(stream, projection[:, rank].cpu(), item["entries"][1])
+            elif item["kind"] == "rope":
+                write_tensor(stream, ref.get_tensor("rope.inv_freq"), item["entries"][0])
+            else:
+                raise RuntimeError(item["kind"])
+    expected_size = 8 + len(header) + data_size
+    actual_size = os.path.getsize(partial)
+    if actual_size != expected_size:
+        raise RuntimeError(f"partial имеет {actual_size} байт, ожидалось {expected_size}")
+    with safe_open(partial, framework="pt") as result:
+        expected_keys = sum(len(item["entries"]) for item in tasks)
+        if len(result.keys()) != expected_keys:
+            raise RuntimeError(f"safetensors открылся, но ключей {len(result.keys())}, ожидалось {expected_keys}")
+    os.replace(partial, dst)
+    print(f"готово: {dst}\n  {actual_size / 2**30:.3f} GiB, INT8={quant_done}, curve={curve_done}, {time.time() - t0:.0f} c")
+
+
+def defaults(variant, rank, grid, time_mode, profile):
+    source = os.path.join(HF, "transformer" if variant == "fl2va" else "transformer_ref")
+    reference = os.path.join(COMFYORG, f"minimax-h3-{variant}-pruned-int8-convrot-comfyorg.safetensors")
+    curve_tag = f"table-k{rank}-g{grid}" if time_mode == "table" else f"dynamic-k{rank}"
+    dst = os.path.join(MODELS, f"minimax-h3-{variant}-int8-lean-convrot-{curve_tag}-{profile}.safetensors")
+    return source, reference, dst
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("variant", choices=("fl2va", "ref2va"))
+    ap.add_argument("--rank", type=int, default=16, choices=(8, 16, 32, 64))
+    ap.add_argument("--time-mode", choices=("dynamic", "table"), default="dynamic",
+                    help="dynamic сохраняет исходный F32 time_embedder; table совместим с pruned")
+    ap.add_argument("--grid", type=int, default=4097,
+                    help="число строк table или плотность численной проверки dynamic basis")
+    ap.add_argument("--profile", choices=tuple(QUALITY_PROFILES), default="quality21")
+    ap.add_argument("--bf16-layer", action="append", default=[],
+                    help="дополнительный base-name основного слоя, например blocks.48.mlp.fc2")
+    ap.add_argument("--groupsize", type=int, choices=(16, 64, 256), default=256)
+    ap.add_argument("--src", default="")
+    ap.add_argument("--reference", default="")
+    ap.add_argument("--dst", default="")
+    ap.add_argument("--device", default="cuda:0")
+    ap.add_argument("--search-min", type=float, default=0.80)
+    ap.add_argument("--clip-margin", type=float, default=0.05)
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--overwrite", action="store_true")
+    args = ap.parse_args()
+    if args.grid < 2:
+        ap.error("--grid должен быть не меньше 2")
+
+    bf16_layers = set(QUALITY_PROFILES[args.profile]) | set(args.bf16_layer)
+    source, reference, dst = defaults(args.variant, args.rank, args.grid, args.time_mode, args.profile)
+    source = args.src or source
+    reference = args.reference or reference
+    dst = args.dst or dst
+    print(f"variant={args.variant} rank={args.rank} time={args.time_mode} profile={args.profile}\n"
+          f"BF16 main={sorted(bf16_layers)}\nsrc={source}\nreference={reference}\ndst={dst}")
+    reader = ShardReader(source)
+    try:
+        validate_source(reader)
+        tasks = build_tasks(reader, args.rank, args.grid, args.time_mode, bf16_layers, args.groupsize)
+        inspect_reference(tasks, reference, args.time_mode, bf16_layers)
+        _, data_size = make_header(tasks)
+        entries = sum(len(item["entries"]) for item in tasks)
+        quant_count = sum(item["kind"] in ("quant", "quant_fc1", "quant_qkv") for item in tasks)
+        print(f"план: {entries} тензоров, {quant_count} INT8 g{args.groupsize}, "
+              f"BF16 main={len(bf16_layers)}, 51 adaLN curve F32 k={args.rank} time={args.time_mode}; "
+              f"данные {data_size / 2**30:.3f} GiB")
+        if args.dry_run:
+            print("dry-run: веса не читались целиком, GPU не использовалась, файл не создан")
+            return
+        build(reader, tasks, reference, dst, args.rank, args.grid, args.device, args.search_min,
+              args.clip_margin, args.overwrite)
+    finally:
+        reader.close()
+
+
+if __name__ == "__main__":
+    main()

tools/mm_validate_dynamic_built.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+"""Validate a built MiniMax-H3 dynamic-basis checkpoint against raw HF weights."""
+import argparse
+import json
+import math
+import os
+import sys
+
+import torch
+import torch.nn.functional as F
+from safetensors import safe_open
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.environ.get("MINIMAX_H3_ROOT", os.getcwd())
+sys.path.insert(0, SCRIPT_DIR)
+from mm_quantize_lean import QUALITY_PROFILES, ShardReader  # noqa: E402
+
+sys.stdout.reconfigure(encoding="utf-8")
+torch.set_grad_enabled(False)
+
+
+def rel(actual, expected):
+    return ((actual - expected).norm() / expected.norm().clamp(min=1e-12)).item()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("variant", choices=("fl2va", "ref2va"))
+    ap.add_argument("checkpoint")
+    ap.add_argument("--src", default="", help="raw diffusers transformer directory")
+    ap.add_argument("--profile", choices=tuple(QUALITY_PROFILES), default="quality21")
+    ap.add_argument("--samples", type=int, default=9)
+    args = ap.parse_args()
+
+    source = args.src or os.path.join(ROOT, "HF",
+                                     "transformer" if args.variant == "fl2va" else "transformer_ref")
+    expected_bf16 = set(QUALITY_PROFILES[args.profile])
+    results = {}
+
+    with ShardReader(source) as raw, safe_open(args.checkpoint, framework="pt") as built:
+        keys = set(built.keys())
+        quant = [key for key in keys if key.endswith(".comfy_quant")]
+        groups = {}
+        for key in quant:
+            config = json.loads(bytes(built.get_tensor(key).numpy()).decode())
+            groups[config["convrot_groupsize"]] = groups.get(config["convrot_groupsize"], 0) + 1
+
+        actual_bf16 = set()
+        for block in range(50):
+            for suffix in ("attn.qkv_proj", "attn.out_proj", "mlp.fc1", "mlp.fc2"):
+                base = f"blocks.{block}.{suffix}"
+                if built.get_slice(base + ".weight").get_dtype() == "BF16":
+                    actual_bf16.add(base)
+        if actual_bf16 != expected_bf16:
+            raise RuntimeError(f"BF16 profile mismatch: -{sorted(expected_bf16 - actual_bf16)} "
+                               f"+{sorted(actual_bf16 - expected_bf16)}")
+
+        time_pairs = (
+            ("time_embedder.linear_1.weight", "time_embedder.proj_in.weight"),
+            ("time_embedder.linear_1.bias", "time_embedder.proj_in.bias"),
+            ("time_embedder.linear_2.weight", "time_embedder.proj_out.weight"),
+            ("time_embedder.linear_2.bias", "time_embedder.proj_out.bias"),
+        )
+        time_bitwise = all(torch.equal(raw.get_tensor(src), built.get_tensor(dst))
+                           for src, dst in time_pairs)
+        if not time_bitwise:
+            raise RuntimeError("time_embedder differs from raw HF")
+
+        # All quality21 BF16 islands are out_proj or fc2 and should be exact copies.
+        bf16_bad = []
+        for base in sorted(actual_bf16):
+            parts = base.split(".")
+            block = int(parts[1])
+            suffix = ".".join(parts[2:])
+            if suffix == "attn.out_proj":
+                src = f"transformer_blocks.{block}.attn.to_out.0.weight"
+            elif suffix == "mlp.fc2":
+                src = f"transformer_blocks.{block}.ff.net.2.weight"
+            else:
+                raise RuntimeError(f"validator needs mapping for {base}")
+            if not torch.equal(raw.get_tensor(src), built.get_tensor(base + ".weight")):
+                bf16_bad.append(base)
+        if bf16_bad:
+            raise RuntimeError(f"BF16 tensors differ: {bf16_bad}")
+
+        w1 = built.get_tensor("time_embedder.proj_in.weight").float()
+        b1 = built.get_tensor("time_embedder.proj_in.bias").float()
+        w2 = built.get_tensor("time_embedder.proj_out.weight").float()
+        b2 = built.get_tensor("time_embedder.proj_out.bias").float()
+        basis = built.get_tensor("adaln_curve_basis").float()
+        mean = built.get_tensor("adaln_curve_mean").float()
+        orth_error = (basis.T @ basis - torch.eye(basis.shape[1])).abs().max().item()
+
+        t = torch.linspace(0.0, 1.0, args.samples, dtype=torch.float32)
+        half = 128
+        freqs = torch.exp(-math.log(10000.0) * torch.arange(half, dtype=torch.float32) / half)
+        phase = t[:, None] * freqs[None]
+        sinusoid = torch.cat((torch.cos(phase), torch.sin(phase)), dim=1)
+        u = F.silu(F.linear(F.silu(F.linear(sinusoid, w1, b1)), w2, b2))
+        coords = (u - mean) @ basis
+
+        curve_errors = {}
+        for block in (0, 24, 49):
+            src = f"transformer_blocks.{block}.adaln_proj.linear"
+            dst = f"blocks.{block}.adaln_proj.linear"
+            exact = F.linear(u, raw.get_tensor(src + ".weight").float(),
+                             raw.get_tensor(src + ".bias").float())
+            approx = F.linear(coords, built.get_tensor(dst + ".weight").float(),
+                              built.get_tensor(dst + ".bias").float())
+            curve_errors[f"block_{block}"] = rel(approx, exact)
+            del exact, approx
+        exact = F.linear(u, raw.get_tensor("norm_out.linear.weight").float(),
+                         raw.get_tensor("norm_out.linear.bias").float())
+        approx = F.linear(coords, built.get_tensor("final_layer.adaln_proj.linear.weight").float(),
+                          built.get_tensor("final_layer.adaln_proj.linear.bias").float())
+        curve_errors["final"] = rel(approx, exact)
+
+        results = {
+            "checkpoint": args.checkpoint,
+            "bytes": os.path.getsize(args.checkpoint),
+            "keys": len(keys),
+            "quant": len(quant),
+            "quant_groups": groups,
+            "bf16_main": len(actual_bf16),
+            "time_embedder_bitwise": time_bitwise,
+            "bf16_main_bitwise": len(actual_bf16) - len(bf16_bad),
+            "basis_shape": list(basis.shape),
+            "basis_orthogonality_max_abs": orth_error,
+            "curve_samples": args.samples,
+            "adaln_relative_errors": curve_errors,
+        }
+
+    print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()