inline-core 1.2.65__tar.gz → 1.2.67__tar.gz

{inline_core-1.2.65 → inline_core-1.2.67}/CLAUDE.md

@@ -126,6 +126,8 @@ between nodes and are never takes.
   every stop/start**, taking the models and leaving dangling symlinks in `models/`. This has cost two
   full re-downloads of MiniMax H3 at ~130 GB each. Weights go on the persistent root volume, or on an
   attached volume that survives a restart. Scratch is fine for logs and temporary output only.
+- **`huggingface_hub>=0.32`** - below it `hf_xet` is only an extra, and files over ~50GB (every
+  H3 transformer) refuse to download at all.
 - **Models root** - `INLINE_MODELS_DIR`, else `./models`. **Bring your own weights; nothing is
   downloaded.** ComfyUI-style category subfolders (`diffusion_models/`, `vae/`, `text_encoders/`,
   `loras/`, `controlnet/`, `checkpoints/`, `clip_vision/`, `upscale_models/`, `embeddings/`). The
@@ -161,6 +163,17 @@ between nodes and are never takes.
   → sequential offload → wont-fit. NF4 is what makes a 32B model viable on a 24 GB card. Note int8
   forces bf16 (torchao's weight-only int8 silently no-ops under fp16) while NF4 does not, so a Turing
   card keeps its fp16 tensor cores under NF4.
+- **A pre-reduced checkpoint must not be re-reduced, structurally or numerically.** MiniMax H3's
+  `pruned` builds ship the AdaLN branch already factorised to rank 8 and drop the timestep path
+  entirely, so re-running our factorisation multiplies a `[96768, 8]` projection by a full-width
+  basis. `minimaxh3/pipeline.py` turns `factorise_adaln` off for those, the same way the rule below
+  turns quantization off for a prequantized file. Both are the same rule: the source is already in
+  the target form.
+- **Size a checkpoint by what it becomes, not by what it weighs.** A pruned file has already lost
+  its AdaLN branch and an fp8 file stores half the bytes it will occupy once dequantised, so scaling
+  the on-disk number under-sizes both, by up to 3x. `minimaxh3.requirements.resident_bytes` counts
+  from the header. Under-sizing is the dangerous direction: the fit ladder then promises a machine
+  that dies to a host-RAM OOM kill instead of raising.
 - **Prequantized checkpoints must not be re-quantized.** A checkpoint that ships already quantized
   (`flux2/variants.is_prequantized`) has an on-disk size that already _is_ its resident size, so the
   ladder's assumption that quantization halves it does not hold, and handing diffusers a second,
@@ -228,11 +241,35 @@ real codec that moves tensors lives with the model runner.
   Don't scatter it.
 - **Bring-your-own models.** Nothing is downloaded by the engine. The catalog scans; the user places
   files. A model picker is a `SELECT` param with `options_from="<category>"`.
+- **Adapter strength is not a quality metric, and a threshold on it is a false-positive machine.**
+  Measured against real bases, published LoRAs that work well span `|B@A| / |W|` from 0.017%
+  (a style LoRA) to 1.2% (a restoration LoRA), so "this adapter looks weak" is not a finding. What
+  predicts a LoRA doing nothing is whether its per-weight change clears one quantization step. Warn
+  on that, and only when the base is actually quantized.
+- **Patching a diffusers object may patch a copy, and it will not tell you.**
+  `ModularPipeline.blocks` is a property returning `deepcopy(self._blocks)`, so hooking the block
+  graph through it installs cleanly onto a throwaway and reports success. That is how H3's denoise
+  ran with no per-step progress while the hook said it was attached. Reach for the backing
+  attribute, and prove a hook fires against the real object rather than trusting a return value.
 - **Verify image models by rendering.** The FLUX.2 work shipped five bugs past a green test suite,
   and every one produced a _wrong image rather than an error_: a mis-keyed checkpoint, a
   vision-language encoder loaded in place of a text one, an unnormalized latent, and a control context
   cast to a quantized weight's `uint8` storage dtype. A unit test cannot see a plausible-but-wrong
   image. Render something and look at it.
+- **Launchers are twins.** `webui.sh` and `webui.bat` change together; only the `launcher` CI job
+  can prove the `.bat`, since it cannot run on a dev box.
+- **Match CUDA arches by within-major compatibility, never exactly.** An `sm_8x` cubin runs on any
+  `sm_8y` where `y >= x`, so `sm_86` covers Ada's `sm_89`.
+- **Pass the widest `uv` flag that works.** `--no-sources-package` needs uv 0.10+; `--no-sources`
+  works back to 0.4 and means the same while torch is the only `[tool.uv.sources]` entry.
+- **An explicit user setting beats a heuristic.** Test `on`/`off` before any auto rule, or the
+  control is silently dead for whichever arch the rule excludes.
+- **Report a phase before the slow work, not after.** Progress emitted only on completion makes a
+  slow step look like a hung previous phase.
+- **In a `.bat`, `call` anything that might be a `.bat`.** `nvidia-smi` is sometimes a shim, and
+  without `call` it takes over the script and never returns.
+- **Log allocated AND reserved VRAM.** `nvidia-smi` shows only reserved, so allocator cache and a
+  leaked reference look identical from outside.
 - **Tests (pytest).** Cover the logic that matters: graph validate/topo/executor/cache, the catalog
   scan, the run store + server contract, the device/memory policy, the parallel group + xfuser seam,
   and each model runner (import-guarded, no GPU needed). See `tests/`.

{inline_core-1.2.65 → inline_core-1.2.67}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.65
+Version: 1.2.67
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11
@@ -14,7 +14,7 @@ Requires-Dist: controlnet-aux>=0.0.7; extra == 'all'
 Requires-Dist: diffusers==0.39.0; extra == 'all'
 Requires-Dist: einops>=0.7; extra == 'all'
 Requires-Dist: fastapi>=0.110; extra == 'all'
-Requires-Dist: huggingface-hub>=0.23; extra == 'all'
+Requires-Dist: huggingface-hub>=0.32; extra == 'all'
 Requires-Dist: imageio-ffmpeg>=0.4; extra == 'all'
 Requires-Dist: nvidia-ml-py>=12; extra == 'all'
 Requires-Dist: onnxruntime>=1.17; extra == 'all'
@@ -41,7 +41,7 @@ Requires-Dist: accelerate>=0.30; extra == 'runtime'
 Requires-Dist: av>=12; extra == 'runtime'
 Requires-Dist: controlnet-aux>=0.0.7; extra == 'runtime'
 Requires-Dist: diffusers==0.39.0; extra == 'runtime'
-Requires-Dist: huggingface-hub>=0.23; extra == 'runtime'
+Requires-Dist: huggingface-hub>=0.32; extra == 'runtime'
 Requires-Dist: onnxruntime>=1.17; extra == 'runtime'
 Requires-Dist: safetensors>=0.4; extra == 'runtime'
 Requires-Dist: scipy>=1.11; extra == 'runtime'

{inline_core-1.2.65 → inline_core-1.2.67}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.65"
+version = "1.2.67"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -29,7 +29,10 @@ runtime = [
   # Backs the Beta sigma schedule (diffusers gates use_beta_sigmas on scipy).
   "scipy>=1.11",
   # We call snapshot_download directly for the model popup, so pin it rather than rely on transit.
-  "huggingface_hub>=0.23",
+  # 0.32 is where hf_xet became a hard dependency rather than an extra. Below it, Hugging Face
+  # refuses the largest files outright ("too large to be downloaded using the regular download
+  # method"), which is every H3 transformer at 66GB.
+  "huggingface_hub>=0.32",
   # ControlNet preprocessors (the Apply ControlNet node): OpenPose/DWPose, MiDaS/Zoe depth, canny,
   # HED, lineart, MLSD, scribble, normal. DWPose runs its detector on ONNX Runtime.
   "controlnet-aux>=0.0.7",
@@ -85,7 +88,10 @@ all = [
   # Clip decode for MiniMax H3 LoRA training, and H3's reference node.
   "av>=12",
   "scipy>=1.11",
-  "huggingface_hub>=0.23",
+  # 0.32 is where hf_xet became a hard dependency rather than an extra. Below it, Hugging Face
+  # refuses the largest files outright ("too large to be downloaded using the regular download
+  # method"), which is every H3 transformer at 66GB.
+  "huggingface_hub>=0.32",
   "controlnet-aux>=0.0.7",
   "onnxruntime>=1.17",
   # server
@@ -111,8 +117,10 @@ name = "pytorch-cu126"
 url = "https://download.pytorch.org/whl/cu126"
 explicit = true
 
-# Launcher installs pass `--no-sources-package torch` so their detected index wins over this pin;
-# anything else added to this table would still apply to them.
+# Launcher installs pass `--no-sources` so their detected index wins over this pin. That flag is
+# broad rather than per-package because the per-package form is too new for the uv versions people
+# have. torch being the ONLY entry here is what makes that equivalent: adding another would silently
+# start ignoring it on launcher installs too.
 [tool.uv.sources]
 torch = [{ index = "pytorch-cu126", marker = "sys_platform == 'win32'" }]
 

{inline_core-1.2.65 → inline_core-1.2.67}/src/inline_core/models/keymap.py

@@ -262,7 +262,7 @@ def transform(
         raise ComponentError(f"{key} has {tensor.shape[0]} rows, not divisible into {parts} parts.")
     if verify_layout:
         assert_layout(tensor, action, key=key)
-    source = _deinterleave(tensor, parts, action.head_dim) if (
+    source = deinterleave_rows(tensor, parts, action.head_dim) if (
         action.layout is RowLayout.INTERLEAVED
     ) else tensor
     block = source.shape[0] // parts
@@ -270,16 +270,31 @@ def transform(
         yield target, source[index * block : (index + 1) * block]
 
 
-def _deinterleave(tensor: Any, parts: int, head_dim: int) -> Any:
-    """``[p0_h0; p1_h0; p2_h0][p0_h1; …]`` to ``[p0_all; p1_all; p2_all]``.
-
-    ``transpose`` is not the same call in torch and numpy - torch swaps two axes, numpy wants a full
-    permutation - so the swap is spelled per backend rather than duck-typed.
-    """
+def deinterleave_rows(tensor: Any, parts: int, head_dim: int) -> Any:
+    """``[p0_h0; p1_h0; p2_h0][p0_h1; …]`` to ``[p0_all; p1_all; p2_all]``."""
     if head_dim < 1:
         raise ComponentError("De-interleaving needs the head dimension the parts are grouped by.")
     heads = tensor.shape[0] // (parts * head_dim)
-    reshaped = tensor.reshape(heads, parts, head_dim, *tensor.shape[1:])
+    return _swap01(tensor, (heads, parts, head_dim))
+
+
+def interleave_rows(tensor: Any, parts: int, head_dim: int) -> Any:
+    """``[p0_all; p1_all; p2_all]`` back to per-head groups: the inverse of ``deinterleave_rows``.
+
+    Needed to *write* a checkpoint or adapter in a publisher's interleaved layout, where the load
+    path only ever reads one."""
+    if head_dim < 1:
+        raise ComponentError("Interleaving needs the head dimension the parts are grouped by.")
+    heads = tensor.shape[0] // (parts * head_dim)
+    return _swap01(tensor, (parts, heads, head_dim))
+
+
+def _swap01(tensor: Any, shape: tuple[int, int, int]) -> Any:
+    """Reshape to ``shape`` plus the trailing dims, exchange the first two, flatten back.
+
+    ``transpose`` is not the same call in torch and numpy - torch swaps two axes, numpy wants a full
+    permutation - so the swap is spelled per backend rather than duck-typed."""
+    reshaped = tensor.reshape(*shape, *tensor.shape[1:])
     if _is_torch(tensor):
         moved = reshaped.transpose(0, 1).contiguous()
     else:

{inline_core-1.2.65 → inline_core-1.2.67}/src/inline_core/models/lora.py

@@ -29,6 +29,10 @@ if TYPE_CHECKING:
 #: while ostris' training adapter uses the reference names.
 Alias = Callable[[str], str | None]
 
+#: Rewrites a whole adapter before it is matched, for an arch whose checkpoint keys need more than a
+#: rename - MiniMax H3 ships attention fused, so three of our modules are one of theirs.
+Translate = Callable[[dict[str, Any]], dict[str, Any]]
+
 _DOWN = ("lora_down.weight", "lora_A.weight", "lora_A.default.weight")
 _UP = ("lora_up.weight", "lora_B.weight", "lora_B.default.weight")
 # Prefixes checkpoints put in front of the module path; stripped when matching against the model.
@@ -39,12 +43,22 @@ _PREFIXES = ("diffusion_model.", "transformer.", "lora_unet_", "lora_te_", "base
 LoraPlan = dict[str, list[tuple[Any, Any, float]]]
 
 
-def fuse_loras(model: Any, loras: tuple[LoraRef, ...], alias: Alias | None = None) -> None:
+def fuse_loras(
+    model: Any,
+    loras: tuple[LoraRef, ...],
+    alias: Alias | None = None,
+    translate: Translate | None = None,
+) -> None:
     """Merge each LoRA into ``model``'s weights in order. No-op for an empty stack."""
-    apply_plan(model, plan_loras(model, loras, alias))
+    apply_plan(model, plan_loras(model, loras, alias, translate))
 
 
-def plan_loras(model: Any, loras: tuple[LoraRef, ...], alias: Alias | None = None) -> LoraPlan:
+def plan_loras(
+    model: Any,
+    loras: tuple[LoraRef, ...],
+    alias: Alias | None = None,
+    translate: Translate | None = None,
+) -> LoraPlan:
     """Resolve every LoRA against ``model``'s module names, without touching any weights.
 
     Split from the fusing so a streaming loader can validate the whole stack **before** reading a
@@ -53,7 +67,7 @@ def plan_loras(model: Any, loras: tuple[LoraRef, ...], alias: Alias | None = Non
     plan: LoraPlan = {}
     names = _linear_module_names(model)
     for lora in loras:
-        _plan_one(plan, names, lora.file, lora.strength, alias)
+        _plan_one(plan, names, lora.file, lora.strength, alias, translate)
     return plan
 
 
@@ -74,7 +88,12 @@ def apply_plan(module: Any, plan: LoraPlan, prefix: str = "") -> None:
 
 
 def _plan_one(
-    plan: LoraPlan, names: dict[str, None], path: str, strength: float, alias: Alias | None
+    plan: LoraPlan,
+    names: dict[str, None],
+    path: str,
+    strength: float,
+    alias: Alias | None,
+    translate: Translate | None = None,
 ) -> None:
     from safetensors.torch import load_file
 
@@ -83,6 +102,8 @@ def _plan_one(
     except Exception as exc:  # noqa: BLE001
         raise ComponentError(f"Could not read LoRA {path!r}: {exc}") from exc
 
+    if translate is not None:
+        state = translate(state)
     pairs, alphas = _group(state)
     if not pairs:
         raise ComponentError(f"LoRA {path!r} contains no recognisable lora_down/lora_up pairs.")
@@ -104,27 +125,39 @@ def _plan_one(
         )
 
 
+#: Most fp32 delta held at once. The product is computed a slice of output rows at a time because
+#: the whole of it is enormous: one MiniMax H3 block's six Linears come to 1.5GB and the model to
+#: 80GB, which is host RAM during a staged load and took a 60GB box down three times.
+_DELTA_CHUNK_BYTES = 64 * 1024 * 1024
+
+
 def _add_delta(weight: Any, up: Any, down: Any, scale: float) -> None:
     """Fuse ``scale * (up @ down)`` into ``weight`` in place.
 
-    Computed on the weight's own device: a big LoRA (Krea 2's are ~260 modules on a 12.9B model)
-    materializes tens of GB of fp32 deltas, and doing that on the CPU costs ~20s of maths plus the
-    transfer where the GPU takes ~2s. Falls back to the CPU if the device runs out of memory, so a
-    tight card still fuses, just slowly."""
+    Computed on the weight's own device: doing it on the CPU costs ~20s of maths plus the transfer
+    where the GPU takes ~2s. Falls back to the CPU if the device runs out of memory, so a tight card
+    still fuses, just slowly."""
     import torch
 
     try:
-        weight.add_(_delta(up, down, weight, weight.device) * scale)
+        _accumulate(weight, up, down, scale, weight.device)
     except torch.cuda.OutOfMemoryError:
-        weight.add_((_delta(up, down, weight, "cpu") * scale).to(weight.device, weight.dtype))
+        _accumulate(weight, up, down, scale, "cpu")
 
 
-def _delta(up: Any, down: Any, weight: Any, device: Any) -> Any:
-    """``up @ down`` on ``device``, shaped and typed for the target weight. Conv LoRAs flatten the
-    spatial dims."""
+def _accumulate(weight: Any, up: Any, down: Any, scale: float, device: Any) -> None:
+    """Add the product into ``weight`` in row slices. Conv LoRAs flatten the spatial dims."""
     dtype = _fuse_dtype(up)
-    delta = up.to(device, dtype=dtype).flatten(1) @ down.to(device, dtype=dtype).flatten(1)
-    return delta.reshape(weight.shape).to(weight.dtype)
+    rows = up.to(device, dtype=dtype).flatten(1)
+    cols = down.to(device, dtype=dtype).flatten(1)
+    if not weight.is_contiguous():  # a non-contiguous target cannot be written through a view
+        weight.add_((rows @ cols).reshape(weight.shape).to(weight.dtype) * scale)
+        return
+    target = weight.view(rows.shape[0], -1)
+    step = max(1, _DELTA_CHUNK_BYTES // max(1, cols.shape[1] * 4))
+    for start in range(0, rows.shape[0], step):
+        stop = start + step
+        target[start:stop].add_((rows[start:stop] @ cols).to(weight.dtype) * scale)
 
 
 def _fuse_dtype(tensor: Any) -> Any:
@@ -141,20 +174,29 @@ def _alpha_scale(alpha: Any, rank: int) -> float:
     return float(alpha.item() if hasattr(alpha, "item") else alpha) / float(rank)
 
 
+def split_key(key: str) -> tuple[str, str] | None:
+    """``…to_q.lora_A.weight`` to ``("…to_q", "down")``. None for anything that is not a LoRA key.
+
+    Public so a per-arch key translator groups by exactly the suffixes the fuser recognises: a
+    convention known to one and not the other would drop tensors silently."""
+    for suffix in _DOWN:
+        if key.endswith("." + suffix):
+            return key[: -len(suffix) - 1], "down"
+    for suffix in _UP:
+        if key.endswith("." + suffix):
+            return key[: -len(suffix) - 1], "up"
+    if key.endswith(".alpha"):
+        return key[: -len(".alpha")], "alpha"
+    return None
+
+
 def _group(state: dict[str, Any]) -> tuple[dict[str, tuple[Any, Any]], dict[str, Any]]:
-    downs: dict[str, Any] = {}
-    ups: dict[str, Any] = {}
-    alphas: dict[str, Any] = {}
+    parts: dict[str, dict[str, Any]] = {}
     for key, value in state.items():
-        for suffix in _DOWN:
-            if key.endswith("." + suffix):
-                downs[key[: -len(suffix) - 1]] = value
-        for suffix in _UP:
-            if key.endswith("." + suffix):
-                ups[key[: -len(suffix) - 1]] = value
-        if key.endswith(".alpha"):
-            alphas[key[: -len(".alpha")]] = value
-    return {k: (downs[k], ups[k]) for k in downs if k in ups}, alphas
+        if (split := split_key(key)) is not None:
+            parts.setdefault(split[0], {})[split[1]] = value
+    pairs = {k: (v["down"], v["up"]) for k, v in parts.items() if "down" in v and "up" in v}
+    return pairs, {k: v["alpha"] for k, v in parts.items() if "alpha" in v}
 
 
 def _linear_module_names(model: Any) -> dict[str, None]:

{inline_core-1.2.65 → inline_core-1.2.67}/src/inline_core/models/minimaxh3/adaln.py

@@ -41,6 +41,11 @@ from typing import Any
 import torch
 from torch import nn
 
+from .vendor.transformer_minimax_h3 import (
+    MiniMaxH3AdaLayerNormModulation,
+    MiniMaxH3AdaLayerNormOut,
+)
+
 logger = logging.getLogger("inline_core.minimaxh3")
 
 #: Rank kept. Five directions carry the energy; eight matches the published build and leaves slack.
@@ -144,3 +149,100 @@ def factorise(model: Any, *, rank: int = RANK) -> int:
         len(model.transformer_blocks), saved / 1e9,
     )
     return saved
+
+
+# --- the published pruned builds ------------------------------------------------------------
+#
+# MiniMax ship `pruned` checkpoints that do this same rank-8 reduction ahead of time, and go one
+# step further: the timestep path itself is gone. There is no `time_embedder` in the file at all,
+# only `adaln_t_table [1025, 8]`, holding `silu(temb)` already projected into their basis at 1025
+# points across t in [0, 1]. So the branch cannot be rebuilt as a basis applied to a `silu(temb)` we
+# compute; the table has to be read directly.
+#
+# Off-grid timesteps are interpolated. Measured against the full bf16 weights at 24 random t, the
+# table reaches 1.636e-4 relative with linear interpolation and 1.874e-4 taking the nearest row,
+# where one bf16 ulp of the reference is 1.307e-3. The grid is dense enough that interpolating costs
+# nothing and removes the sampler constraint a lookup would otherwise impose.
+
+#: Rows in the published table. Checked, not assumed: a build on a different grid must not be read
+#: as though it were on this one.
+TABLE_ROWS = 1025
+
+
+class TableEmbedder(nn.Module):
+    """Stands in for ``time_proj`` + ``time_embedder``, returning the pruned build's rank-8 row.
+
+    ``linear_1`` exists because the port reads ``time_embedder.linear_1.weight.dtype`` to cast its
+    input; it carries the table's dtype and nothing else, which keeps ``vendor/`` verbatim.
+    """
+
+    #: Declared so the buffer reads as a tensor; ``register_buffer`` alone types as ``Module``.
+    table: torch.Tensor
+
+    def __init__(self, table: torch.Tensor) -> None:
+        super().__init__()
+        self.register_buffer("table", table, persistent=True)
+        self.linear_1 = nn.Linear(1, 1, bias=False, dtype=table.dtype)
+
+    def forward(self, timestep: torch.Tensor) -> torch.Tensor:
+        rows = self.table.shape[0]
+        position = timestep.to(self.table.dtype).flatten() * (rows - 1)
+        low = position.floor().long().clamp(0, rows - 2)
+        frac = (position - low).unsqueeze(1)
+        return self.table[low] * (1 - frac) + self.table[low + 1] * frac
+
+
+class TabulatedModulation(MiniMaxH3AdaLayerNormModulation):
+    """``adaln_proj`` reading a table row. It already holds ``silu(temb)``, so no activation."""
+
+    def forward(self, temb: torch.Tensor) -> tuple[torch.Tensor, ...]:
+        out = self.linear(temb.to(self.linear.weight.dtype)).view(-1, 6 * self.hidden_size)
+        return out.chunk(6, dim=-1)
+
+
+class TabulatedNormOut(MiniMaxH3AdaLayerNormOut):
+    """``norm_out`` reading a table row, otherwise the port's own forward."""
+
+    def forward(
+        self, hidden_states: torch.Tensor, temb: torch.Tensor, timestep_indices: torch.Tensor
+    ) -> torch.Tensor:
+        shift, scale = self.linear(temb.to(self.linear.weight.dtype)).chunk(2, dim=-1)
+        hidden_states = self.norm(hidden_states)
+        return hidden_states * (1.0 + scale.index_select(0, timestep_indices)) + shift.index_select(
+            0, timestep_indices
+        )
+
+
+@torch.no_grad()
+def tabulate(model: Any, table: torch.Tensor) -> None:
+    """Rebuild the timestep path around a pruned build's table, on the meta device before streaming.
+
+    Every module the table feeds changes shape, so this has to happen before any weight is placed:
+    the rank-8 ``adaln_proj`` in the file would otherwise be assigned into a ``[96768, 2688]`` slot.
+    """
+    if table.ndim != 2 or table.shape[0] != TABLE_ROWS:
+        raise ValueError(
+            f"adaln_t_table is {tuple(table.shape)}, not [{TABLE_ROWS}, rank]. This build is on a "
+            "different timestep grid from the one measured, and reading it as if it were not would "
+            "shift the modulation at every step while still rendering."
+        )
+    rank = int(table.shape[1])
+    model.time_proj = nn.Identity()
+    model.time_embedder = TableEmbedder(table)
+    for block in model.transformer_blocks:
+        block.adaln_proj = _retyped(block.adaln_proj, TabulatedModulation, rank)
+    model.norm_out = _retyped(model.norm_out, TabulatedNormOut, rank)
+
+
+def _retyped(module: Any, cls: type, rank: int) -> Any:
+    """The same module with its projection narrowed to ``rank`` inputs, still on meta."""
+    replacement = module
+    replacement.__class__ = cls
+    old = module.linear
+    with torch.device("meta"):
+        replacement.linear = nn.Linear(rank, old.out_features, bias=old.bias is not None)
+    return replacement
+
+
+#: Parameters ``tabulate`` creates that no checkpoint fills.
+TABULATED_SELF_COMPUTED = ("time_embedder.linear_1.weight", "time_embedder.table")

{inline_core-1.2.65 → inline_core-1.2.67}/src/inline_core/models/minimaxh3/keys.py

@@ -23,7 +23,7 @@ fused QKV into three.
 
 from __future__ import annotations
 
-from ..keymap import AssertEqual, KeyPlan, Rename, RowLayout, Split, SwapHalves
+from ..keymap import AssertEqual, Drop, KeyPlan, Rename, RowLayout, Split, SwapHalves
 
 #: Bumping this invalidates every prepared artifact built by the old plan.
 PLAN_VERSION = "minimax-h3.keys.1"
@@ -81,9 +81,17 @@ def build_plan(
     num_blocks: int = NUM_BLOCKS,
     num_refiner_blocks: int = NUM_REFINER_BLOCKS,
     head_dim: int = HEAD_DIM,
+    pruned: bool = False,
+    sidecars: tuple[str, ...] = (),
 ) -> KeyPlan:
     """The plan for a publisher's layout. ``source`` selects how the fused QKV rows are arranged.
 
+    ``pruned`` is the published rank-8 build: it ships ``adaln_t_table`` in place of the whole
+    timestep path, so the two ``time_embedder`` projections are simply not in the file.
+
+    ``sidecars`` are the quantisation tensors an fp8 build carries beside each weight. They are
+    consumed while streaming and dropped here, so the coverage check still accounts for every key.
+
     The counts are arguments so a round-trip test can exercise the same code at a size that fits in
     memory; the defaults are the released geometry.
     """
@@ -95,7 +103,16 @@ def build_plan(
         ) from None
 
     actions: dict[str, object] = {}
-    for stem, target in _TOP_LEVEL.items():
+    top_level = {
+        stem: target
+        for stem, target in _TOP_LEVEL.items()
+        if not (pruned and stem.startswith("time_embedder."))
+    }
+    if pruned:
+        actions["adaln_t_table"] = Drop("read before streaming, to rebuild the timestep path")
+    for key in sidecars:
+        actions[key] = Drop("a quantisation scale, applied to its weight while streaming")
+    for stem, target in top_level.items():
         for suffix in ("weight", "bias"):
             actions[f"{stem}.{suffix}"] = Rename(f"{target}.{suffix}")
     for key, target in _WEIGHT_ONLY.items():
@@ -126,9 +143,16 @@ def build_plan(
                     continue
                 actions[f"{src}.{stem}"] = Rename(f"{dst}.{target}")
 
-    return KeyPlan(version=f"{PLAN_VERSION}+{source}", actions=actions)  # type: ignore[arg-type]
+    suffix = source + ("+pruned" if pruned else "") + ("+fp8" if sidecars else "")
+    return KeyPlan(version=f"{PLAN_VERSION}+{suffix}", actions=actions)  # type: ignore[arg-type]
 
 
-def self_computed_targets() -> set[str]:
+def self_computed_targets(*, pruned: bool = False) -> set[str]:
     """Targets the port builds itself, which ``check_coverage`` must not demand be filled."""
-    return {"rope.inv_freq"}
+    if not pruned:
+        return {"rope.inv_freq"}
+    return {"rope.inv_freq", *_PRUNED_SELF_COMPUTED}
+
+
+#: What ``adaln.tabulate`` creates in place of the timestep path. No checkpoint fills these.
+_PRUNED_SELF_COMPUTED = ("time_embedder.table", "time_embedder.linear_1.weight")