orbitquant 0.2.1__tar.gz → 0.2.2__tar.gz

{orbitquant-0.2.1 → orbitquant-0.2.2}/.github/workflows/publish-pypi.yml

@@ -6,7 +6,7 @@ on:
       version:
         description: Version to publish
         required: true
-        default: "0.2.1"
+        default: "0.2.2"
 
 jobs:
   build:

{orbitquant-0.2.1 → orbitquant-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbitquant
-Version: 0.2.1
+Version: 0.2.2
 Summary: Calibration-free OrbitQuant for transformer linear projections
 Project-URL: Homepage, https://github.com/iamwavecut/OrbitQuant
 Project-URL: Repository, https://github.com/iamwavecut/OrbitQuant

{orbitquant-0.2.1 → orbitquant-0.2.2}/docs/kernel-audit.md

@@ -107,6 +107,27 @@ The native CUDA package was also built and tested on an NVIDIA RTX 4090
 All 34 applicable package tests passed for W2/W3/W4/W6, FP16/BF16, bias and
 no-bias paths, partial output tiles, short rows, and tensor-core rows.
 
+The same local package build passed its 34 CUDA tests on an NVIDIA A40
+(`sm_86`) with Torch 2.9.1+cu128 and CUDA 12.8. A full FLUX.2 Klein 9B W4A4
+pipeline exercised 396 packed linears across the transformer and Qwen3 text
+encoder. Native 1024x1024 generation at four steps used
+`native_packed_matmul` for every packed linear and the Triton activation path;
+no full weight matrix was materialized.
+
+Representative A40 W4A4 layer timings from that pipeline are:
+
+| Projection | Rows | Shape | RPBH + activation quantization | Native packed matmul | Full layer |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| Double-stream Q | 4096 | 4096 -> 4096 | 0.698 ms | 2.607 ms | 3.279 ms |
+| Single-stream fused input | 4608 | 4096 -> 36864 | 0.770 ms | 25.962 ms | 26.677 ms |
+| Single-stream output | 4608 | 16384 -> 4096 | 4.257 ms | 11.244 ms | 15.514 ms |
+
+The corresponding full-pipeline hot-generation mean was 7.418 seconds with a
+17.66 GB NVML peak. On the same A40 and prompt pack, BF16 measured 3.911
+seconds and 40.83 GB, while SDNQ UINT4 measured 3.546 seconds and 17.55 GB.
+These results establish the memory reduction and the remaining throughput gap;
+they do not support a model-level speedup claim for OrbitQuant on A40.
+
 Measured W4 BF16 operator latency for `in_features=768` and
 `out_features=2304`:
 

{orbitquant-0.2.1 → orbitquant-0.2.2}/native-kernels/orbitquant-packed-matmul/orbitquant_packed_matmul_cuda/packed_matmul.cu

@@ -58,7 +58,7 @@ __device__ __forceinline__ __nv_bfloat16 orbitquant_mma_from_float<__nv_bfloat16
   return __float2bfloat16(value);
 }
 
-template <int Bits, typename mma_t>
+template <int Bits, int Values, typename mma_t>
 __device__ __forceinline__ void decode_mma64_weight_segment(
     mma_t *__restrict__ destination,
     uint8_t const *__restrict__ packed_weight_indices,
@@ -68,9 +68,9 @@ __device__ __forceinline__ void decode_mma64_weight_segment(
     int64_t global_k,
     int64_t in_features,
     bool valid_segment) {
-  constexpr int values = 32;
   constexpr uint32_t mask = (1u << Bits) - 1u;
-  uint32_t packed_words[Bits] = {};
+  constexpr int word_count = (Values * Bits + 31) / 32;
+  uint32_t packed_words[word_count] = {};
   float norm = 0.0f;
   if (valid_segment) {
     const int64_t value_offset = global_col * in_features + global_k;
@@ -78,14 +78,14 @@ __device__ __forceinline__ void decode_mma64_weight_segment(
     auto const *words = reinterpret_cast<uint32_t const *>(
         packed_weight_indices + byte_index);
 #pragma unroll
-    for (int word = 0; word < Bits; ++word) {
+    for (int word = 0; word < word_count; ++word) {
       packed_words[word] = words[word];
     }
     norm = static_cast<float>(row_norms[global_col]);
   }
 
 #pragma unroll
-  for (int index_offset = 0; index_offset < values; ++index_offset) {
+  for (int index_offset = 0; index_offset < Values; ++index_offset) {
     const int bit_start = index_offset * Bits;
     const int word_index = bit_start >> 5;
     const int shift = bit_start & 31;
@@ -111,23 +111,22 @@ __global__ void orbitquant_packed_matmul_mma64_kernel(
     int64_t rows,
     int64_t out_features,
     int64_t in_features) {
-  constexpr int tile_m = 64;
-  constexpr int tile_n = 64;
+  constexpr int tile_m = 128;
+  constexpr int tile_n = 128;
   constexpr int tile_k = 64;
   constexpr int padded_k = 72;
-  constexpr int warps_per_block = 4;
+  constexpr int warps_per_block = 8;
   constexpr int warp_tile = 16;
   constexpr int col_tiles = tile_n / warp_tile;
   constexpr int x_vector_values = 8;
   constexpr int x_vectors_per_row = tile_k / x_vector_values;
-  constexpr int weight_segment_values = 32;
+  constexpr int weight_segment_values = Bits == 3 ? 32 : 16;
   constexpr int weight_segments_per_row = tile_k / weight_segment_values;
   static_assert(sizeof(storage_t) == sizeof(mma_t));
 
   __shared__ mma_t x_tile[tile_m * padded_k];
   __shared__ mma_t weight_tile[tile_n * padded_k];
-  __shared__ float accumulator_tile[
-      warps_per_block * col_tiles * warp_tile * warp_tile];
+  __shared__ float accumulator_tile[warps_per_block * warp_tile * warp_tile];
 
   const int warp_id = threadIdx.x / warpSize;
   const int lane = threadIdx.x & (warpSize - 1);
@@ -160,14 +159,14 @@ __global__ void orbitquant_packed_matmul_mma64_kernel(
     }
 
     constexpr int weight_tasks = tile_n * weight_segments_per_row;
-    const int weight_task = threadIdx.x;
-    if (weight_task < weight_tasks) {
+    for (int weight_task = threadIdx.x; weight_task < weight_tasks;
+         weight_task += blockDim.x) {
       const int local_col = weight_task / weight_segments_per_row;
       const int local_segment =
           weight_task - local_col * weight_segments_per_row;
       const int local_k = local_segment * weight_segment_values;
       const int64_t global_col = block_col + local_col;
-      decode_mma64_weight_segment<Bits>(
+      decode_mma64_weight_segment<Bits, weight_segment_values>(
           weight_tile + local_col * padded_k + local_k,
           packed_weight_indices,
           row_norms,
@@ -204,10 +203,9 @@ __global__ void orbitquant_packed_matmul_mma64_kernel(
     __syncthreads();
   }
 
+  float *warp_accumulator = accumulator_tile + warp_id * warp_tile * warp_tile;
 #pragma unroll
   for (int col_tile = 0; col_tile < col_tiles; ++col_tile) {
-    float *warp_accumulator = accumulator_tile +
-        (warp_id * col_tiles + col_tile) * warp_tile * warp_tile;
     wmma::store_matrix_sync(
         warp_accumulator,
         accumulators[col_tile],
@@ -228,6 +226,7 @@ __global__ void orbitquant_packed_matmul_mma64_kernel(
             static_cast<storage_t>(value);
       }
     }
+    __syncwarp();
   }
 }
 
@@ -648,9 +647,9 @@ void matmul_packed_weight(
   if (x.scalar_type() == at::kBFloat16 && x.size(0) >= 9) {
     if (in_features % 64 == 0 &&
         (bits == 2 || bits == 3 || bits == 4 || bits == 6)) {
-      constexpr int mma_tile_m = 64;
-      constexpr int mma_tile_n = 64;
-      const dim3 mma_block(128);
+      constexpr int mma_tile_m = 128;
+      constexpr int mma_tile_n = 128;
+      const dim3 mma_block(256);
       const dim3 mma_grid(
           (out_features + mma_tile_n - 1) / mma_tile_n,
           (x.size(0) + mma_tile_m - 1) / mma_tile_m);
@@ -740,9 +739,9 @@ void matmul_packed_weight(
   if (x.scalar_type() == at::kHalf && x.size(0) >= 9) {
     if (in_features % 64 == 0 &&
         (bits == 2 || bits == 3 || bits == 4 || bits == 6)) {
-      constexpr int mma_tile_m = 64;
-      constexpr int mma_tile_n = 64;
-      const dim3 mma_block(128);
+      constexpr int mma_tile_m = 128;
+      constexpr int mma_tile_n = 128;
+      const dim3 mma_block(256);
       const dim3 mma_grid(
           (out_features + mma_tile_n - 1) / mma_tile_n,
           (x.size(0) + mma_tile_m - 1) / mma_tile_m);

{orbitquant-0.2.1 → orbitquant-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "orbitquant"
-version = "0.2.1"
+version = "0.2.2"
 description = "Calibration-free OrbitQuant for transformer linear projections"
 readme = "README.md"
 requires-python = ">=3.11"

{orbitquant-0.2.1 → orbitquant-0.2.2}/src/orbitquant/__init__.py

@@ -18,7 +18,7 @@ from orbitquant.pipeline import (
 from orbitquant.quantizer import register_hf_quantizers
 from orbitquant.recipes import recipe
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 register_hf_quantizers()
 

{orbitquant-0.2.1 → orbitquant-0.2.2}/src/orbitquant/artifacts/model_card.py

@@ -408,6 +408,22 @@ def _comparison_prompt_section(
     return lines
 
 
+def _observed_quality_section(
+    benchmark_summary: dict[str, Any] | None,
+) -> list[str]:
+    if not isinstance(benchmark_summary, dict):
+        return []
+    observed_quality = benchmark_summary.get("observed_quality")
+    if not isinstance(observed_quality, str) or not observed_quality.strip():
+        return []
+    return [
+        "## Observed Quality",
+        "",
+        f"**Warning:** {observed_quality.strip()}",
+        "",
+    ]
+
+
 def render_model_card(
     manifest: OrbitQuantManifest,
     *,
@@ -424,6 +440,7 @@ def render_model_card(
     comparison_prompt_lines = _comparison_prompt_section(
         data["source_model_id"], benchmark_summary
     )
+    observed_quality_lines = _observed_quality_section(benchmark_summary)
     adaln_group_size = int(data.get("adaln_group_size", 64))
     adaln_default_note = (
         "- AdaLN group-size note: paper default."
@@ -531,6 +548,7 @@ def render_model_card(
             "- Calibration data: none",
             "- Text encoders and VAE: left in source precision by default",
             "",
+            *observed_quality_lines,
             *comparison_lines,
             "## Source",
             "",

{orbitquant-0.2.1 → orbitquant-0.2.2}/src/orbitquant/kernels/triton_cuda.py

@@ -236,6 +236,50 @@ def _fused_rpbh_quantize_activation_kernel(
     tl.store(output_ptr + row * dim + cols, quantized * norm, mask=mask)
 
 
+@triton.jit
+def _fused_rpbh_fwht_1024_chunk_kernel(
+    input_ptr,
+    norms_ptr,
+    permutation_ptr,
+    signs_ptr,
+    work_ptr,
+    rows: tl.constexpr,
+    dim: tl.constexpr,
+    num_blocks: tl.constexpr,
+    orbit_block_size: tl.constexpr,
+    chunks_per_orbit_block: tl.constexpr,
+    eps: tl.constexpr,
+):
+    program = tl.program_id(0)
+    chunk = program % chunks_per_orbit_block
+    row_block = program // chunks_per_orbit_block
+    row = row_block // num_blocks
+    orbit_block = row_block % num_blocks
+    local_cols = tl.arange(0, 1024)
+    cols = orbit_block * orbit_block_size + chunk * 1024 + local_cols
+    mask = (row < rows) & (cols < dim)
+    source_cols = tl.load(permutation_ptr + cols, mask=mask, other=0).to(tl.int64)
+    signs = tl.load(signs_ptr + cols, mask=mask, other=1).to(tl.float32)
+    norm = tl.load(norms_ptr + row, mask=row < rows, other=0.0).to(tl.float32)
+    values = tl.load(
+        input_ptr + row * dim + source_cols,
+        mask=mask,
+        other=0.0,
+    ).to(tl.float32)
+    values = values * signs / (norm + eps)
+    values = _fwht_local_stage(values, 1024, 1)
+    values = _fwht_local_stage(values, 1024, 2)
+    values = _fwht_local_stage(values, 1024, 4)
+    values = _fwht_local_stage(values, 1024, 8)
+    values = _fwht_local_stage(values, 1024, 16)
+    values = _fwht_local_stage(values, 1024, 32)
+    values = _fwht_local_stage(values, 1024, 64)
+    values = _fwht_local_stage(values, 1024, 128)
+    values = _fwht_local_stage(values, 1024, 256)
+    values = _fwht_local_stage(values, 1024, 512)
+    tl.store(work_ptr + row * dim + cols, values, mask=mask)
+
+
 @triton.jit
 def _codebook_rescale_kernel(
     rotated_ptr,
@@ -868,24 +912,86 @@ def quantize_activations_with_triton(
 
     orbit_block_size = int(rotation.block_size)
     num_blocks = int(rotation.num_blocks)
-    fwht_stages = orbit_block_size.bit_length() - 1
-    _fused_rpbh_quantize_activation_kernel[(rows * num_blocks,)](
+    if orbit_block_size <= 1024:
+        fwht_stages = orbit_block_size.bit_length() - 1
+        _fused_rpbh_quantize_activation_kernel[(rows * num_blocks,)](
+            input_contiguous,
+            norms,
+            permutation,
+            signs,
+            centroids,
+            boundaries,
+            output,
+            rows=rows,
+            dim=dim,
+            num_blocks=num_blocks,
+            orbit_block_size=orbit_block_size,
+            fwht_stages=fwht_stages,
+            levels=centroids.numel(),
+            eps=float(eps),
+            inv_sqrt_block=float(rotation.normalization),
+            num_warps=8 if orbit_block_size >= 512 else 4,
+        )
+        return output.reshape(original_shape)
+
+    element_block_size = 256
+    work = torch.empty(total, device=x.device, dtype=torch.float32)
+    chunks_per_orbit_block = orbit_block_size // 1024
+    _fused_rpbh_fwht_1024_chunk_kernel[
+        (rows * num_blocks * chunks_per_orbit_block,)
+    ](
         input_contiguous,
         norms,
         permutation,
         signs,
-        centroids,
-        boundaries,
-        output,
+        work,
         rows=rows,
         dim=dim,
         num_blocks=num_blocks,
         orbit_block_size=orbit_block_size,
-        fwht_stages=fwht_stages,
-        levels=centroids.numel(),
+        chunks_per_orbit_block=chunks_per_orbit_block,
         eps=float(eps),
+        num_warps=8,
+    )
+
+    stage_width = 1024
+    while stage_width * 2 < orbit_block_size:
+        total_quads = rows * num_blocks * (orbit_block_size // 4)
+        _fwht_two_stage_kernel[(triton.cdiv(total_quads, element_block_size),)](
+            work,
+            total_quads=total_quads,
+            in_features=dim,
+            num_blocks=num_blocks,
+            orbit_block_size=orbit_block_size,
+            stage_width=stage_width,
+            block_size=element_block_size,
+        )
+        stage_width *= 4
+    if stage_width < orbit_block_size:
+        total_pairs = rows * num_blocks * (orbit_block_size // 2)
+        _fwht_stage_kernel[(triton.cdiv(total_pairs, element_block_size),)](
+            work,
+            total_pairs=total_pairs,
+            in_features=dim,
+            num_blocks=num_blocks,
+            orbit_block_size=orbit_block_size,
+            stage_width=stage_width,
+            block_size=element_block_size,
+        )
+
+    _quantize_activation_work_rescale_kernel[
+        (triton.cdiv(total, element_block_size),)
+    ](
+        work,
+        norms,
+        centroids,
+        boundaries,
+        output,
+        total=total,
+        dim=dim,
+        levels=centroids.numel(),
         inv_sqrt_block=float(rotation.normalization),
-        num_warps=8 if orbit_block_size >= 512 else 4,
+        block_size=element_block_size,
     )
     return output.reshape(original_shape)
 

{orbitquant-0.2.1 → orbitquant-0.2.2}/src/orbitquant/layers.py

@@ -223,6 +223,7 @@ class OrbitQuantLinear(nn.Module):
         self.last_effective_runtime_mode: str | None = None
         self.last_activation_kernel_backend: str | None = None
         self.last_forward_device_type: str | None = None
+        self._derived_constants_valid = True
 
     @classmethod
     def from_linear(
@@ -341,6 +342,38 @@ class OrbitQuantLinear(nn.Module):
         self._dequantized_weight_cache = None
         self._dequantized_weight_cache_key = None
 
+    def _apply(self, fn, recurse: bool = True):
+        result = super()._apply(fn, recurse=recurse)
+        self._derived_constants_valid = False
+        self.clear_dequantized_cache()
+        return result
+
+    def _ensure_derived_constants(self, device: torch.device) -> None:
+        if self._derived_constants_valid and self._rotation_permutation.device == device:
+            return
+        constants = (
+            ("_rotation_permutation", self.rotation.permutation, torch.int64),
+            ("_rotation_signs", self.rotation.signs, torch.int8),
+            (
+                "_activation_codebook_centroids",
+                self.activation_codebook.centroids,
+                torch.float32,
+            ),
+            (
+                "_activation_codebook_boundaries",
+                self.activation_codebook.boundaries,
+                torch.float32,
+            ),
+            (
+                "_weight_codebook_centroids",
+                self.weight_codebook.centroids,
+                torch.float32,
+            ),
+        )
+        for name, source, dtype in constants:
+            setattr(self, name, source.to(device=device, dtype=dtype).clone())
+        self._derived_constants_valid = True
+
     def _constant_buffer(
         self,
         name: str,
@@ -518,6 +551,7 @@ class OrbitQuantLinear(nn.Module):
         return dequantized
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
+        self._ensure_derived_constants(x.device)
         runtime_mode = (
             self._resolve_auto_fused_runtime(x)
             if self.runtime_mode == "auto_fused"

{orbitquant-0.2.1 → orbitquant-0.2.2}/src/orbitquant/modeling.py

@@ -353,7 +353,9 @@ def quantize_model(
     model.quantization_config = resolved_config
     model.orbitquant_summary = summary
     model_config = getattr(model, "config", None)
-    if model_config is not None:
+    if hasattr(model, "register_to_config"):
+        model.register_to_config(quantization_config=resolved_config.to_dict())
+    elif model_config is not None:
         model_config.quantization_config = resolved_config.to_dict()
     return summary
 

{orbitquant-0.2.1 → orbitquant-0.2.2}/src/orbitquant/pipeline.py

@@ -12,7 +12,7 @@ from orbitquant.artifacts import (
     save_orbitquant_artifact,
 )
 from orbitquant.config import OrbitQuantConfig
-from orbitquant.modeling import QuantizationSummary, quantize_linear_modules
+from orbitquant.modeling import QuantizationSummary, quantize_model
 from orbitquant.quantizer import register_hf_quantizers
 
 
@@ -124,7 +124,7 @@ def quantize_pipeline(
     synchronize_per_module: bool = False,
 ) -> QuantizationSummary:
     target = _get_pipeline_component(pipeline, component)
-    return quantize_linear_modules(
+    return quantize_model(
         target,
         config,
         quantization_device=quantization_device,

{orbitquant-0.2.1 → orbitquant-0.2.2}/tests/test_diffusers_modelmixin_integration.py

@@ -5,6 +5,7 @@ import torch
 
 from orbitquant.config import OrbitQuantConfig
 from orbitquant.layers import OrbitQuantLinear
+from orbitquant.modeling import quantize_model
 from orbitquant.quantizer import register_hf_quantizers
 
 diffusers = pytest.importorskip("diffusers")
@@ -101,3 +102,20 @@ def test_diffusers_modelmixin_save_pretrained_round_trips_pre_quantized_model(
     assert isinstance(restored.proj_out, torch.nn.Linear)
     x = torch.randn(2, 3, 16)
     assert torch.isfinite(restored(x)).all()
+
+
+def test_diffusers_manual_quantize_model_persists_quantization_config(tmp_path):
+    model = TinyDiffusersTransformer()
+    config = OrbitQuantConfig(
+        block_size=8,
+        runtime_mode="dequant_bf16",
+        activation_kernel_backend="cpu",
+    )
+
+    quantize_model(model, config, quantization_device="cpu")
+    model.save_pretrained(tmp_path)
+    saved_config = json.loads((tmp_path / "config.json").read_text())
+    restored = TinyDiffusersTransformer.from_pretrained(tmp_path)
+
+    assert saved_config["quantization_config"] == config.to_dict()
+    assert isinstance(restored.transformer_blocks[0]["attn"]["to_q"], OrbitQuantLinear)

{orbitquant-0.2.1 → orbitquant-0.2.2}/tests/test_kernels.py

@@ -813,6 +813,42 @@ def test_triton_cuda_activation_kernel_matches_paper_sized_rpbh_block():
     assert torch.allclose(actual, expected, atol=1e-5, rtol=1e-5)
 
 
+def test_triton_cuda_activation_kernel_matches_large_rpbh_block():
+    if not torch.cuda.is_available() or not available_backends()["triton_cuda"]:
+        pytest.skip("CUDA/Triton backend is not available")
+
+    torch.manual_seed(3)
+    x = torch.randn(3, 4096, device="cuda", dtype=torch.bfloat16)
+    rotation = RPBHRotation(dim=4096, seed=0, block_size="paper")
+    codebook = get_codebook(dim=4096, bits=4)
+    expected = quantize_activations(x, rotation=rotation, codebook=codebook, eps=1e-12)
+    actual = quantize_activations_kernel(
+        x, rotation=rotation, codebook=codebook, eps=1e-12, backend="triton_cuda"
+    )
+
+    assert rotation.block_size == 4096
+    assert actual.dtype == torch.bfloat16
+    assert torch.allclose(actual.float(), expected.float(), atol=1e-2, rtol=1e-2)
+
+
+def test_triton_cuda_activation_kernel_matches_very_large_rpbh_block():
+    if not torch.cuda.is_available() or not available_backends()["triton_cuda"]:
+        pytest.skip("CUDA/Triton backend is not available")
+
+    torch.manual_seed(4)
+    x = torch.randn(2, 16384, device="cuda", dtype=torch.bfloat16)
+    rotation = RPBHRotation(dim=16384, seed=0, block_size="paper")
+    codebook = get_codebook(dim=16384, bits=4)
+    expected = quantize_activations(x, rotation=rotation, codebook=codebook, eps=1e-12)
+    actual = quantize_activations_kernel(
+        x, rotation=rotation, codebook=codebook, eps=1e-12, backend="triton_cuda"
+    )
+
+    assert rotation.block_size == 16384
+    assert actual.dtype == torch.bfloat16
+    assert torch.allclose(actual.float(), expected.float(), atol=1e-2, rtol=1e-2)
+
+
 def test_cuda_quantize_linear_modules_keeps_packed_buffers_on_gpu_until_serialization():
     if not torch.cuda.is_available() or not available_backends()["triton_cuda"]:
         pytest.skip("CUDA/Triton backend is not available")

{orbitquant-0.2.1 → orbitquant-0.2.2}/tests/test_model_card.py

@@ -120,6 +120,31 @@ def test_model_card_renders_native_validation_evidence_without_raw_records():
     assert "original.metrics.jsonl" not in card
 
 
+def test_model_card_renders_observed_quality_warning_from_benchmark_summary():
+    manifest = _manifest_for_model("Tongyi-MAI/Z-Image-Turbo", bits=(2, 3))
+    observed_quality = (
+        "The OrbitQuant W2A3 outputs show severe visual collapse across all ten "
+        "native comparison prompts. Use W3A3 or W4A4 for this model."
+    )
+
+    card = render_model_card(
+        manifest,
+        benchmark_summary={"observed_quality": observed_quality},
+    )
+
+    assert "## Observed Quality" in card
+    assert f"**Warning:** {observed_quality}" in card
+
+
+def test_model_card_omits_observed_quality_without_a_nonempty_string():
+    manifest = _manifest_for_model("Tongyi-MAI/Z-Image-Turbo", bits=(2, 3))
+
+    for benchmark_summary in (None, {}, {"observed_quality": "  "}):
+        card = render_model_card(manifest, benchmark_summary=benchmark_summary)
+
+        assert "## Observed Quality" not in card
+
+
 def test_model_card_renders_imported_geneval_release_metrics():
     manifest = _manifest_for_model("black-forest-labs/FLUX.1-schnell")
     benchmark_summary = {

{orbitquant-0.2.1 → orbitquant-0.2.2}/tests/test_orbit_linear.py

@@ -827,6 +827,47 @@ def test_orbit_linear_explicit_dequant_bf16_still_uses_reference_path(monkeypatc
     assert calls == {"dequant": 1, "linear": 1}
 
 
+def test_orbit_linear_rebuilds_derived_constants_after_to_empty():
+    torch.manual_seed(19)
+    source = torch.nn.Linear(16, 7, bias=True, dtype=torch.float32)
+    x = torch.randn(2, 5, 16)
+    config = OrbitQuantConfig(
+        weight_bits=4,
+        activation_bits=4,
+        rotation_seed=11,
+        block_size=8,
+        runtime_mode="dequant_bf16",
+        activation_kernel_backend="cpu",
+    )
+    reference = OrbitQuantLinear.from_linear(
+        source, config=config, module_name="block.ff.linear"
+    )
+    state = {name: tensor.clone() for name, tensor in reference.state_dict().items()}
+    restored = copy.deepcopy(reference)
+    restored.to_empty(device="cpu")
+    restored.load_state_dict(state)
+
+    assert not restored._derived_constants_valid
+    actual = restored(x)
+
+    assert restored._derived_constants_valid
+    assert torch.equal(restored._rotation_permutation, restored.rotation.permutation)
+    assert torch.equal(restored._rotation_signs, restored.rotation.signs)
+    assert torch.equal(
+        restored._activation_codebook_centroids,
+        restored.activation_codebook.centroids,
+    )
+    assert torch.equal(
+        restored._activation_codebook_boundaries,
+        restored.activation_codebook.boundaries,
+    )
+    assert torch.equal(
+        restored._weight_codebook_centroids,
+        restored.weight_codebook.centroids,
+    )
+    assert torch.allclose(actual, reference(x))
+
+
 def test_orbit_linear_native_packed_matmul_mps_matches_dequant_bf16(monkeypatch):
     if not torch.backends.mps.is_available():
         pytest.skip("MPS backend is not available")

{orbitquant-0.2.1 → orbitquant-0.2.2}/uv.lock

@@ -1095,7 +1095,7 @@ wheels = [
 
 [[package]]
 name = "orbitquant"
-version = "0.2.1"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "huggingface-hub" },