orbitquant 0.2.0__tar.gz → 0.2.2__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbitquant
-Version: 0.2.0
+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
@@ -232,8 +232,9 @@ save_quantized_pipeline_component(
 ```
 
 Published FLUX, Z-Image, and Wan repositories are compact Diffusers component
-artifacts. Their model cards contain the matching pipeline code and native
-generation settings.
+artifacts. Image model cards contain the matching pipeline code, native
+generation settings, and a ten-prompt full-resolution BF16-vs-OrbitQuant
+comparison matrix.
 
 Load a published component artifact together with its recorded source pipeline:
 

{orbitquant-0.2.0 → orbitquant-0.2.2}/README.md

@@ -188,8 +188,9 @@ save_quantized_pipeline_component(
 ```
 
 Published FLUX, Z-Image, and Wan repositories are compact Diffusers component
-artifacts. Their model cards contain the matching pipeline code and native
-generation settings.
+artifacts. Image model cards contain the matching pipeline code, native
+generation settings, and a ten-prompt full-resolution BF16-vs-OrbitQuant
+comparison matrix.
 
 Load a published component artifact together with its recorded source pipeline:
 

{orbitquant-0.2.0 → 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.0 → orbitquant-0.2.2}/docs/paper-methodology-audit.md

@@ -143,7 +143,9 @@ Native artifact readiness is separate from full GenEval or VBench scoring.
 Those runs prove metric-table claims. The required artifact-readiness evidence
 is:
 
-- Native-resolution BF16-vs-OrbitQuant comparison matrix.
+- Ten-prompt native-resolution BF16-vs-OrbitQuant comparison matrix for image
+  artifacts, including dense composition, fine detail, artistic style, and
+  Latin, Russian, Japanese, and Chinese typography stress cases.
 - Same prompt and seed for BF16 and OrbitQuant.
 - Native settings from `src/orbitquant/eval/native_settings.py`.
 - Finite, nonblank output checks.

{orbitquant-0.2.0 → 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.0 → orbitquant-0.2.2}/pyproject.toml

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

{orbitquant-0.2.0 → 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.0"
+__version__ = "0.2.2"
 
 register_hf_quantizers()
 

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

@@ -4,6 +4,7 @@ from typing import Any
 
 from orbitquant.artifacts.manifest import OrbitQuantManifest
 from orbitquant.eval.native_settings import NativeSuite, list_native_suites
+from orbitquant.eval.prompts import default_prompt_payload
 
 _GENEVAL_METRICS = (
     "geneval_overall",
@@ -65,7 +66,7 @@ def _install_snippet() -> str:
     return "\n".join(
         [
             "```bash",
-            "pip install \"orbitquant[hf]\"",
+            "pip install \"orbitquant[hf,kernels]>=0.2.0\"",
             "```",
         ]
     )
@@ -343,6 +344,86 @@ def _native_validation_proof_section(
     return lines
 
 
+def _comparison_prompt_section(
+    source_model_id: str,
+    benchmark_summary: dict[str, Any] | None,
+) -> list[str]:
+    suite = _native_suite_for_source_model(source_model_id)
+    if suite is None or suite.frames is not None or not isinstance(benchmark_summary, dict):
+        return []
+    proof = benchmark_summary.get("native_smoke")
+    if not isinstance(proof, dict):
+        return []
+    prompt_payload = default_prompt_payload(
+        {
+            "flux2-native": "flux2",
+            "flux1-schnell-native": "flux",
+            "z-image-native": "z_image",
+        }[suite.name]
+    )
+    prompts = prompt_payload["prompts"]
+    if proof.get("paired_prompt_seed_count") != len(prompts):
+        return []
+    paired_keys = proof.get("paired_prompt_seed_keys")
+    if not isinstance(paired_keys, list):
+        return []
+    paired_prompt_ids = {
+        str(item[2])
+        for item in paired_keys
+        if isinstance(item, list) and len(item) == 3
+    }
+    if paired_prompt_ids != {str(prompt["id"]) for prompt in prompts}:
+        return []
+
+    required_text = {
+        "english-text-rendering": "ORBIT QUANT; DATA WITHOUT CALIBRATION",
+        "cyrillic-text-rendering": "КВАНТОВАЯ ОРБИТА; МОСКВА 2049; КВАНТОВАНИЕ",
+        "style-heavy": "量子の軌道; 東京の未来",
+        "occlusion-reflection": "量子轨道; 未来之城",
+    }
+    lines = [
+        "## Comparison Prompt Set",
+        "",
+        f"The matrix uses all ten prompts from `{prompt_payload['prompt_pack']}` at "
+        f"`{suite.width}x{suite.height}`. BF16 and OrbitQuant use the same seed for "
+        "each row.",
+        "",
+        "| # | Stress case | Exact required text |",
+        "| ---: | --- | --- |",
+    ]
+    for index, prompt in enumerate(prompts, start=1):
+        text = required_text.get(str(prompt["id"]), "-")
+        lines.append(f"| {index} | {prompt['title']} | {text} |")
+    lines.extend(
+        [
+            "",
+            "<details>",
+            "<summary>Exact comparison prompts</summary>",
+            "",
+        ]
+    )
+    for index, prompt in enumerate(prompts, start=1):
+        lines.append(f"{index}. **{prompt['title']}**: {prompt['prompt']}")
+    lines.extend(["", "</details>", ""])
+    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,
     *,
@@ -356,6 +437,10 @@ def render_model_card(
         data["source_model_id"], benchmark_summary
     )
     native_validation_proof_lines = _native_validation_proof_section(benchmark_summary)
+    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."
@@ -425,14 +510,19 @@ def render_model_card(
             _usage_snippet(data["source_model_id"], bits),
             "",
             "`runtime_mode=\"auto_fused\"` is the default optimized runtime. On "
-            "CUDA it tries the native packed low-bit matmul kernel first, then "
-            "Triton packed matmul. On MPS it requires the native Metal packed "
-            "matmul kernel. Use `runtime_mode=\"dequant_bf16\"` only as an "
-            "explicit compatibility/debug reference path.",
+            "CUDA, the `kernels` extra provides the Triton packed fallback; a "
+            "locally built native CUDA package is preferred automatically when "
+            "installed. On MPS, build and install the native Metal package from "
+            "the OrbitQuant source tree. See the [OrbitQuant runtime instructions]"
+            "(https://github.com/iamwavecut/OrbitQuant/blob/main/docs/"
+            "kernel-audit.md#local-native-package). Use "
+            "`runtime_mode=\"dequant_bf16\"` only as an explicit compatibility/"
+            "debug reference path.",
             "",
             *native_settings_lines,
             *validation_status_lines,
             *native_validation_proof_lines,
+            *comparison_prompt_lines,
             "## Quantization",
             "",
             f"- Method: `{data['quant_method']}`",
@@ -458,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.0 → orbitquant-0.2.2}/src/orbitquant/eval/prompts.py

@@ -8,62 +8,126 @@ from typing import Any
 IMAGE_VISUAL_PROMPTS = [
     {
         "id": "simple-object",
-        "category": "simple_object",
-        "prompt": "A red ceramic mug on a wooden desk, soft daylight, shallow depth of field",
+        "title": "01 Fine-detail astrolabe",
+        "category": "fine_detail",
+        "prompt": (
+            "A museum-grade macro photograph of a single ornate brass astronomical clock, "
+            "covered with interlocking gears, engraved constellations, enamel moon phases, "
+            "hair-thin hands, tiny screws, worn gilt edges, and dust caught in the mechanisms; "
+            "dramatic Rembrandt lighting, black velvet background, extreme material detail, "
+            "large-format photography, every cog mechanically coherent"
+        ),
     },
     {
         "id": "two-object-composition",
-        "category": "two_object_composition",
-        "prompt": "Two robots playing chess in a quiet library, one silver and one matte black",
+        "title": "02 Layered character composition",
+        "category": "layered_character_composition",
+        "prompt": (
+            "A lacquered white android and an elderly watchmaker facing each other across a "
+            "crowded Art Nouveau workshop, jointly repairing a mechanical hummingbird; the "
+            "android is on the left, the watchmaker on the right, the bird centered between "
+            "them, hundreds of tools and clock parts in the midground, rain and a tram visible "
+            "through the window, coherent mirror reflections, cinematic tungsten and cyan light, "
+            "intricate faces and hands, editorial realism"
+        ),
     },
     {
         "id": "counting",
-        "category": "counting",
-        "prompt": "Five glass marbles arranged in a straight line on white paper",
+        "title": "03 Exact counting and choreography",
+        "category": "counting_and_choreography",
+        "prompt": (
+            "Exactly seven masked dancers performing on seven separate illuminated platforms "
+            "inside a vast flooded opera house, no extra dancers; alternating crimson and ivory "
+            "costumes from left to right, each dancer in a distinct pose, balconies reflected in "
+            "the water, floating candles, volumetric stage haze, baroque theatrical photography, "
+            "sharp foreground and readable background architecture"
+        ),
     },
     {
         "id": "color-binding",
-        "category": "color_binding",
-        "prompt": "A blue cube beside a yellow sphere and a green pyramid on a gray table",
+        "title": "04 Dense color and object binding",
+        "category": "dense_color_binding",
+        "prompt": (
+            "An elaborate surreal fashion tableau with three models: the left model wears a "
+            "cobalt-blue coat and holds a yellow glass sphere, the center model wears a saffron "
+            "dress and holds a green ceramic pyramid, the right model wears an emerald suit and "
+            "holds a red velvet cube; rococo greenhouse, rare orchids, patterned tile floor, "
+            "prismatic sunlight, magazine-cover precision, preserve every color-object pairing"
+        ),
     },
     {
         "id": "spatial-relationship",
-        "category": "spatial_relationship",
-        "prompt": "A blue cube to the left of a yellow sphere, both centered in the frame",
+        "title": "05 Nested spatial relationships",
+        "category": "nested_spatial_relationships",
+        "prompt": (
+            "A meticulous cutaway diorama of a vertical city: a glass greenhouse sits directly "
+            "above a silver subway car, a red fox stands inside the greenhouse beneath a hanging "
+            "moon lamp, a violinist waits below the subway platform, and a yellow airship passes "
+            "behind the entire structure; isometric perspective, architectural-section drawing "
+            "mixed with photoreal materials, dozens of tiny rooms, stairs and people, clean depth"
+        ),
     },
     {
         "id": "long-prompt",
-        "category": "long_prompt",
+        "title": "06 Cinematic night-market panorama",
+        "category": "cinematic_panorama",
         "prompt": (
-            "A precise editorial photo of a compact robotics workbench with labeled tools, "
-            "a small oscilloscope, coiled cables, a half-assembled drone, and a warm desk lamp; "
-            "the scene should remain readable without clutter"
+            "A sweeping cinematic panorama of a rain-soaked floating night market at blue hour: "
+            "in the foreground a chef plates translucent dumplings under a red silk canopy; in "
+            "the midground children chase paper lanterns across narrow bridges while merchants "
+            "unload exotic fruit from wooden boats; in the background a terraced megacity rises "
+            "through mist beneath a storm, with hundreds of warm windows, wet reflections, steam, "
+            "umbrellas, ropes and signage; deep focus, anamorphic highlights, realistic faces, "
+            "coherent perspective, painterly color grading with documentary-level detail"
         ),
     },
     {
         "id": "english-text-rendering",
-        "category": "text_rendering",
-        "prompt": 'A clean street sign with the exact text "ORBIT QUANT"',
+        "title": "07 Editorial Latin typography",
+        "category": "latin_typography",
+        "prompt": (
+            "A sophisticated Swiss International Style exhibition poster photographed behind "
+            "slightly reflective museum glass, with the exact large headline \"ORBIT QUANT\" and "
+            "the exact smaller subtitle \"DATA WITHOUT CALIBRATION\"; strict modular grid, red, "
+            "black and white screenprint, tiny registration marks, embossed paper fibers, sharp "
+            "letterforms, dramatic gallery shadows, no other text"
+        ),
     },
     {
         "id": "cyrillic-text-rendering",
-        "category": "text_rendering",
-        "prompt": 'A handwritten note in Cyrillic that says "КВАНТОВАНИЕ"',
+        "title": "08 Russian Constructivist typography",
+        "category": "russian_typography",
+        "prompt": (
+            "A richly detailed Russian Constructivist science-fiction poster with the exact "
+            "Cyrillic headline \"КВАНТОВАЯ ОРБИТА\", the exact subtitle \"МОСКВА 2049\", and a "
+            "small exact stamp \"КВАНТОВАНИЕ\"; diagonal red and black geometry, cream paper, "
+            "cosmonaut portrait, orbital diagrams, halftone grain, folded corners, layered ink, "
+            "museum archival photograph, all letters crisp and correctly ordered"
+        ),
     },
     {
         "id": "style-heavy",
-        "category": "style",
+        "title": "09 Japanese typography and mixed style",
+        "category": "japanese_typography",
         "prompt": (
-            "A crowded train platform at sunset, documentary photo style, high dynamic range, "
-            "natural grain, realistic faces, detailed architecture"
+            "An elaborate Japanese art magazine cover combining Edo woodblock printing with a "
+            "futuristic Tokyo skyline, with the exact vertical title \"量子の軌道\" and the exact "
+            "subtitle \"東京の未来\"; giant indigo waves curl around glass towers, red-crowned "
+            "cranes cross a gold moon, tiny pedestrians and trains fill the lower streets, visible "
+            "washi fibers, layered spot colors, precise Japanese glyphs, balanced editorial layout"
         ),
     },
     {
         "id": "occlusion-reflection",
-        "category": "occlusion_reflection",
+        "title": "10 Chinese typography, reflection, occlusion",
+        "category": "chinese_typography_reflection_occlusion",
         "prompt": (
-            "A reflective chrome teapot partly hidden behind orange flowers, with the room "
-            "visible as a coherent reflection on the metal"
+            "A luxurious Chinese retro-futurist department-store window at night with the exact "
+            "gold title \"量子轨道\" and the exact red subtitle \"未来之城\"; a curved chrome "
+            "robot "
+            "is partly occluded by peonies and blue-and-white porcelain, the calligraphy and neon "
+            "street must appear coherently reflected across its body, multiple glass layers, silk "
+            "textures, passing bicycles, cinematic rain, fine product-photography detail"
         ),
     },
 ]
@@ -152,7 +216,7 @@ def default_prompt_payload(target_policy: str) -> dict[str, Any]:
             "prompts": deepcopy(VIDEO_VISUAL_PROMPTS),
         }
     return {
-        "prompt_pack": "image_visual_v1",
+        "prompt_pack": "image_visual_v2",
         "media_type": "image",
         "target_policy": target_policy,
         "prompts": deepcopy(IMAGE_VISUAL_PROMPTS),

{orbitquant-0.2.0 → orbitquant-0.2.2}/src/orbitquant/eval/report.py

@@ -308,6 +308,8 @@ def _write_comparison_matrix(
     items: list[dict[str, Any]],
     *,
     title: str,
+    tile_size: tuple[int, int] = (208, 214),
+    lossless: bool = False,
 ) -> Path | None:
     if not items:
         return None
@@ -320,12 +322,11 @@ def _write_comparison_matrix(
         return None
 
     by_cell = {(item["row_key"], item["col_key"]): item for item in items}
-    row_label_width = 210
-    col_width = 220
+    row_label_width = 260 if tile_size[0] >= 512 else 210
+    col_width = tile_size[0] + 12
     title_height = 34
     header_height = 66
-    row_height = 230
-    tile_size = (col_width - 12, row_height - 16)
+    row_height = tile_size[1] + 16
     width = row_label_width + col_width * len(col_keys)
     height = title_height + header_height + row_height * len(row_keys)
     sheet = Image.new("RGB", (width, height), "white")
@@ -364,7 +365,7 @@ def _write_comparison_matrix(
             x = row_label_width + col_index * col_width + 6
             tile = _thumbnail(item["path"], size=tile_size)
             sheet.paste(tile, (x, y + 8))
-    sheet.save(path)
+    sheet.save(path, lossless=lossless, method=6)
     return path
 
 
@@ -408,6 +409,8 @@ def _write_report_comparison_matrices(
             output_path,
             items,
             title=f"OrbitQuant {media} generation comparison matrix",
+            tile_size=(1024, 1024) if media == "image" else (208, 214),
+            lossless=media == "image",
         )
         if result is not None:
             created[media] = result