Add files using upload-large-folder tool

README.md

@@ -0,0 +1,104 @@
+---
+tags:
+- blackhole
+- p150
+- tt-dit-server
+- tt-model-cache
+- tt-model-container
+---
+
+# gr00t-n1.5-3b-p150
+
+NVIDIA Isaac GR00T N1.5 (3B vision-language-action policy: SigLIP ViT (224², 256 tokens/image) → linear projector → 12-layer Qwen3-1.7B backbone → 4-block VL self-attention → 16-block cross/self AdaLN DiT, 4 Euler flow-matching steps) running on one Tenstorrent Blackhole p150a via tt-nn: one camera frame + proprioceptive state + a task instruction in, a 16-step chunk of GR1 arm/hand joint targets out. Stage-1 release: every op is a TTNN op replayed from four Metal traces (DiT block matmul weights bfp8, everything else bf16); the persistent-megakernel denoise is in progress and not in this image.
+Weights: [nvidia/GR00T-N1.5-3B](https://huggingface.co/nvidia/GR00T-N1.5-3B) (NVIDIA License, non-commercial) · Paper: [arXiv:2503.14734](https://arxiv.org/abs/2503.14734) (GR00T N1 report; the N1.5 changes are described in the [N1.5 model card](https://huggingface.co/nvidia/GR00T-N1.5-3B)) · Upstream code: [NVIDIA/Isaac-GR00T](https://github.com/NVIDIA/Isaac-GR00T) (tag `n1.5-release`) · Port: `code/models/experimental/gr00t` in this repo (tt-metal-tree layout, frozen snapshot `5dc0517ee3b`) + the policy server `code/gr00t_p150`
+
+Runs on **p150** (mesh `P150`).
+
+Packaged and published with [tt-model-manager](https://github.com/tenstorrent/tt-model-manager) 0.1.0 (manifest schema 5.1).
+
+## Quickstart
+
+```bash
+tt-model pull  changh95/GR00T-N1.5-3B-p150 --with-weights
+tt-model serve changh95/GR00T-N1.5-3B-p150
+```
+
+`pull --with-weights` downloads the Docker image and the [`nvidia/GR00T-N1.5-3B`](https://huggingface.co/nvidia/GR00T-N1.5-3B) weights at `869830fc749c35f34771aa5209f923ac57e4564e` (into your HF cache; they are not in the image). `serve` starts the model's own HTTP server on port 20000 (or the next free port, if that one is busy); the first start compiles kernels for your device, which takes several minutes, and the server is ready when it logs `Application startup complete`.
+
+### Run with tt-cli
+
+```bash
+tt serve changh95/GR00T-N1.5-3B-p150
+python3 - <<'EOF'
+import base64, json
+body = json.load(open("media/demo_observation.json"))          # GR1 PickNPlace demo step: raw joint state + instruction
+body.pop("_note", None)
+body["images"] = {"ego_view": base64.b64encode(open("media/demo_ego_view.png", "rb").read()).decode()}
+json.dump(body, open("req.json", "w"))
+EOF
+curl -s localhost:20000/predict -H 'Content-Type: application/json' -d @req.json
+tt model stop changh95/GR00T-N1.5-3B-p150
+```
+
+- `POST /predict`: `images` (`{"ego_view": <base64 PNG/JPEG>}` — the one GR1 camera; any size with sides in 64–4096 px, the server applies the checkpoint's own eval chain: 0.95 centre crop → bilinear 224×224 → Eagle2.5 normalisation), `state` (`{group: [[floats]]}`: `left_arm` 7, `right_arm` 7, `left_hand` 6, `right_hand` 6 — raw joint values, one time step), `instruction` (task text, ≤ 102 BPE tokens); optional `embodiment` (`gr1`, the only layout in this image), `seed` (initial flow-matching noise; default 0 = the deployed policy's seed → deterministic) or `noise` (an explicit `[16][32]` initial noise), `state_dtype` (`float64` default, as the GR1 dataset), `return_normalized` (also return the model-space chunk).
+- `GET /health`, `GET /info` (the full input/output contract, weights/tree provenance, warm-up latency and fidelity), `GET /demo` (the shipped demo request and its fp32 reference actions).
+
+### Response
+
+```json
+{"actions": {"left_arm":   [[0.0069, 0.2107, 0.0483, -1.8136, -0.1264, -0.0548, 0.0147], "... 16 steps"],
+             "right_arm":  [[-0.0177, -0.1731, 0.3702, -1.7429, 0.4968, -0.0567, 0.9849], "..."],
+             "left_hand":  [[0.0081, 0.0155, 0.0033, 0.0064, 0.0169, 0.0438], "..."],
+             "right_hand": [[-1.4880, -1.4915, -1.4781, -1.4810, -2.9609, 2.9904], "..."]},
+ "action_horizon": 16, "action_keys": ["left_arm", "right_arm", "left_hand", "right_hand"], "action_dims": {"left_arm": 7, "right_arm": 7, "left_hand": 6, "right_hand": 6},
+ "normalized": false, "embodiment": "gr1", "embodiment_id": 24, "version": "n15", "model": "GR00T-N1.5-3B-p150", "layout": "gr1",
+ "images": {"ego_view": {"frames": 1, "received_hw": [256, 256]}}, "seq_len": 296, "prompt_tokens": 14, "state_dtype": "float64",
+ "noise_source": "client", "seed": null,
+ "timing_ms": {"decode": 1.5, "encode": 2.6, "device": 43.0, "decode_actions": 0.1, "total": 47.2}}
+```
+
+- `actions` are **physical, un-normalised** joint targets (radians) in the GR1 arms-and-hands action space of the checkpoint's `experiment_cfg/metadata.json` statistics, 16 steps × [7, 7, 6, 6] dims — what `Gr00tPolicy.get_action` returns for this checkpoint; the values above are abridged from the shipped demo request (`GET /demo`) with its golden initial noise. `seq_len` is the LLM prompt length the request produced (296 for the demo; padded to 384 on device). `timing_ms.device` covers input upload, the four trace replays and the action readback; `total` is the whole handler.
+
+### Demo
+
+| Input (`media/demo_ego_view.png`, GR1 sim `robot_sim.PickNPlace` traj 0 / step 100, 256×256) | Instruction | p150a actions vs the fp32 reference (`media/demo_actions.png`) |
+|:---:|:---|:---:|
+| ![](media/demo_ego_view.png) | `pick the pear from the counter and place it in the plate` | ![](media/demo_actions.png) |
+
+### Accuracy and speed
+
+| Metric | Value |
+|---|---:|
+| Action chunk vs the fp32 reference (`Gr00tPolicy`, same observation, same initial noise) | PCC `left_arm` 0.99995 · `right_arm` 0.99997 · `right_hand` 0.99999 (gates 0.9999; max\|d\| 0.021 / 0.017 / 0.029 rad) · `left_hand` max\|d\| 0.018 rad ≤ 0.046 (PCC 0.943 reported only: the golden chunk is near-constant there, spread 0.1 rad — NVIDIA's own bf16 GPU path scores 0.952) · normalised chunk `action_pred_normalized` 0.99998 (max\|d\| 0.014 ≤ 0.027) |
+| Intermediate taps vs the fp32 reference (untraced path from pixels, 57 gated taps + determinism row) | **58/58 rows pass**; tightest: `vit_block_first` 0.99994 (gate 0.9999), `backbone_features` 0.99586 (0.995), `vl_self_attention_out` 0.99119 (0.991), `vit_post_ln` 0.99506 (0.993) |
+| Traced == untraced, determinism, stale state | traced `action_pred` / `backbone_features` / hoisted K,V bit-equal to the untraced run; 5 trace replays bit-identical; mutated inputs (`n_text` > L_max, other shapes) refused before any device write; A→B→A→B alternating observations on one captured model pass |
+| Inference on p150a (port benchmark, warm, batch 1, one 224² image, LLM S 296→384, median of 50; `benchmarks/results/e2e_stage1_n15.json`) | **43.4 ms end-to-end** (p90 44.1) = host encode 1.5 + upload 3.8 + 4 traces 37.8 (vision 8.7 · LLM 8.7 · adapter 4.5 · denoise 16.0) + readback 0.1 + decode 0.2 |
+| Served over HTTP by this image (`tt-model serve`, warm, batch 1, the demo request, 10 warm-ups + 50 timed; `scripts/bench_http.py`) | **42.4 ms device · 45.4 ms server-side** (medians; p90 43.2 / 49.2; min 41.7 / 44.5) = image decode 1.1 + host encode 1.6 + device 42.4 (upload, 4 trace replays, readback) + un-normalise 0.1; 47.6 ms client wall on the same host (p90 51.8). Under a heavily loaded host (two concurrent tt-metal builds, load average 16–110) the same loop read 44.3 / 44.5 ms device and 53.6 / 58.1 ms server-side medians with p90s of 55 / 91–97 ms — the host-side stages, not the device, absorb the contention. The served actions are bit-identical to the port's device test and to the host run |
+| Same policy on an RTX 5090 (same host, NVIDIA's unmodified `Gr00tPolicy`, eager PyTorch bf16 autocast + flash-attn 2, batch 1) | `get_action` e2e **58.0 ms** (preprocessing 2.2, model 55.4 = backbone 20.8 + action head 34.6) → the p150a is 1.34× faster end-to-end (43.4 vs 58.0) and 1.33× on the model (41.7 device vs 55.4); NVIDIA's N1.5 README quotes 47.9 ms on an H100 (backbone 23.2 + head 4 × 6.2) |
+
+### Caveats
+
+- **Stage-1 path.** Vision / LLM / adapter / denoise are TTNN ops captured in four Metal traces; DiT block matmul weights are bfp8_b, everything else bf16 (`mixed_dit`). The persistent-megakernel denoise (Stage 2) is at rung K1 — its weight-streaming kernel measures 464 GB/s bf16 / 414 GB/s bfp8 (90.6 % of DRAM peak) on the full DiT block set — and is **not** in this image.
+- **One embodiment, one layout.** The image is built for GR1 arms-and-hands (`gr1`, embodiment slot 24, one `ego_view` camera, ≤ 102 text tokens → LLM sequence padded to 384); other embodiments, cameras or longer instructions are refused with 400, nothing is truncated. Batch 1; requests are serialised on one lock.
+- **Noise is seeded** (seed 0, as the deployed policy); pass `seed` or `noise` for another draw. The reference noise of the shipped demo is not seed-reproducible, so the smoke test sends it as `noise`. Outputs are the base checkpoint's actions for the GR1 sim data config — a real robot needs NVIDIA's post-training.
+- Not an OpenAI-compatible API; `GET /v1/models` is a stub so the tt-model ready card does not 404.
+- Validated on tt-metal main `668c2907575` (`v0.79.0-dev20260914-1`), single p150a only, with this exact image (`tt-model serve` → smoke test → 50-request benchmark → `tt-model stop`, three boots). **First boot is cold**: the checkpoint is converted into the port's device layout under `~/.cache/tt-model/gr00t-n1.5-3b-p150/weights` (6.4 GB, 9 s) and the kernels of the four traces are JIT-compiled into `…/cache` (411 MB, ~87 s incl. trace capture) — `tt-model serve` reported READY after 1 min 43 s; the next boots reused both caches and were ready in 20 s (loaded host) and 9.7 s (quiet host). Every boot re-checks the warm-up actions against the shipped fp32 reference (PCC 0.999982 here) and refuses to serve below 0.999.
+- GPU comparison: the RTX 5090 row is NVIDIA's unmodified `Gr00tPolicy` path (`Isaac-GR00T` `n1.5-release`, torch 2.7.1+cu128, transformers 4.51.3, flash-attn 2.8.3), best median of 3 × (20 warm-ups + 20 timed calls), GPU idle, no `torch.compile` / TensorRT; the p150a rows are the Stage-1 trace path incl. upload and readback. p150a power was not measured, so no efficiency comparison is made. Full table: [`GPU_COMPARISON.md`](GPU_COMPARISON.md).
+
+### Licensing
+
+- Weights: [nvidia/GR00T-N1.5-3B](https://huggingface.co/nvidia/GR00T-N1.5-3B), **NVIDIA License** — use limited to research or evaluation (non-commercial), redistribution only under the same licence (copy in [`LICENSE`](LICENSE)). Not redistributed here; `tt-model serve` fetches the pinned snapshot into your HF cache.
+- Tokenizer files under `code/gr00t_p150/assets/tokenizer/n15/` (Qwen2 BPE + Eagle2.5 special tokens) are copied from [NVIDIA/Isaac-GR00T `n1.5-release`](https://github.com/NVIDIA/Isaac-GR00T/tree/n1.5-release) (Apache-2.0).
+- Port and serving code (`code/models/experimental/gr00t`, `code/gr00t_p150`, `code/scripts`): Apache-2.0 (SPDX headers), © 2026 Tenstorrent; as a derivative work of the weights it is distributed here under the same non-commercial use limitation (NVIDIA License §3.2). tt-metal / tt-nn: Apache-2.0.
+- Demo frame and state (`media/`): one step of the GR1 `robot_sim.PickNPlace` demo data shipped with Isaac-GR00T.
+
+## Provenance
+
+The exact sources the image was built from — `code/` in this repo is byte-identical to the model code inside the image:
+
+| component | built from |
+| --- | --- |
+| tt-metal | [`668c290757550588d0ce46b180c344a462a2aaf5`](https://github.com/tenstorrent/tt-metal/commit/668c290757550588d0ce46b180c344a462a2aaf5) |
+| `code/` digest | `a2771515bca98527` (sha256, first 16 hex digits) |
+| built | 2026-09-14T15:17:00+00:00 by tt-model 0.1.0 |
+

code/gr00t_p150/__init__.py

@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+"""``gr00t_p150``: the HTTP policy server shipped by the ``changh95/GR00T-N1.5-3B-p150`` and
+``changh95/GR00T-N1.6-3B-p150`` tt-model container packages.
+
+The device port itself lives in ``models.experimental.gr00t`` (tt-metal tree layout, shipped under ``code/models/``
+in the same repos); this package only adds the FastAPI server (:mod:`gr00t_p150.server.app`), its request /
+response schemas (:mod:`gr00t_p150.server.schemas`), a stdlib-only smoke test (:mod:`gr00t_p150.server.smoke_test`),
+the canonical demo observations of both versions (``demo/<version>/``) and the vendored Qwen2 tokenizer files the
+port's prompt builder needs (``assets/tokenizer/<version>/``).
+
+Importing this package has no side effects.
+"""
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

code/models/common/utility_functions.py

@@ -0,0 +1,1266 @@
+# SPDX-FileCopyrightText: © 2023 Tenstorrent USA, Inc.
+
+# SPDX-License-Identifier: Apache-2.0
+
+import math
+import os
+import struct
+import time
+from typing import Union
+
+import numpy as np
+import torch
+from loguru import logger
+from ttnn.device import Arch
+from typing_extensions import deprecated
+
+import ttnn
+
+
+def get_mesh_device():
+    """Fixture to provide mesh device configuration."""
+    mesh_device = os.environ.get("MESH_DEVICE", "N150")
+    mesh_config = {
+        "N150": (1, 1),
+        "N300": (2, 1),
+        "T3K": (8, 1),
+        "TG": (8, 4),
+    }.get(mesh_device, (ttnn.get_num_devices(), 1))
+    return mesh_config
+
+
+### Math operations ###
+def _nearest_32(x):
+    return math.ceil(x / 32) * 32
+
+
+def nearest_32(
+    x,
+):  # needs refctoring; to match alias called in some scripts (e.g. test_padding_test in unit tests)
+    return _nearest_32(x)
+
+
+def _nearest_y(x, y):
+    return math.ceil(x / y) * y
+
+
+def nearest_y(x, y):
+    return _nearest_y(x, y)
+
+
+def divup(a, b):
+    return (a + b - 1) // b
+
+
+def roundup(a, b):
+    result = divup(a, b) * b
+    return result
+
+
+def roundup32(a):
+    return roundup(a, 32)
+
+
+def float_to_bits(x):
+    s = struct.pack(">f", x)
+    return struct.unpack(">l", s)[0]
+
+
+def torch_random(shape, low, high, dtype):
+    if dtype in [torch.int64, torch.int32, torch.int16, torch.int8]:
+        return torch.randint(low, high, shape, dtype=dtype)
+    return torch.zeros(shape, dtype=dtype).uniform_(low, high)
+
+
+def torch_random_with_zeros(shape, low, high, dtype, zero_fraction=0.1):
+    total_elements = torch.prod(torch.tensor(shape)).item()
+    num_zeros = int(total_elements * zero_fraction)
+    num_random = total_elements - num_zeros
+
+    # Generate random values between low and high
+    random_values = torch.empty(num_random).uniform_(low, high)
+    zeros = torch.zeros(num_zeros)
+
+    # Combine zeros and random values
+    combined = torch.cat([zeros, random_values])
+
+    # Shuffle the tensor
+    shuffled = combined[torch.randperm(combined.size(0))]
+
+    # Reshape to the desired shape. Tensor.to is not in-place, so return the converted tensor.
+    result_tensor = shuffled.view(shape)
+    return result_tensor.to(dtype)
+
+
+### Profiling ###
+class Profiler:
+    def __init__(self):
+        self.start_times = dict()
+        self.times = dict()
+        self.disabled = False
+
+    def clear(self):
+        self.start_times = dict()
+        self.times = dict()
+        self.disabled = False
+
+    def enable(self):
+        self.disabled = False
+
+    def disable(self):
+        self.disabled = True
+
+    def start(self, key, force_enable=False):
+        if self.disabled and not force_enable:
+            return
+
+        self.start_times[key] = time.time()
+
+    def end(self, key, PERF_CNT=1, force_enable=False):
+        if self.disabled and not force_enable:
+            return
+
+        if key not in self.start_times:
+            return
+
+        diff = time.time() - self.start_times[key]
+
+        if key not in self.times:
+            self.times[key] = []
+
+        self.times[key].append(diff / PERF_CNT)
+
+    def get(self, key):
+        if key not in self.times:
+            return 0
+
+        return sum(self.times[key]) / len(self.times[key])
+
+    def print(self, units="s"):
+        for key in self.times:
+            average = self.get(key)
+            if units == "s":
+                pass
+            elif units == "ms":
+                average *= 1000
+            elif units == "us":
+                average *= 1000000
+            elif units == "ns":
+                average *= 1000000000
+            else:
+                raise ValueError(f"Invalid units: {units}")
+            print(f"{key}: {average:.3f}{units}")
+
+
+profiler = Profiler()
+
+
+### Turn flags on/off ###
+def enable_memory_reports():
+    """
+    Enables generating reports of memory allocation statistics in .reports/tt_metal dir
+    """
+    return ttnn.device.EnableMemoryReports()
+
+
+def disable_memory_reports():
+    """
+    Disables generating reports of memory allocation statistics
+    """
+    return ttnn.device.DisableMemoryReports()
+
+
+### Tensor conversion ###
+def torch2tt_tensor(
+    py_tensor: torch.Tensor,
+    tt_device,
+    tt_layout=ttnn.TILE_LAYOUT,
+    tt_memory_config=ttnn.MemoryConfig(ttnn.TensorMemoryLayout.INTERLEAVED),
+    tt_dtype=ttnn.bfloat16,
+):
+    size = list(py_tensor.size())
+
+    while len(size) < 4:
+        size.insert(0, 1)
+
+    tt_tensor = ttnn.Tensor(py_tensor.reshape(size), tt_dtype)
+    tt_tensor = tt_tensor.to(tt_layout)
+
+    if tt_device is not None:
+        tt_tensor = tt_tensor.to(tt_device, tt_memory_config)
+    else:
+        tt_tensor = tt_tensor.cpu()
+
+    return tt_tensor
+
+
+def tt_tensors_to_torch_tensors(
+    tt_tensors_device: ttnn.Tensor, mesh_device: Union[ttnn.MeshDevice, ttnn.Device], concat_dim: int = 0
+):
+    # Convert tensors to interleaved
+    if tt_tensors_device.is_sharded():
+        tt_tensors_device = ttnn.sharded_to_interleaved(tt_tensors_device)
+
+    # Convert tensors to RM layout
+    if tt_tensors_device.layout == ttnn.TILE_LAYOUT:
+        # Convert to bfloat16 to ensure untilize works
+        if tt_tensors_device.dtype != ttnn.bfloat16:
+            tt_tensors_device = ttnn.clone(
+                tt_tensors_device, dtype=ttnn.bfloat16, memory_config=ttnn.DRAM_MEMORY_CONFIG
+            )
+        # Untilize using singlecore since multicore version runs out of l1 memory (Issue #9022)
+        tt_tensors_device = ttnn.untilize(tt_tensors_device, use_multicore=False)
+
+    return torch.cat([t.to_torch() for t in ttnn.get_device_tensors(tt_tensors_device.cpu())], dim=concat_dim)
+
+
+def tt2torch_tensor(tt_tensor):
+    tt_output = tt_tensor.cpu()
+    if tt_output.get_layout() != ttnn.ROW_MAJOR_LAYOUT:
+        tt_output = tt_output.to(ttnn.ROW_MAJOR_LAYOUT)
+    return tt_output.to_torch()
+
+
+def tt_to_torch_tensor(tt_tensor):
+    tt_output = tt_tensor.cpu().to(ttnn.ROW_MAJOR_LAYOUT)
+    return tt_output.to_torch()
+
+
+def torch_to_tt_tensor_rm(py_tensor, device, shape=None, put_on_device=True):
+    if shape is None:
+        shape = list(py_tensor.size())
+        while len(shape) < 4:
+            shape.insert(0, 1)
+
+    tt_tensor = ttnn.Tensor(py_tensor.reshape(shape), ttnn.bfloat16)
+    if put_on_device:
+        tt_tensor = tt_tensor.to(device)
+    return tt_tensor
+
+
+def torch_to_tt_tensor(py_tensor, device):
+    shape = list(py_tensor.size())
+    while len(shape) < 4:
+        shape.insert(0, 1)
+
+    tt_tensor = (
+        ttnn.Tensor(py_tensor.reshape(shape), ttnn.bfloat16)
+        .to(
+            ttnn.TILE_LAYOUT
+        )  # change memory layout of TT Tensor to TILE (as operation that will use it expects TILE layout)
+        .to(device)  # move TT Tensor from host to TT accelerator device (device is of type ttnn.device.Device)
+    )
+
+    return tt_tensor
+
+
+def unpad_from_zero(x, desired_shape):
+    if x.padded_shape[-1] == desired_shape[-1] and x.padded_shape[-2] == desired_shape[-2]:
+        x = tt2torch_tensor(x)
+    else:
+        x = x.cpu()
+        if x.get_layout() != ttnn.ROW_MAJOR_LAYOUT:
+            x = x.to(ttnn.ROW_MAJOR_LAYOUT)
+        x = x.unpad(
+            (0, 0, 0, 0),
+            (
+                desired_shape[0],
+                desired_shape[1],
+                desired_shape[2],
+                desired_shape[3],
+            ),
+        )
+
+        x = x.to_torch()
+    return x
+
+
+def pad_activation(x):
+    """
+    This function pads an activation with 0s as a pre-preprocessing step to tilization.
+
+    In the 2d case, it pads a vector to the right with 0s, and in the 2+d case,
+    it pads the bottom and right corners of the last two dimensions.
+
+    :param x: Input PyTorch Tensor
+    :type x: class:`torch.Tensor`
+
+    WARNING: This function should eventually be retired in favour of padding on device
+    """
+    nearest_32 = _nearest_32
+
+    assert isinstance(x, torch.Tensor), "Input to this function must be an instance of torch.Tensor"
+    assert len(x.shape) >= 1 and len(x.shape) <= 4, "Only tensors with dimension 1-4 supported"
+    if len(x.shape) == 1:  # (num_features,)
+        padded_tensor = torch.zeros(1, 1, 32, nearest_32(x.shape[0]))
+        padded_tensor[:, 0, 0, : x.shape[0]] = x
+    elif len(x.shape) == 2:  # (batch, num features)
+        padded_tensor = torch.zeros(x.shape[0], 1, 32, nearest_32(x.shape[1]))
+        padded_tensor[:, 0, 0, : x.shape[1]] = x
+    elif len(x.shape) == 3:  # (batch, num features y, num features x)
+        padded_tensor = torch.zeros(x.shape[0], 1, nearest_32(x.shape[-2]), nearest_32(x.shape[-1]))
+        padded_tensor[..., 0, : x.shape[-2], : x.shape[-1]] = x
+    else:  # (batch, num channels, num features y, num features x)
+        padded_tensor = torch.zeros(*x.shape[:-2], nearest_32(x.shape[-2]), nearest_32(x.shape[-1]))
+        padded_tensor[..., : x.shape[-2], : x.shape[-1]] = x
+    return padded_tensor
+
+
+def pad_weight(x):
+    """
+    This function pads a weight/bias with 0s as a pre-preprocessing step to tilization.
+
+    tt_tensor = ttnn.Tensor(
+        py_tensor.reshape(shape), ttnn.bfloat16
+    In the 2d case, it pads a vector to the right with 0s, and in the 2+d case,
+    it pads the bottom and right corners of the last two dimensions.
+
+    :param x: Input PyTorch Tensor
+    :type x: class:`torch.Tensor`
+
+    WARNING: This function should eventually be retired in favour of padding on device
+    """
+    nearest_32 = _nearest_32
+
+    assert isinstance(x, torch.Tensor), "Input to this function must be an instance of torch.Tensor"
+    assert len(x.shape) >= 1 and len(x.shape) <= 4, "Only tensors with dimension 1-4 supported"
+
+    if len(x.shape) == 1:  # (num_features,)
+        padded_tensor = torch.zeros(1, 1, 32, nearest_32(x.shape[0]))
+        padded_tensor[:, 0, 0, : x.shape[0]] = x
+    elif len(x.shape) == 2:  # (r_features, c_features)
+        padded_tensor = torch.zeros(1, 1, nearest_32(x.shape[0]), nearest_32(x.shape[1]))
+        padded_tensor[:, 0, : x.shape[0], : x.shape[1]] = x
+    else:
+        padded_tensor = torch.zeros(*x.shape[:-2], nearest_32(x.shape[-2]), nearest_32(x.shape[-1]))
+        padded_tensor[..., : x.shape[-2], : x.shape[-1]] = x
+
+    return padded_tensor
+
+
+def convert_weights_2d_matrix(weights, w_shape):
+    """
+    :param weights: Input PyTorch Tensor
+    :type weights: class:`torch.Tensor`
+    """
+    ret_shape = [1, 1, w_shape[0], w_shape[1] * w_shape[2] * w_shape[3]]
+    if isinstance(weights, torch.Tensor):
+        ret = torch.zeros(np.prod(ret_shape))
+    else:
+        ret = np.zeros(np.prod(ret_shape))
+    idx = 0
+    for k in range(w_shape[0]):
+        for r in range(w_shape[2]):
+            for s in range(w_shape[3]):
+                for c in range(w_shape[1]):
+                    ret[idx] = weights[k][c][r][s]
+                    idx += 1
+    assert idx == np.prod(ret_shape)
+    return ret.reshape(ret_shape).transpose(2, 3)
+
+
+def convert_act_2d_matrix(activation, kernel_y, kernel_x, stride_y, stride_x, pad_y, pad_x):
+    """
+    :param activation: Input PyTorch Tensor
+    :type activation: class:`torch.Tensor`
+    """
+    N = activation.shape[0]
+    C = activation.shape[1]
+    H = activation.shape[2]
+    W = activation.shape[3]
+
+    OH = (int)((H - kernel_y + 2 * pad_y) // stride_y) + 1
+    OW = ((W - kernel_x + 2 * pad_x) // stride_x) + 1
+    nrows = OH * OW
+    ncols = C * kernel_x * kernel_y
+    ret_shape = [1, N, nrows, ncols]
+    if isinstance(activation, torch.Tensor):
+        ret = torch.zeros(np.prod(ret_shape))
+    else:
+        ret = np.zeros(np.prod(ret_shape))
+    idx = 0
+    for n in range(N):
+        for h in range(-1 * pad_y, H + pad_y - kernel_y + 1, stride_y):
+            for w in range(-1 * pad_x, W + pad_x - kernel_x + 1, stride_x):
+                for r in range(kernel_y):
+                    for s in range(kernel_x):
+                        for c in range(C):
+                            h_offs = h + r
+                            w_offs = w + s
+                            pad = h_offs < 0 or h_offs >= H or w_offs < 0 or w_offs >= W
+                            ret[idx] = 0 if pad else activation[n][c][h_offs][w_offs]
+                            idx += 1
+    assert idx == np.prod(ret_shape)
+    return ret.reshape(ret_shape)
+
+
+### Tilizing / Untilizing ###
+@deprecated("PyTorch data is handled automatically in tensor infra. This function does nothing now:")
+def tilize(x):
+    return x
+
+
+@deprecated("PyTorch data is handled automatically in tensor infra. This function does nothing now:")
+def tilize_to_list(x):
+    """
+    Returns a flattened list of the tensor
+    """
+    return tilize(x).reshape(-1).tolist()
+
+
+@deprecated("PyTorch data is handled automatically in tensor infra. This function does nothing now:")
+def untilize(x):
+    return x
+
+
+### Measuring accuracy and other metrics ###
+def is_close(a, b, rtol=1e-2, atol=1e-2, max_mag=2.0, max_mag_fraction=0.02):
+    """
+    A variant of np.isclose with logging.
+    """
+    absdiff = (a - b).abs()
+    reldiff1 = (a.abs() / b.abs()) - 1.0
+    reldiff2 = (a.abs() + 1.0) / (b.abs() + 1.0) - 1.0  # in case b.abs() is 0
+    reldiff_or = torch.logical_or(reldiff1.abs() < rtol, reldiff2.abs() < rtol)
+    max_mag_ok = absdiff < max_mag * max_mag_fraction
+
+    or_abs_rel = torch.logical_or(absdiff < atol, reldiff_or)
+    or_abs_rel = torch.logical_or(or_abs_rel, max_mag_ok)
+    debug_index = or_abs_rel.to(torch.int32).argmin().item()
+
+    if not or_abs_rel.reshape(-1)[debug_index]:
+        logger.info(f"isclose mismatch at index={debug_index}")
+        logger.info(a.reshape(-1)[debug_index])
+        logger.info(b.reshape(-1)[debug_index])
+        logger.info(f"reldiff1={reldiff1.reshape(-1)[debug_index]}")
+        logger.info(f"reldiff2={reldiff2.reshape(-1)[debug_index]}")
+        logger.info(f"absdiff={absdiff.reshape(-1)[debug_index]}")
+
+        HT = a.shape[-2] // 32
+        WT = a.shape[-1] // 32
+        hwt = debug_index // 1024
+        wt = hwt % WT
+        ht = hwt // WT
+        h = (debug_index % 1024) // 32
+        w = (debug_index % 1024) % 32
+
+        logger.info(f"****    at {debug_index} --- HTWT={ht} {wt} HW={h} {w}")
+
+    return torch.all(or_abs_rel)
+
+
+def _comp_nonfinite(golden, calculated):
+    """
+    Returns True if tensors contain the same non-finite values (nan, inf, -inf) at the same positions. Also returns True if all elements are finite.
+    Returns False if non-finite values differ between both tensors.
+    """
+
+    # torch.equal(['nan'], ['nan']] => False
+    # For this reason, we check for nan and inf separately
+    if torch.not_equal(torch.isnan(golden), torch.isnan(calculated)).any():
+        return False
+
+    golden_inf_mask = torch.isinf(golden)
+    calculated_inf_mask = torch.isinf(calculated)
+
+    if torch.not_equal(golden_inf_mask, calculated_inf_mask).any():
+        return False
+
+    golden_inf = golden[golden_inf_mask]
+    calculated_inf = calculated[calculated_inf_mask]
+    return torch.equal(golden_inf, calculated_inf)
+
+
+def comp_allclose(golden, calculated, rtol=1e-05, atol=1e-08):
+    if golden.dtype != calculated.dtype:
+        calculated = calculated.type(golden.dtype)
+
+    atol_delta = torch.max(torch.abs(golden - calculated)).item()
+    rtol_delta = torch.max(torch.abs(golden - calculated) / torch.abs(calculated)).item()
+    return (
+        torch.allclose(golden, calculated, rtol, atol, True),
+        f"Max ATOL Delta: {atol_delta}, Max RTOL Delta: {rtol_delta}",
+    )
+
+
+def comp_pcc(golden, calculated, pcc=0.99, rtol=1e-05, atol=1e-04):
+    golden = torch.Tensor(golden)
+    calculated = torch.Tensor(calculated)
+
+    if golden.dtype != calculated.dtype:
+        calculated = calculated.type(golden.dtype)
+
+    if torch.all(torch.isnan(golden)) and torch.all(torch.isnan(calculated)):
+        logger.warning("Both tensors are 'nan'")
+        return True, 1.0
+
+    if torch.all(torch.isnan(golden)) or torch.all(torch.isnan(calculated)):
+        logger.error("One tensor is all nan, the other is not.")
+        return False, 0.0
+
+    # Test if either is completely zero — but a zero tensor is also a constant tensor,
+    # so fall back to allclose instead of a hard 0.0: zero-vs-small-constant may be
+    # within the caller's tolerances.
+    if torch.any(golden.bool()) != torch.any(calculated.bool()):
+        logger.warning("One tensor is all zero. PCC undefined; falling back to allclose.")
+        result = torch.allclose(golden, calculated, rtol=rtol, atol=atol)
+        return result, float(result)
+
+    golden = torch.squeeze(golden).flatten()
+    calculated = torch.squeeze(calculated).flatten()
+
+    # For now, mask all infs and nans (to zero) so that we check the rest... TODO
+    # Skip this for integer types which don't have NaN/Inf values.
+    if golden.dtype.is_floating_point:
+        # FP8 doesn't support isfinite/nan_to_num and bfloat16 products lose precision,
+        # so correlate these in float32.
+        if golden.dtype in (torch.float8_e4m3fn, torch.float8_e5m2, torch.bfloat16):
+            golden = golden.to(torch.float32)
+            calculated = calculated.to(torch.float32)
+
+        # Zero out NaN/Inf, preserving the historical PCC values. nan_to_num allocates a
+        # full-size copy of each tensor, so only do it when invalid values are actually
+        # present; on the common all-finite path the tensors stay as views and no copy is
+        # made (this short-circuit is what keeps peak memory near 1x of one input).
+        if not bool((torch.isfinite(golden) & torch.isfinite(calculated)).all()):
+            golden = torch.nan_to_num(golden, nan=0.0, posinf=0.0, neginf=0.0)
+            calculated = torch.nan_to_num(calculated, nan=0.0, posinf=0.0, neginf=0.0)
+
+    if torch.equal(golden, calculated):
+        return True, 1.0
+
+    # Integer tensors must be correlated in floating point (centering/products would
+    # otherwise truncate/overflow). float32 keeps the working set small.
+    if not golden.dtype.is_floating_point:
+        golden = golden.to(torch.float32)
+        calculated = calculated.to(torch.float32)
+
+    # Pearson r with float64 *accumulation* (dtype= on the reductions) over the float32
+    # data: no float64 copy of either tensor is materialized, so peak memory stays near
+    # 1x of one input on large tensors while matching a full-float64 correlation to
+    # |Δ|<1e-9 across the high-PCC (>=0.999) range.
+    n = golden.numel()
+    g_centered = golden - (golden.sum(dtype=torch.float64) / n).to(golden.dtype)
+    c_centered = calculated - (calculated.sum(dtype=torch.float64) / n).to(calculated.dtype)
+    cov = (g_centered * c_centered).sum(dtype=torch.float64)
+    g_sq_sum = g_centered.pow(2).sum(dtype=torch.float64)
+    c_sq_sum = c_centered.pow(2).sum(dtype=torch.float64)
+    denom = torch.sqrt(g_sq_sum * c_sq_sum)
+    # pow/sum stay in float32 before the reduction; large-magnitude tensors (e.g. ldexp)
+    # can overflow to inf here even though float64 accumulation would be finite.
+    if not math.isfinite(denom.item()) or not math.isfinite(cov.item()):
+        g_centered64 = g_centered.to(torch.float64)
+        c_centered64 = c_centered.to(torch.float64)
+        cov = (g_centered64 * c_centered64).sum()
+        denom = torch.sqrt(g_centered64.pow(2).sum() * c_centered64.pow(2).sum())
+    cal_pcc = (cov / denom).item()
+
+    # Zero variance -> denom == 0 -> cal_pcc is nan: PCC is undefined for constant tensors.
+    # Fall back to allclose rather than returning a misleading 1.0.
+    if math.isnan(cal_pcc):
+        logger.warning("PCC is NaN (zero variance / constant tensor). Falling back to allclose check.")
+        result = torch.allclose(golden, calculated, rtol=rtol, atol=atol)
+        return result, float(result)
+
+    return cal_pcc >= pcc, cal_pcc
+
+
+def ulp(x: Union[ttnn.Tensor, torch.Tensor]) -> Union[ttnn.Tensor, torch.Tensor]:
+    "Return Unit of Least Precision for each element of a given tensor"
+
+    received_ttnn_input = False
+    if isinstance(x, ttnn.Tensor):
+        x = ttnn.to_torch(x)
+        received_ttnn_input = True
+
+    # Notes:
+    # - This should be identical to the definition of ULP by Goldberg
+    #   "What every computer scientist should know about floating-point arithmetic"
+    #   https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+    # - We use torch.abs(x) to ensure symmetry ULP(-x) == ULP(x)
+    # - For x powers of 2, x + ULP(x) is not closest number but second closest (previous number is 2x closer)
+    #   However, this avoids rounding-to-nearest-tie-to-even issues on addition (i.e. x + ULP(x) != x)
+    abs_x = torch.abs(x)
+    next = torch.nextafter(
+        abs_x, torch.tensor(math.inf, dtype=x.dtype)
+    )  # 1 ULP ~ Difference between two consecutive floating point numbers
+    ulp_value = next - abs_x
+
+    # Special case: if abs_x == torch.finfo(x.dtype).max, then next == math.inf, which leads to ULP(x) == inf rather than finite number
+    # We fix this problem by manually calculating ULP at max value, and masking tensor when input == max
+    dtype_max = torch.finfo(x.dtype).max
+    max_epsilon = dtype_max - torch.nextafter(
+        torch.tensor(dtype_max, dtype=x.dtype), torch.tensor(-math.inf, dtype=x.dtype)
+    )
+    ulp_value = torch.where(abs_x == dtype_max, max_epsilon, ulp_value)
+
+    if received_ttnn_input:  # Ensures that type(input) == type(output)
+        ulp_value = ttnn.from_torch(ulp_value)
+
+    return ulp_value
+
+
+def comp_ulp(golden, calculated, ulp_threshold, allow_nonfinite=False):
+    """
+    Compute absolute error between two tensors in Units of Least Precision (ULP)
+    """
+
+    # If both tensors are empty, then we can return True
+    if torch.numel(golden) == 0 and torch.numel(calculated) == 0:
+        return True, "Both tensors are empty"
+
+    if not allow_nonfinite and not torch.all(torch.isfinite(calculated)):
+        return False, "Calculated tensor contains non-finite values"
+
+    if not _comp_nonfinite(golden, calculated):
+        return False, "Tensors are not finite at the same positions"
+    # nonfinite elements can interfere with ULP error calculation
+    # To avoid this, replace nan, +inf, -inf with 0
+    # (we have already checked that both tensors have the same nonfinite elements)
+    mask_finite = ~torch.isfinite(golden)
+    golden = golden.clone()
+    calculated = calculated.clone()
+    golden[mask_finite] = 0
+    calculated[mask_finite] = 0
+
+    # ULP is measured according to the golden tensor
+    # In most cases, data type of golden tensor should be the same as calculated tensor.
+    # However, in some cases, we may want to measure < 1 ULP differences, which requires golden tensor
+    # to have higher precision than calculated tensor.
+    # If we passed golden tensor to ulp() as is, we would get ULP of higher precision.
+    # e.g. ulp of float32 rather bfloat16 calculation, which would give us a wrong value.
+    ulp_value = ulp(golden.type(calculated.dtype))
+
+    if golden.dtype != calculated.dtype:  # Note: assumes that golden has higher precision than calculated tensor
+        calculated = calculated.type(golden.dtype)
+        ulp_value = ulp_value.type(golden.dtype)  # Convert ULP to higher precision (for sub-1 ULP measurements)
+
+    ulp_tensor = torch.abs(calculated - golden) / ulp_value
+    ulp_delta = torch.max(ulp_tensor)
+    within_threshold = ulp_delta <= ulp_threshold
+    message = f"Max ULP Delta: {ulp_delta}"
+    if not within_threshold:
+        ulp_index = torch.argmax(ulp_tensor)
+        ulp_index_tuple = tuple(int(idx) for idx in torch.unravel_index(ulp_index, golden.shape))
+        message += (
+            f" @ {list(ulp_index_tuple)} = "
+            f"|calculated {calculated[ulp_index_tuple]} - golden {golden[ulp_index_tuple]}| "
+            f"/ ULP(golden) {ulp_value[ulp_index_tuple]}"
+        )
+    return (within_threshold, message)
+
+
+def calculate_detailed_ulp_stats(expected, actual):
+    """
+    Calculate detailed ULP statistics for analysis.
+
+    Returns:
+        dict: Dictionary with ULP statistics including max, mean, std, and percentiles
+    """
+    if isinstance(actual, ttnn.Tensor):
+        actual = ttnn.to_torch(actual)
+    if isinstance(expected, ttnn.Tensor):
+        expected = ttnn.to_torch(expected)
+
+    # Convert to bfloat16 if not already
+    expected = expected.to(torch.bfloat16)
+    actual = actual.to(torch.bfloat16)
+
+    # Handle special cases
+    if torch.allclose(expected, actual, rtol=0, atol=0, equal_nan=True):
+        return {
+            "max_ulp": 0.0,
+            "mean_ulp": 0.0,
+            "median_ulp": 0.0,
+            "std_ulp": 0.0,
+            "p95_ulp": 0.0,
+            "p99_ulp": 0.0,
+            "perfect_matches": 1.0,
+        }
+
+    # Convert bfloat16 to uint16 representation for bit manipulation
+    expected_bits = expected.view(torch.int16).to(torch.int32)
+    actual_bits = actual.view(torch.int16).to(torch.int32)
+
+    # Handle sign differences
+    expected_sign = expected_bits < 0
+    actual_sign = actual_bits < 0
+    same_sign = expected_sign == actual_sign
+
+    # Calculate ULP differences
+    expected_abs_bits = torch.where(expected_sign, -expected_bits, expected_bits)
+    actual_abs_bits = torch.where(actual_sign, -actual_bits, actual_bits)
+
+    ulp_diff = torch.where(same_sign, torch.abs(expected_bits - actual_bits), expected_abs_bits + actual_abs_bits)
+
+    # Handle non-finite values
+    expected_finite = torch.isfinite(expected)
+    actual_finite = torch.isfinite(actual)
+    both_finite = expected_finite & actual_finite
+
+    ulp_diff = torch.where(both_finite, ulp_diff, torch.tensor(float("inf")))
+
+    # Handle same non-finite values
+    both_nan = torch.isnan(expected) & torch.isnan(actual)
+    both_posinf = torch.isposinf(expected) & torch.isposinf(actual)
+    both_neginf = torch.isneginf(expected) & torch.isneginf(actual)
+    same_nonfinite = both_nan | both_posinf | both_neginf
+
+    ulp_diff = torch.where(same_nonfinite, torch.tensor(0.0), ulp_diff)
+
+    # Calculate statistics only on finite ULP differences
+    finite_ulp = ulp_diff[torch.isfinite(ulp_diff)]
+
+    if len(finite_ulp) == 0:
+        return {
+            "max_ulp": float("inf"),
+            "mean_ulp": float("inf"),
+            "median_ulp": float("inf"),
+            "std_ulp": float("inf"),
+            "p95_ulp": float("inf"),
+            "p99_ulp": float("inf"),
+            "perfect_matches": 0.0,
+        }
+
+    finite_ulp_float = finite_ulp.float()
+    perfect_matches = (finite_ulp == 0).float().mean().item()
+
+    return {
+        "max_ulp": torch.max(finite_ulp).item(),
+        "mean_ulp": torch.mean(finite_ulp_float).item(),
+        "median_ulp": torch.median(finite_ulp_float).item(),
+        "std_ulp": torch.std(finite_ulp_float).item(),
+        "p95_ulp": torch.quantile(finite_ulp_float, 0.95).item(),
+        "p99_ulp": torch.quantile(finite_ulp_float, 0.99).item(),
+        "perfect_matches": perfect_matches,
+    }
+
+
+def comp_allclose_and_pcc(golden, calculated, rtol=1e-05, atol=1e-08, pcc=0.99):
+    # 0-volume tensors are special because they don't have elements, so we can't compute PCC, etc.
+    # If one of the tensors is a 0-volume tensor, simply call torch.equal to check if they are equal
+    # (i.e. that both are 0-volume tensors and they have equal shapes).
+    if golden.numel() == 0 or calculated.numel() == 0:
+        return torch.equal(golden, calculated), f"{golden} != {calculated}"
+
+    if golden.dtype != calculated.dtype:
+        calculated = calculated.type(golden.dtype)
+
+    passing = True
+    output = ""
+    passing_allclose, output_allclose = comp_allclose(golden, calculated, rtol, atol)
+    passing &= passing_allclose
+    output += output_allclose
+    if torch.numel(golden) != 1:
+        passing_pcc, output_pcc = comp_pcc(golden, calculated, pcc, rtol=rtol, atol=atol)
+        passing &= passing_pcc
+        output += f", pcc={output_pcc}"
+
+    return passing, output
+
+
+def comp_equal(golden, calculated):
+    if golden.dtype != calculated.dtype:
+        calculated = calculated.type(golden.dtype)
+
+    # If either tensor is zero-volume, broadcasting can still yield an empty delta and
+    # crash torch.max(); defer entirely to torch.equal (False on shape mismatch).
+    if golden.numel() == 0 or calculated.numel() == 0:
+        return torch.equal(golden, calculated), f"{golden} != {calculated}"
+
+    atol_delta = torch.max(torch.abs(golden - calculated)).item()
+    rtol_delta = torch.max(torch.abs(golden - calculated) / torch.abs(calculated)).item()
+    return (
+        torch.equal(golden, calculated),
+        f"Max ATOL Delta: {atol_delta}, Max RTOL Delta: {rtol_delta}",
+    )
+
+
+def get_oom_of_float(float_lst):
+    """
+    Given a list of floats, returns a list of the order or magnitudes
+    of the floats. Useful when you want to make sure that even if your
+    tt outputs don't match pytorch all that well, they are at least
+    on the same order of magnitude
+    """
+    ooms = []
+    for el in float_lst:
+        str_el = str(el)
+        if "e" in str_el:
+            oom = int(str_el.split("e")[1])
+        elif str_el[:2] == "0.":
+            str_el = str_el.split(".")[1]
+
+            oom = -1
+            for e in str_el:
+                if e != "0":
+                    break
+                oom -= 1
+        else:
+            oom = len(str_el.split(".")[0])
+
+        ooms.append(oom)
+
+    return ooms
+
+
+def print_diff_argmax(a, b, annotation=""):
+    """
+    Prints out the value of both tensors at a point where the absolute difference is the largest.
+    """
+    absdiff = (a - b).abs()
+    argmax = absdiff.argmax().item()
+    diff = absdiff.reshape(-1)[argmax]
+    rela = a.abs() / (torch.max(a.abs(), b.abs()))
+    relb = b.abs() / (torch.max(a.abs(), b.abs()))
+    HT = a.shape[-2] // 32
+    WT = a.shape[-1] // 32
+    hwt = argmax // 1024
+    wt = hwt % WT
+    ht = hwt // WT
+    h = (argmax % 1024) // 32
+    w = (argmax % 1024) % 32
+    print(
+        "Abs diff=",
+        diff,
+        " at ",
+        argmax,
+        " --- ",
+        annotation,
+        "HTWT=",
+        ht,
+        wt,
+        "HW=",
+        h,
+        w,
+    )
+    print("  (a=", a.reshape(-1)[argmax].item(), ")")
+    print("  (b=", b.reshape(-1)[argmax].item(), ")")
+    print("  Rel a=", rela.reshape(-1)[argmax], " at ", argmax)
+    print("  Rel b=", relb.reshape(-1)[argmax], " at ", argmax)
+    return diff.item()
+
+
+def print_diff_tt_pyt(a, b, annotation=""):
+    # first convert a pytorch tensor argument b to tt
+    padded_b = pad_weight(b)
+    pyt_a = tt2torch(a)  # untilizes also
+    return print_diff_argmax(pyt_a, padded_b, annotation)
+
+
+def ttP(x, count=4, offset=0, stride=1):
+    if type(x) == torch.Tensor:
+        t1 = x.reshape(-1)
+    else:
+        tt_out = x.cpu()
+        torch_out = untilize(tt_out.to_torch())
+        t1 = torch_out.reshape(-1)
+    print("Tensor vals: (", end="")
+    for j in range(offset, offset + count * stride, stride):
+        print(t1[j].item(), " ", end="")
+    print(")")
+
+
+### Conv related helpers ###
+def read_conv_act_into_mm_act_block(
+    conv_act,
+    act_address_map_index,
+    address_map,
+    address_map_this_block_size,
+    act_block_h,
+    act_block_w,
+):
+    mm_act_block_shape = [1, 1, act_block_h * 32, act_block_w * 32]
+    mm_act_block_size = act_block_h * act_block_w * 1024
+    mm_act_block = torch.zeros(mm_act_block_size, dtype=torch.bfloat16).float()
+    for i in range(0, address_map_this_block_size, 4):
+        src_address = address_map[act_address_map_index]
+        dst_address = address_map[act_address_map_index + 1]
+        read_size = address_map[act_address_map_index + 2]
+        pad = address_map[act_address_map_index + 3]
+        for s in range(read_size):
+            assert dst_address + s < mm_act_block_size
+            if pad:
+                mm_act_block[dst_address + s] = 0
+            else:
+                assert src_address + s < len(conv_act)
+                mm_act_block[dst_address + s] = conv_act[src_address + s]
+        act_address_map_index += 4
+    return (mm_act_block.reshape(mm_act_block_shape), act_address_map_index)
+
+
+def read_conv_weight_into_mm_weight_block(
+    conv_weight,
+    weight_address_map_index,
+    weight_address_map,
+    weight_address_map_this_block_size,
+    weight_block_h,
+    weight_block_w,
+):
+    mm_weight_block_shape = [1, 1, weight_block_h * 32, weight_block_w * 32]
+    mm_weight_block_size = weight_block_h * weight_block_w * 1024
+    mm_weight_block = torch.zeros(mm_weight_block_size, dtype=torch.bfloat16).float()
+    for i in range(0, weight_address_map_this_block_size, 4):
+        src_address = weight_address_map[weight_address_map_index]
+        dst_address = weight_address_map[weight_address_map_index + 1]
+        read_size = weight_address_map[weight_address_map_index + 2]
+        pad = weight_address_map[weight_address_map_index + 3]
+        for s in range(read_size):
+            assert dst_address + s < mm_weight_block_size
+            if pad:
+                mm_weight_block[dst_address + s] = 0
+            else:
+                assert src_address + s < len(conv_weight)
+                mm_weight_block[dst_address + s] = conv_weight[src_address + s]
+        weight_address_map_index += 4
+    return (mm_weight_block.reshape(mm_weight_block_shape), weight_address_map_index)
+
+
+def blocked_mm_with_conv_act(
+    conv_act,
+    mm_weight,
+    act_address_map,
+    weight_address_map,
+    num_blocks_act_h,
+    num_blocks_act_w,
+    num_blocks_weight_w,
+    act_block_h,
+    act_block_w,
+    weight_block_w,
+):
+    # act refers to conv activation tensor
+    # weight refers to conv weight tensor
+    mm_output_shape = [
+        1,
+        1,
+        num_blocks_act_h * act_block_h * 32,
+        num_blocks_weight_w * weight_block_w * 32,
+    ]
+    ret = torch.zeros(mm_output_shape, dtype=torch.bfloat16).float()
+    mm_output_block_shape = [1, 1, act_block_h * 32, weight_block_w * 32]
+    act_address_map_index = 0
+    weight_address_map_index = 0
+    weight_block_h = act_block_w
+    num_groups = act_address_map[act_address_map_index]
+    assert num_groups == num_blocks_act_h * num_blocks_act_w * num_blocks_weight_w
+    weight_num_groups = act_address_map[weight_address_map_index]
+    assert weight_num_groups == num_groups
+    act_address_map_index += 1
+    weight_address_map_index += 1
+    for block_act_h in range(num_blocks_act_h):
+        # Reset weight (weight) to the starting tile in this column
+        for block_weight_w in range(num_blocks_weight_w):
+            output_block = torch.zeros(mm_output_block_shape, dtype=torch.bfloat16).float()
+            for block_act_w in range(num_blocks_act_w):
+                address_map_this_block_size = act_address_map[act_address_map_index]
+                act_address_map_index += 1
+                weight_address_map_this_block_size = weight_address_map[weight_address_map_index]
+                weight_address_map_index += 1
+                (mm_act_block, act_address_map_index) = read_conv_act_into_mm_act_block(
+                    conv_act,
+                    act_address_map_index,
+                    act_address_map,
+                    address_map_this_block_size,
+                    act_block_h,
+                    act_block_w,
+                )
+                (
+                    mm_weight_block,
+                    weight_address_map_index,
+                ) = read_conv_weight_into_mm_weight_block(
+                    mm_weight,
+                    weight_address_map_index,
+                    weight_address_map,
+                    weight_address_map_this_block_size,
+                    weight_block_h,
+                    weight_block_w,
+                )
+                # Untilize weight block (this CPU reference does matmul on untilized blocks)
+                mm_weight_block = untilize(mm_weight_block)
+                for out_h_block in range(act_block_h * 32):
+                    for out_w_block in range(weight_block_w * 32):
+                        output_block[0][0][out_h_block][out_w_block] += torch.dot(
+                            mm_act_block[0, 0, out_h_block, :].reshape(-1),
+                            mm_weight_block[0, 0, :, out_w_block].reshape(-1),
+                        )
+            start_oh = block_act_h * act_block_h * 32
+            start_ow = block_weight_w * weight_block_w * 32
+            end_oh = start_oh + (act_block_h * 32)
+            end_ow = start_ow + (weight_block_w * 32)
+            ret[0, 0, start_oh:end_oh, start_ow:end_ow] = output_block
+
+    return ret
+
+
+def is_conv_supported_on_device(conv_params):
+    K, C, R, S, U, V, P_H, P_W, dilation, groups = [conv_params[i] for i in range(10)]
+
+    if K % 32 != 0 or dilation != 1 or groups != 1:
+        logger.warning("DOES NOT HAVE SUPPORT FOR Conv with following parameters -")
+        logger.warning(
+            "K="
+            + str(K)
+            + " C="
+            + str(C)
+            + " R="
+            + str(R)
+            + " S="
+            + str(S)
+            + " U="
+            + str(U)
+            + " V="
+            + str(V)
+            + " PH="
+            + str(P_H)
+            + " PW="
+            + str(P_W)
+            + " dilation="
+            + str(dilation)
+            + " groups="
+            + str(groups)
+        )
+        return False
+
+    return True
+
+
+def is_x2_harvested(device):
+    grid = device.compute_with_storage_grid_size()
+    return device.arch() == Arch.WORMHOLE_B0 and (grid.x, grid.y) == (8, 7)
+
+
+def is_single_chip():
+    return ttnn.GetNumAvailableDevices() == 1
+
+
+def is_quasar():
+    ARCH_NAME = ttnn.get_arch_name()
+    return "quasar" in ARCH_NAME
+
+
+def is_blackhole():
+    ARCH_NAME = ttnn.get_arch_name()
+    return "blackhole" in ARCH_NAME
+
+
+def is_wormhole_b0():
+    ARCH_NAME = ttnn.get_arch_name()
+    return "wormhole_b0" in ARCH_NAME
+
+
+def is_watcher_enabled():
+    watcher = os.environ.get("TT_METAL_WATCHER")
+    lightweight_asserts = os.environ.get("TT_METAL_LIGHTWEIGHT_KERNEL_ASSERTS")
+    return (watcher is not None and watcher != "") or lightweight_asserts == "1"
+
+
+def is_llk_assert_enabled():
+    llk_assert = os.environ.get("TT_METAL_LLK_ASSERTS")
+    return llk_assert == "1"
+
+
+def is_n300():
+    return os.environ.get("MESH_DEVICE", "N150") == "N300"
+
+
+def is_slow_dispatch():
+    return os.environ.get("TT_METAL_SLOW_DISPATCH_MODE") == "1"
+
+
+def ti_skip(condition, reason="Invalid test parameters"):
+    import pytest
+
+    return pytest.mark.skipif(condition, reason="Skipping unsupported case: " + reason)
+
+
+def skip_for_blackhole(reason_str="not a blackhole test"):
+    return ti_skip(is_blackhole(), reason=reason_str)
+
+
+def skip_for_wormhole_b0(reason_str="not a wormhole test"):
+    return ti_skip(is_wormhole_b0(), reason=reason_str)
+
+
+def skip_with_watcher(reason_str="Test is not passing with watcher enabled"):
+    return ti_skip(is_watcher_enabled(), reason=reason_str)
+
+
+def skip_with_llk_assert(reason_str="Test is not passing with LLK asserts enabled"):
+    return ti_skip(is_llk_assert_enabled(), reason=reason_str)
+
+
+def run_for_blackhole(reason_str="only runs for Blackhole"):
+    return ti_skip(not is_blackhole(), reason=reason_str)
+
+
+def run_for_wormhole_b0(reason_str="only runs for Wormhole B0"):
+    return ti_skip(not is_wormhole_b0(), reason=reason_str)
+
+
+def run_for_wormhole_b0_or_blackhole(reason_str="only runs for Wormhole B0 or Blackhole"):
+    return ti_skip(not (is_wormhole_b0() or is_blackhole()), reason=reason_str)
+
+
+def run_for_n_dev(n, reason_str="Test is not meant for this number of devices"):
+    return ti_skip(ttnn.get_num_devices() != n, reason=reason_str)
+
+
+def skip_for_n_dev(n, reason_str="Test is not meant for this number of devices"):
+    return ti_skip(ttnn.get_num_devices() == n, reason=reason_str)
+
+
+def skip_for_n_or_less_dev(n, reason_str="Test is not meant for this number of devices"):
+    return ti_skip(ttnn.get_num_devices() <= n, reason=reason_str)
+
+
+def skip_for_slow_dispatch(reason_str="not working for slow dispatch"):
+    return ti_skip(is_slow_dispatch(), reason=reason_str)
+
+
+def ttl_complex_2_torch_complex(tt_tensor):
+    torch_tensor = tt2torch_tensor(tt_tensor)
+
+    # extract real and imag parts of the complex tensor
+    real = torch_tensor[:, :, :, : torch_tensor.shape[-1] // 2].to(torch.bfloat16).to(torch.float)
+    imag = torch_tensor[:, :, :, torch_tensor.shape[-1] // 2 :].to(torch.bfloat16).to(torch.float)
+
+    # create torch complex tensor
+    result = torch.complex(real, imag)
+    return result
+
+
+def pad_and_fold_conv_filters_for_unity_stride(filter_pyt_nchw_tensor, stride_h, stride_w, align_c=4):
+    assert stride_h == stride_w
+    assert filter_pyt_nchw_tensor.shape[2] == filter_pyt_nchw_tensor.shape[3]
+    assert isinstance(align_c, int) and align_c > 0
+    # Fold activation for unity stride
+    # Pad channel size to align_c. This keeps L1 read addresses aligned; extra channels become
+    # zero-valued weights that contribute nothing to the convolution. align_c=4 is the WH/BH default
+    # (16B alignment for bf16 gives C a multiple of 4 with a tiled conv reader). Quasar's row-major
+    # fold needs align_c=8 (bf16 row-major shard width must be a multiple of 8) so the first conv
+    # folds to groups*8 input channels and consumes the aligned output without per-group padding strip.
+    C = _nearest_y(filter_pyt_nchw_tensor.shape[1], align_c)
+    # Pad filter to nearest stride
+    Padded_filter_height = _nearest_y(filter_pyt_nchw_tensor.shape[2], stride_h)
+    Padded_filter_width = _nearest_y(filter_pyt_nchw_tensor.shape[3], stride_w)
+    filter_pyt_padded = torch.nn.functional.pad(
+        filter_pyt_nchw_tensor,
+        (
+            0,
+            Padded_filter_width - filter_pyt_nchw_tensor.shape[3],
+            0,
+            Padded_filter_height - filter_pyt_nchw_tensor.shape[2],
+            0,
+            C - filter_pyt_nchw_tensor.shape[1],
+        ),
+    )
+    # Fold filter for unity stride.
+    filter_pyt_padded_folded = torch.zeros(
+        [
+            filter_pyt_padded.shape[0],
+            C * stride_h * stride_w,
+            (int)(filter_pyt_padded.shape[2] / stride_h),
+            (int)(filter_pyt_padded.shape[3] / stride_w),
+        ]
+    )
+    for h in range(0, filter_pyt_padded.shape[2], stride_h):
+        for w in range(0, filter_pyt_padded.shape[3], stride_w):
+            folded_h = (int)(h / stride_h)
+            folded_w = (int)(w / stride_w)
+            for i in range(4):
+                start_c = i * C
+                filter_pyt_padded_folded[:, start_c : start_c + C, folded_h, folded_w] = filter_pyt_padded[
+                    :, :, h + (int)(i / stride_w), w + (int)(i % stride_w)
+                ]
+    return filter_pyt_padded_folded
+
+
+# produces a tensor where each element in a page is the page number
+# this tensor is easy to debug and visualize
+def get_debug_tensor(num_pages_width, num_pages_height, dtype, page_width=32, page_height=32):
+    torch_tensor = None
+    for row_idx in range(0, int(num_pages_height)):
+        tile_row = None
+        for col_idx in range(0, int(num_pages_width)):
+            tile_idx = col_idx + num_pages_width * row_idx
+            tile = torch.full((1, 1, page_width, page_height), tile_idx + 1, dtype=dtype)
+            if tile_row == None:
+                tile_row = tile
+            else:
+                tile_row = torch.cat((tile_row, tile), 3)
+        if torch_tensor == None:
+            torch_tensor = tile_row
+        else:
+            torch_tensor = torch.cat((torch_tensor, tile_row), 2)
+
+    return torch_tensor
+
+
+# ── transformers 5.x Cache API compatibility ────────────────────────────────
+# transformers 5.x removed the legacy Cache API: DynamicCache no longer exposes
+# from_legacy_cache / to_legacy_cache / key_cache / value_cache (per-layer KV now
+# lives at cache.layers[i].keys/.values). These helpers work on both 4.x and 5.x.
+def hf_cache_layer_kv(cache, layer_idx):
+    """Return (key, value) tensors for a layer of a transformers Cache.
+
+    Handles the legacy tuple-of-tuples past_key_values, transformers <5 Cache
+    (key_cache/value_cache), and transformers >=5 Cache (layers[i].keys/.values).
+    """
+    if isinstance(cache, (tuple, list)):  # legacy tuple-of-tuples past_key_values
+        return cache[layer_idx][0], cache[layer_idx][1]
+    if hasattr(cache, "key_cache"):  # transformers < 5.x Cache
+        return cache.key_cache[layer_idx], cache.value_cache[layer_idx]
+    layer = cache.layers[layer_idx]  # transformers >= 5.x Cache
+    return layer.keys, layer.values
+
+
+def hf_cache_to_legacy(cache):
+    """Export a transformers Cache to the legacy tuple-of-(key, value) format."""
+    if hasattr(cache, "to_legacy_cache"):  # transformers < 5.x
+        return cache.to_legacy_cache()
+    return tuple((layer.keys, layer.values) for layer in cache.layers)  # transformers >= 5.x
+
+
+def hf_dynamic_cache_from_legacy(layer_kvs):
+    """Build a transformers DynamicCache from per-layer (key, value) tuples."""
+    from transformers import DynamicCache
+
+    layer_kvs = tuple(layer_kvs)
+    if hasattr(DynamicCache, "from_legacy_cache"):  # transformers < 5.x
+        return DynamicCache.from_legacy_cache(layer_kvs)
+    return DynamicCache(layer_kvs)  # transformers >= 5.x
+
+
+def hf_cache_num_layers(cache):
+    """Number of populated layers in a transformers Cache (version-tolerant)."""
+    return len(cache.key_cache) if hasattr(cache, "key_cache") else len(cache.layers)
+
+
+def hf_empty_encoder_decoder_cache():
+    """Create an empty transformers EncoderDecoderCache (version-tolerant)."""
+    from transformers import DynamicCache, EncoderDecoderCache
+
+    if hasattr(EncoderDecoderCache, "from_legacy_cache"):  # transformers < 5.x
+        return EncoderDecoderCache.from_legacy_cache(None)
+    return EncoderDecoderCache(DynamicCache(), DynamicCache())  # transformers >= 5.x
+
+
+def copy_to_buffer(src: "ttnn.Tensor", dst: "ttnn.Tensor", target_dtype) -> None:
+    """Convert ``src`` to ``dst``'s layout/dtype/shape/memcfg and write it into
+    ``dst``. ``dst``'s device buffer is preserved (no reallocation) so any
+    captured trace and the DRAM prefetcher's recorded buffer addresses remain
+    valid. The final ``ttnn.to_memory_config`` with ``output_tensor=dst`` both
+    reshards to ``dst``'s memory config and copies into ``dst``'s buffer.
+    """
+    converted = src
+
+    if converted.layout != dst.layout:
+        converted = ttnn.to_layout(converted, layout=dst.layout)
+
+    if converted.dtype != target_dtype:
+        converted = ttnn.typecast(converted, dtype=target_dtype)
+
+    if tuple(converted.shape) != tuple(dst.shape):
+        converted = ttnn.reshape(converted, list(dst.shape))
+
+    ttnn.to_memory_config(converted, dst.memory_config(), output_tensor=dst)

code/models/experimental/gr00t/reference/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""CPU torch reference implementations of the GR00T N1.5 / N1.6 / N1.7 components (populated by later tasks)."""

code/models/experimental/gr00t/reference/action_head.py

@@ -0,0 +1,1093 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""CPU fp32 torch reference of the GR00T N1.5 / N1.6 / N1.7 action head (VL adapter, encoders, DiT, decoder).
+
+The modules are organised the way the future device modules are (``01-architecture-synthesis.md`` §2.1 / §2.3):
+
+* :class:`VLAdapter`            ``vlln`` LayerNorm + 0 / 4 :class:`VLSelfAttentionBlock` -- once per inference (§1.4).
+* :class:`EmbodimentLinear`     one slot ``e`` of ``CategorySpecificLinear``: ``y = x @ W[e] + b[e]`` with ``W[e]`` in
+                                ``[in, out]`` orientation -- no transpose (``weight-loader-spec.md`` §4.7, arch-n15 §3.1).
+* :class:`EmbodimentMLP`        state encoder / action decoder (``layer2(relu(layer1(x)))``, §1.6).
+* :class:`ActionEncoder`        ``W1`` -> ``cat[a, tau]`` -> ``W2`` -> swish -> ``W3`` with the 1536-d sinusoid of the
+                                integer bucket (arch-n15 §3.3, arch-n16 §7.2); the position rows are added by the head.
+* :class:`TimestepEncoder`      diffusers ``Timesteps(256, flip_sin_to_cos, shift 1)`` -> Linear -> SiLU -> Linear (§1.5).
+* :class:`DiTBlock`             AdaLN (``norm1.linear.chunk(2) = (scale, shift)``, attention branch only, ungated) ->
+                                cross / self attention (32 x 48) -> plain non-affine LN -> FF 6144 GELU-tanh (§1.5, C6).
+* :class:`DiTOutputHead`        ``LN(eps 1e-6) * (1 + scale) + shift`` with ``proj_out_1.chunk(2) = (shift, scale)`` --
+                                the opposite order to the blocks -- then ``proj_out_2`` (§1.5).
+* :class:`DiT`                  the interleaved stack with the cross-attention key-set selector (``all`` for N1.5;
+                                ``idx % 4 == 0`` -> non-image, ``idx % 4 == 2`` -> image for N1.6 / N1.7; arch-n16 §7.4,
+                                arch-n17 §3.3) in the reference *mask* form and in the *gather + hoisted K/V* form.
+* :class:`ActionHead`           everything above plus position rows, N1.5 future tokens, the decoder and the tap plumbing.
+
+Weights are read from the RAW checkpoint keys through :class:`~models.experimental.gr00t.common.checkpoint.LazyCheckpoint`
+(``nn.Linear`` layout ``[out, in]`` consumed with ``F.linear``; embodiment slots ``[in, out]`` consumed with ``@``), upcast
+bf16 -> fp32 exactly.  Every ``action_head.*`` key of the checkpoint must be consumed, and every shape is checked against
+:mod:`~models.experimental.gr00t.common.configs`; nothing falls back silently.
+
+Optional head padding 48 -> 64 (``static-shape-plan`` D5, ``weight-loader-spec.md`` §4.6) is available through
+:meth:`DiT.set_head_dim_pad`; the softmax scale stays the *logical* ``48 ** -0.5`` and is always passed explicitly.
+
+No ``ttnn`` import anywhere in this module.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Set, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor, nn
+
+from models.experimental.gr00t.common.checkpoint import LazyCheckpoint
+from models.experimental.gr00t.common.configs import DiTConfig, EncoderConfig, GR00TConfig, VLAdapterConfig, get_config
+
+# "mask" = reference form (K/V over all S tokens + boolean key mask); "gather" = K/V over the selected tokens only.
+CrossForm = str
+CROSS_FORMS: Tuple[str, ...] = ("mask", "gather")
+KEY_SUBSETS: Tuple[str, ...] = ("all", "text", "image")
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Functional pieces
+# --------------------------------------------------------------------------------------------------------------------
+
+
+def gelu_tanh(x: Tensor) -> Tensor:
+    """diffusers ``FeedForward(activation_fn="gelu-approximate")`` = ``F.gelu(approximate="tanh")`` (arch-n17 §3.3)."""
+    return F.gelu(x, approximate="tanh")
+
+
+def swish(x: Tensor) -> Tensor:
+    """``swish(x) = x * sigmoid(x)`` of the action encoder (arch-n15 §3.3)."""
+    return x * torch.sigmoid(x)
+
+
+def sinusoidal_tau_encoding(t_bucket: int, dim: int = 1536, max_period: float = 10000.0) -> Tensor:
+    """1536-d sinusoid of the integer timestep bucket fed to the action encoder (arch-n15 §3.3, arch-n16 §7.2).
+
+    ``half = dim // 2``; ``exponent_i = -i * ln(max_period) / half``; ``enc = [sin(t * exp(exponent)), cos(...)]``
+    (sin first) -- computed in fp32 exactly like ``SinusoidalPositionalEncoding.forward``.  This is *not* the DiT
+    timestep projection (:func:`timestep_projection`), which has 256 channels, a ``half - 1`` divisor and cos first.
+    """
+    if dim % 2 != 0:
+        raise ValueError(f"tau dim must be even, got {dim}")
+    half = dim // 2
+    log_scale = torch.log(torch.tensor(float(max_period), dtype=torch.float32)) / half
+    exponent = -torch.arange(half, dtype=torch.float32) * log_scale
+    freqs = torch.tensor(float(t_bucket), dtype=torch.float32) * torch.exp(exponent)
+    return torch.cat([torch.sin(freqs), torch.cos(freqs)])
+
+
+def timestep_projection(
+    t_bucket: int,
+    dim: int = 256,
+    flip_sin_to_cos: bool = True,
+    downscale_freq_shift: int = 1,
+    max_period: float = 10000.0,
+) -> Tensor:
+    """diffusers ``get_timestep_embedding`` as used by ``Timesteps(256, flip_sin_to_cos=True, downscale_freq_shift=1)``
+    (weight-loader-spec.md §4.6): ``e = t * exp(-ln(max_period) * arange(half) / (half - shift))``; ``[sin e, cos e]``
+    flipped to ``[cos e, sin e]``.  Returns ``[1, dim]`` fp32.  Sanity: ``t = 0`` -> first 128 entries 1.0, rest 0.0.
+    """
+    half = dim // 2
+    exponent = -math.log(max_period) * torch.arange(0, half, dtype=torch.float32)
+    exponent = exponent / (half - downscale_freq_shift)
+    emb = torch.exp(exponent)
+    emb = torch.tensor([float(t_bucket)], dtype=torch.float32)[:, None] * emb[None, :]
+    emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=-1)
+    if flip_sin_to_cos:
+        emb = torch.cat([emb[:, half:], emb[:, :half]], dim=-1)
+    return emb
+
+
+def _check_shape(name: str, t: Tensor, shape: Sequence[int]) -> None:
+    if tuple(t.shape) != tuple(shape):
+        raise ValueError(f"{name}: expected shape {tuple(shape)}, got {tuple(t.shape)}")
+
+
+def _fp32(t: Tensor) -> Tensor:
+    if not t.is_floating_point():
+        raise TypeError(f"expected a floating tensor, got {t.dtype}")
+    return t.to(torch.float32)
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Leaf modules
+# --------------------------------------------------------------------------------------------------------------------
+
+
+class Linear(nn.Module):
+    """``nn.Linear`` in the raw checkpoint layout: ``weight [out, in]``, ``bias [out]``; ``y = F.linear(x, W, b)``."""
+
+    def __init__(self, weight: Tensor, bias: Tensor):
+        super().__init__()
+        if weight.ndim != 2 or bias.ndim != 1 or bias.shape[0] != weight.shape[0]:
+            raise ValueError(f"Linear: weight {tuple(weight.shape)} / bias {tuple(bias.shape)} mismatch")
+        self.register_buffer("weight", _fp32(weight).contiguous())
+        self.register_buffer("bias", _fp32(bias).contiguous())
+
+    @property
+    def in_features(self) -> int:
+        return int(self.weight.shape[1])
+
+    @property
+    def out_features(self) -> int:
+        return int(self.weight.shape[0])
+
+    @classmethod
+    def from_checkpoint(cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], shape: Tuple[int, int]) -> "Linear":
+        wk, bk = prefix + ".weight", prefix + ".bias"
+        w = ck.get(wk, torch.float32)
+        b = ck.get(bk, torch.float32)
+        _check_shape(wk, w, shape)
+        _check_shape(bk, b, (shape[0],))
+        consumed.update((wk, bk))
+        return cls(w, b)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return F.linear(x, self.weight, self.bias)
+
+
+class LayerNorm(nn.Module):
+    """LayerNorm over the last dim; affine (``vlln``, VL-SA norms) or plain (DiT ``norm1`` inner LN, ``norm3``, ``norm_out``)."""
+
+    def __init__(self, dim: int, eps: float, weight: Optional[Tensor] = None, bias: Optional[Tensor] = None):
+        super().__init__()
+        self.dim = dim
+        self.eps = eps
+        if (weight is None) != (bias is None):
+            raise ValueError("LayerNorm: weight and bias must both be given or both be absent")
+        if weight is not None:
+            _check_shape("LayerNorm.weight", weight, (dim,))
+            _check_shape("LayerNorm.bias", bias, (dim,))
+            self.register_buffer("weight", _fp32(weight).contiguous())
+            self.register_buffer("bias", _fp32(bias).contiguous())
+        else:
+            self.weight = None
+            self.bias = None
+
+    @property
+    def affine(self) -> bool:
+        return self.weight is not None
+
+    @classmethod
+    def from_checkpoint(cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], dim: int, eps: float) -> "LayerNorm":
+        wk, bk = prefix + ".weight", prefix + ".bias"
+        w = ck.get(wk, torch.float32)
+        b = ck.get(bk, torch.float32)
+        consumed.update((wk, bk))
+        return cls(dim, eps, w, b)
+
+    def forward(self, x: Tensor) -> Tensor:
+        if x.shape[-1] != self.dim:
+            raise ValueError(f"LayerNorm({self.dim}): got last dim {x.shape[-1]}")
+        return F.layer_norm(x, (self.dim,), self.weight, self.bias, self.eps)
+
+
+class EmbodimentLinear(nn.Module):
+    """One embodiment slot of ``CategorySpecificLinear`` (``flow_matching_action_head.py:30-42``,
+    ``embodiment_conditioned_mlp.py:59-79``): ``W[e] [in, out]``, ``b[e] [out]``; ``y = x @ W[e] + b[e]``.
+
+    The slot is read with ``LazyCheckpoint.slot`` so only ``1/32`` of the ``[32, in, out]`` tensor is touched
+    (weight-loader-spec.md §1.2 / §4.7).  The orientation is ``[in, out]`` -- **not** transposed (§4.7, VERIFIED).
+    """
+
+    def __init__(self, W: Tensor, b: Tensor, embodiment_id: int):
+        super().__init__()
+        if W.ndim != 2 or b.ndim != 1 or b.shape[0] != W.shape[1]:
+            raise ValueError(f"EmbodimentLinear: W {tuple(W.shape)} / b {tuple(b.shape)} mismatch")
+        self.embodiment_id = int(embodiment_id)
+        self.register_buffer("W", _fp32(W).contiguous())
+        self.register_buffer("b", _fp32(b).contiguous())
+
+    @property
+    def in_features(self) -> int:
+        return int(self.W.shape[0])
+
+    @property
+    def out_features(self) -> int:
+        return int(self.W.shape[1])
+
+    @classmethod
+    def from_checkpoint(
+        cls,
+        ck: LazyCheckpoint,
+        prefix: str,
+        embodiment_id: int,
+        consumed: Set[str],
+        shape: Tuple[int, int],
+        max_num_embodiments: int,
+    ) -> "EmbodimentLinear":
+        wk, bk = prefix + ".W", prefix + ".b"
+        _check_shape(wk, torch.empty(ck.shape(wk)), (max_num_embodiments,) + tuple(shape))
+        _check_shape(bk, torch.empty(ck.shape(bk)), (max_num_embodiments, shape[1]))
+        W = ck.slot(wk, embodiment_id, torch.float32)
+        b = ck.slot(bk, embodiment_id, torch.float32)
+        consumed.update((wk, bk))
+        return cls(W, b, embodiment_id)
+
+    def forward(self, x: Tensor) -> Tensor:
+        if x.shape[-1] != self.in_features:
+            raise ValueError(f"EmbodimentLinear: input width {x.shape[-1]} != {self.in_features}")
+        return x @ self.W + self.b
+
+
+class EmbodimentMLP(nn.Module):
+    """``CategorySpecificMLP`` slot: ``layer2(relu(layer1(x)))`` (state encoder, action decoder; synthesis §1.6)."""
+
+    def __init__(self, layer1: EmbodimentLinear, layer2: EmbodimentLinear):
+        super().__init__()
+        if layer1.out_features != layer2.in_features:
+            raise ValueError("EmbodimentMLP: layer widths do not chain")
+        self.layer1 = layer1
+        self.layer2 = layer2
+
+    @classmethod
+    def from_checkpoint(
+        cls,
+        ck: LazyCheckpoint,
+        prefix: str,
+        embodiment_id: int,
+        consumed: Set[str],
+        dims: Tuple[int, int, int],
+        max_num_embodiments: int,
+    ) -> "EmbodimentMLP":
+        l1 = EmbodimentLinear.from_checkpoint(
+            ck, prefix + "layer1", embodiment_id, consumed, dims[:2], max_num_embodiments
+        )
+        l2 = EmbodimentLinear.from_checkpoint(
+            ck, prefix + "layer2", embodiment_id, consumed, dims[1:], max_num_embodiments
+        )
+        return cls(l1, l2)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.layer2(F.relu(self.layer1(x)))
+
+
+class ActionEncoder(nn.Module):
+    """``MultiEmbodimentActionEncoder`` slot (arch-n15 §3.3, arch-n16 §7.2, arch-n17 §3.1)::
+
+    a   = actions @ W1 + b1                     # [B, H, D_action] -> [B, H, 1536]
+    tau = sinusoid_1536(t_bucket)               # fp32, broadcast over H (sin first)
+    h   = swish(cat[a, tau] @ W2 + b2)          # [B, H, 3072] -> [B, H, 1536]
+    out = h @ W3 + b3                           # [B, H, 1536]   (BEFORE the position-embedding add)
+    """
+
+    def __init__(
+        self, W1: EmbodimentLinear, W2: EmbodimentLinear, W3: EmbodimentLinear, tau_dim: int, tau_max_period: float
+    ):
+        super().__init__()
+        if W2.in_features != W1.out_features + tau_dim or W3.in_features != W2.out_features:
+            raise ValueError("ActionEncoder: W1/W2/W3 widths do not chain")
+        self.W1, self.W2, self.W3 = W1, W2, W3
+        self.tau_dim = tau_dim
+        self.tau_max_period = tau_max_period
+
+    @classmethod
+    def from_checkpoint(
+        cls, ck: LazyCheckpoint, prefix: str, embodiment_id: int, consumed: Set[str], enc: EncoderConfig
+    ) -> "ActionEncoder":
+        e, n = embodiment_id, enc.max_num_embodiments
+        W1 = EmbodimentLinear.from_checkpoint(ck, prefix + "W1", e, consumed, enc.action_encoder_w1, n)
+        W2 = EmbodimentLinear.from_checkpoint(ck, prefix + "W2", e, consumed, enc.action_encoder_w2, n)
+        W3 = EmbodimentLinear.from_checkpoint(ck, prefix + "W3", e, consumed, enc.action_encoder_w3, n)
+        if enc.tau_order != ("sin", "cos"):
+            raise ValueError(f"unsupported tau order {enc.tau_order}")
+        return cls(W1, W2, W3, enc.tau_dim, enc.tau_max_period)
+
+    def tau(self, t_bucket: int) -> Tensor:
+        return sinusoidal_tau_encoding(t_bucket, self.tau_dim, self.tau_max_period)
+
+    def forward(self, actions: Tensor, t_bucket: int) -> Tensor:
+        if actions.ndim != 3:
+            raise ValueError(f"actions must be [B, H, D], got {tuple(actions.shape)}")
+        a = self.W1(actions)
+        tau = self.tau(t_bucket).to(a.dtype)[None, None, :].expand(a.shape[0], a.shape[1], -1)
+        h = swish(self.W2(torch.cat([a, tau], dim=-1)))
+        return self.W3(h)
+
+
+class FeedForward(nn.Module):
+    """diffusers ``FeedForward``: ``net.0.proj`` Linear -> GELU(tanh) -> ``net.2`` Linear (VL-SA 8192, DiT 6144)."""
+
+    def __init__(self, proj: Linear, out: Linear):
+        super().__init__()
+        if proj.out_features != out.in_features or proj.in_features != out.out_features:
+            raise ValueError("FeedForward: widths do not chain")
+        self.proj = proj
+        self.out = out
+
+    @classmethod
+    def from_checkpoint(
+        cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], dim: int, inner: int
+    ) -> "FeedForward":
+        proj = Linear.from_checkpoint(ck, prefix + "net.0.proj", consumed, (inner, dim))
+        out = Linear.from_checkpoint(ck, prefix + "net.2", consumed, (dim, inner))
+        return cls(proj, out)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.out(gelu_tanh(self.proj(x)))
+
+
+class MultiHeadAttention(nn.Module):
+    """diffusers ``Attention`` + ``AttnProcessor2_0`` in fp32: ``to_q/to_k/to_v`` (+bias) -> heads -> SDPA -> ``to_out.0``.
+
+    ``head_dim`` is the *logical* head width (48 for the DiT, 64 for VL-SA) and fixes the softmax scale
+    ``head_dim ** -0.5``.  :meth:`set_head_dim_pad` re-lays the weights per head to a wider storage width
+    (48 -> 64, weight-loader-spec.md §4.6 rows to_q/to_k/to_v/to_out) while the scale stays the logical one
+    (static-shape-plan D5); zero-padded key dims contribute nothing to the logits and zero V columns meet zero
+    ``to_out`` columns, so the result is unchanged up to fp32 rounding.
+
+    The K/V side is exposed separately (:meth:`project_kv`, :meth:`attend`) so that the DiT cross blocks can hoist
+    their K/V out of the denoising loop (arch-n15 §3.6, arch-n17 §3.3).
+    """
+
+    def __init__(self, to_q: Linear, to_k: Linear, to_v: Linear, to_out: Linear, n_heads: int, head_dim: int):
+        super().__init__()
+        inner = n_heads * head_dim
+        for name, lin in (("to_q", to_q), ("to_k", to_k), ("to_v", to_v)):
+            if lin.out_features != inner:
+                raise ValueError(f"{name}: out {lin.out_features} != heads*head_dim {inner}")
+        if to_out.in_features != inner:
+            raise ValueError(f"to_out: in {to_out.in_features} != {inner}")
+        if to_k.in_features != to_v.in_features:
+            raise ValueError("to_k / to_v input widths differ")
+        self.to_q, self.to_k, self.to_v, self.to_out = to_q, to_k, to_v, to_out
+        self.n_heads = n_heads
+        self.head_dim = head_dim  # logical
+        self.head_dim_pad = head_dim  # storage width of each head in the buffers
+        self.scale = float(head_dim) ** -0.5
+
+    @property
+    def kv_dim(self) -> int:
+        return self.to_k.in_features
+
+    @classmethod
+    def from_checkpoint(
+        cls,
+        ck: LazyCheckpoint,
+        prefix: str,
+        consumed: Set[str],
+        query_dim: int,
+        kv_dim: int,
+        n_heads: int,
+        head_dim: int,
+    ) -> "MultiHeadAttention":
+        inner = n_heads * head_dim
+        to_q = Linear.from_checkpoint(ck, prefix + "to_q", consumed, (inner, query_dim))
+        to_k = Linear.from_checkpoint(ck, prefix + "to_k", consumed, (inner, kv_dim))
+        to_v = Linear.from_checkpoint(ck, prefix + "to_v", consumed, (inner, kv_dim))
+        to_out = Linear.from_checkpoint(ck, prefix + "to_out.0", consumed, (query_dim, inner))
+        return cls(to_q, to_k, to_v, to_out, n_heads, head_dim)
+
+    # ------------------------------------------------------------------ head padding (weight-loader §4.6)
+    def set_head_dim_pad(self, pad: int) -> None:
+        """Re-lay q/k/v out-axis and to_out in-axis per head to ``pad`` columns (zero filled); reversible."""
+        if pad < self.head_dim:
+            raise ValueError(f"head_dim_pad {pad} < logical head_dim {self.head_dim}")
+        cur = self.head_dim_pad
+        if pad == cur:
+            return
+        extra = pad - self.head_dim
+        for lin in (self.to_q, self.to_k, self.to_v):
+            w = lin.weight.reshape(self.n_heads, cur, lin.in_features)[:, : self.head_dim]
+            b = lin.bias.reshape(self.n_heads, cur)[:, : self.head_dim]
+            lin.weight = F.pad(w, (0, 0, 0, extra)).reshape(self.n_heads * pad, lin.in_features).contiguous()
+            lin.bias = F.pad(b, (0, extra)).reshape(self.n_heads * pad).contiguous()
+        wo = self.to_out.weight.reshape(self.to_out.out_features, self.n_heads, cur)[:, :, : self.head_dim]
+        self.to_out.weight = F.pad(wo, (0, extra)).reshape(self.to_out.out_features, self.n_heads * pad).contiguous()
+        self.head_dim_pad = pad
+
+    # ------------------------------------------------------------------ pieces
+    def _heads(self, x: Tensor) -> Tensor:
+        b, n, _ = x.shape
+        return x.view(b, n, self.n_heads, self.head_dim_pad).transpose(1, 2)
+
+    def project_q(self, x: Tensor) -> Tensor:
+        return self._heads(self.to_q(x))
+
+    def project_kv(self, kv: Tensor) -> Tuple[Tensor, Tensor]:
+        """``(K, V)`` as ``[B, heads, L, head_dim_pad]`` from the key/value source rows."""
+        if kv.shape[-1] != self.kv_dim:
+            raise ValueError(f"key/value source width {kv.shape[-1]} != {self.kv_dim}")
+        return self._heads(self.to_k(kv)), self._heads(self.to_v(kv))
+
+    def attend(self, q: Tensor, k: Tensor, v: Tensor, key_mask: Optional[Tensor] = None) -> Tensor:
+        """SDPA with the explicit logical scale; ``key_mask`` is a bool ``[B, L]`` (True = attend) or None."""
+        attn_mask = None
+        if key_mask is not None:
+            if key_mask.dtype != torch.bool or key_mask.ndim != 2 or key_mask.shape[-1] != k.shape[-2]:
+                raise ValueError(
+                    f"key_mask must be bool [B, L={k.shape[-2]}], got {key_mask.dtype} {tuple(key_mask.shape)}"
+                )
+            if not bool(key_mask.any(dim=-1).all()):
+                raise ValueError("key_mask masks out every key of some row")
+            attn_mask = key_mask[:, None, None, :]
+        out = F.scaled_dot_product_attention(
+            q, k, v, attn_mask=attn_mask, dropout_p=0.0, is_causal=False, scale=self.scale
+        )
+        b, _, m, _ = out.shape
+        return self.to_out(out.transpose(1, 2).reshape(b, m, self.n_heads * self.head_dim_pad))
+
+    def forward(self, x: Tensor, kv: Optional[Tensor] = None, key_mask: Optional[Tensor] = None) -> Tensor:
+        """Self attention when ``kv`` is None, cross attention on ``kv`` otherwise."""
+        q = self.project_q(x)
+        k, v = self.project_kv(x if kv is None else kv)
+        return self.attend(q, k, v, key_mask)
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# VL adapter (vlln + VL self-attention)
+# --------------------------------------------------------------------------------------------------------------------
+
+
+class VLSelfAttentionBlock(nn.Module):
+    """``BasicTransformerBlock(norm_type="layer_norm")`` of the VL self-attention transformer (arch-n15 §3.5,
+    arch-n17 §3.2): ``x += attn1(LN1(x))``; ``x += ff(LN3(x))``; LN affine eps 1e-5; 32 x 64 heads; FF 8192; no mask."""
+
+    def __init__(self, norm1: LayerNorm, attn: MultiHeadAttention, norm3: LayerNorm, ff: FeedForward):
+        super().__init__()
+        self.norm1, self.attn, self.norm3, self.ff = norm1, attn, norm3, ff
+
+    @classmethod
+    def from_checkpoint(
+        cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], cfg: VLAdapterConfig
+    ) -> "VLSelfAttentionBlock":
+        norm1 = LayerNorm.from_checkpoint(ck, prefix + "norm1", consumed, cfg.dim, cfg.ln_eps)
+        attn = MultiHeadAttention.from_checkpoint(
+            ck, prefix + "attn1.", consumed, cfg.dim, cfg.dim, cfg.n_heads, cfg.head_dim
+        )
+        norm3 = LayerNorm.from_checkpoint(ck, prefix + "norm3", consumed, cfg.dim, cfg.ln_eps)
+        ff = FeedForward.from_checkpoint(ck, prefix + "ff.", consumed, cfg.dim, cfg.ff_dim)
+        return cls(norm1, attn, norm3, ff)
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = x + self.attn(self.norm1(x))
+        return x + self.ff(self.norm3(x))
+
+
+class VLAdapter(nn.Module):
+    """``vlln`` LayerNorm(2048, eps 1e-5, affine) followed by 0 (N1.6) or 4 (N1.5 / N1.7) VL self-attention blocks
+    (synthesis §1.4).  Runs once per inference; its output is the DiT ``encoder_hidden_states``."""
+
+    def __init__(self, vlln: LayerNorm, blocks: Sequence[VLSelfAttentionBlock]):
+        super().__init__()
+        self.vlln = vlln
+        self.blocks = nn.ModuleList(blocks)
+
+    @classmethod
+    def from_checkpoint(cls, ck: LazyCheckpoint, cfg: GR00TConfig, consumed: Set[str]) -> "VLAdapter":
+        vla = cfg.vl_adapter
+        vlln = LayerNorm.from_checkpoint(ck, cfg.checkpoint.vlln_prefix.rstrip("."), consumed, vla.dim, vla.vlln_eps)
+        blocks: List[VLSelfAttentionBlock] = []
+        prefix = cfg.checkpoint.vl_self_attention_prefix
+        if vla.n_blocks > 0:
+            if prefix is None:
+                raise ValueError(f"{cfg.version}: {vla.n_blocks} VL-SA blocks configured but no checkpoint prefix")
+            for i in range(vla.n_blocks):
+                blocks.append(
+                    VLSelfAttentionBlock.from_checkpoint(ck, f"{prefix}transformer_blocks.{i}.", consumed, vla)
+                )
+        elif prefix is not None:
+            raise ValueError(f"{cfg.version}: VL-SA prefix configured but n_blocks == 0")
+        return cls(vlln, blocks)
+
+    def forward(self, backbone_features: Tensor, taps: Optional[Dict[str, Tensor]] = None) -> Tensor:
+        if backbone_features.ndim != 3 or backbone_features.shape[-1] != self.vlln.dim:
+            raise ValueError(f"backbone_features must be [B, S, {self.vlln.dim}], got {tuple(backbone_features.shape)}")
+        x = self.vlln(backbone_features)
+        if taps is not None:
+            taps["vlln_out"] = x
+        for i, blk in enumerate(self.blocks):
+            x = blk(x)
+            if taps is not None:
+                taps[f"vlsa_block{i}_out"] = x
+        if taps is not None:
+            if len(self.blocks) > 0:
+                taps["vl_self_attention_out"] = x
+            taps["dit_encoder_hidden_states"] = x
+        return x
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# DiT
+# --------------------------------------------------------------------------------------------------------------------
+
+
+class TimestepEncoder(nn.Module):
+    """``TimestepEncoder`` (cross_attention_dit.py:31-41 / dit.py:61-71): ``Timesteps(256, flip, shift 1)`` ->
+    ``linear_1`` (256 -> 1536) -> SiLU -> ``linear_2`` (1536 -> 1536) -> ``temb [1, 1536]`` shared by every block."""
+
+    def __init__(self, linear_1: Linear, linear_2: Linear, cfg: DiTConfig):
+        super().__init__()
+        self.linear_1, self.linear_2 = linear_1, linear_2
+        self.embed_dim = cfg.timestep_embed_dim
+        self.flip_sin_to_cos = cfg.timestep_flip_sin_to_cos
+        self.downscale_freq_shift = cfg.timestep_downscale_freq_shift
+        self.max_period = cfg.timestep_max_period
+
+    @classmethod
+    def from_checkpoint(cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], cfg: DiTConfig) -> "TimestepEncoder":
+        l1 = Linear.from_checkpoint(
+            ck, prefix + "linear_1", consumed, (cfg.timestep_mlp_hidden, cfg.timestep_embed_dim)
+        )
+        l2 = Linear.from_checkpoint(ck, prefix + "linear_2", consumed, (cfg.width, cfg.timestep_mlp_hidden))
+        return cls(l1, l2, cfg)
+
+    def projection(self, t_bucket: int) -> Tensor:
+        return timestep_projection(
+            t_bucket, self.embed_dim, self.flip_sin_to_cos, self.downscale_freq_shift, self.max_period
+        )
+
+    def forward(self, t_bucket: int) -> Tensor:
+        return self.linear_2(F.silu(self.linear_1(self.projection(t_bucket))))
+
+
+class AdaLayerNorm(nn.Module):
+    """``AdaLayerNorm`` (cross_attention_dit.py:44-67 / dit.py:74-97): ``scale, shift = linear(silu(temb)).chunk(2)``
+    -- **scale first** -- and ``LN(x, eps 1e-5, no affine) * (1 + scale) + shift`` (critique C6; weight-loader §4.6
+    VERIFIED: swapped order -> PCC 0.61).  :meth:`modulation` returns ``(1 + scale, shift)`` so that a precomputed
+    table and the live path execute the same arithmetic."""
+
+    def __init__(self, linear: Linear, dim: int, eps: float):
+        super().__init__()
+        if linear.out_features != 2 * dim or linear.in_features != dim:
+            raise ValueError(f"AdaLayerNorm: linear {linear.out_features}x{linear.in_features} != {2 * dim}x{dim}")
+        self.linear = linear
+        self.norm = LayerNorm(dim, eps)
+
+    def modulation(self, temb: Tensor) -> Tuple[Tensor, Tensor]:
+        scale, shift = self.linear(F.silu(temb)).chunk(2, dim=-1)
+        return 1.0 + scale, shift
+
+    def forward(self, x: Tensor, one_plus_scale: Tensor, shift: Tensor) -> Tensor:
+        return self.norm(x) * one_plus_scale[:, None, :] + shift[:, None, :]
+
+
+class DiTBlock(nn.Module):
+    """``BasicTransformerBlock(norm_type="ada_norm")`` (synthesis §1.5)::
+
+        h = AdaLN(x, temb)                                   # attention branch only, ungated
+        x = x + attn1(h, kv = vl_embs if cross else h)       # 32 x 48, scale 48^-0.5, bias everywhere
+        x = x + ff(LN(x, eps 1e-5, no affine))               # norm3 has no weights in any checkpoint (synthesis §3 N8)
+
+    ``key_subset`` names the cross-attention key set (``DiTConfig.cross_key_subset``): ``all`` (N1.5), ``text``
+    (non-image tokens, ``idx % 4 == 0``) or ``image`` (``idx % 4 == 2``); ``None`` for self-attention blocks.
+    """
+
+    def __init__(
+        self,
+        index: int,
+        norm1: AdaLayerNorm,
+        attn: MultiHeadAttention,
+        ff: FeedForward,
+        norm3_eps: float,
+        key_subset: Optional[str],
+    ):
+        super().__init__()
+        self.index = index
+        self.norm1, self.attn, self.ff = norm1, attn, ff
+        self.norm3 = LayerNorm(attn.to_q.in_features, norm3_eps)
+        if key_subset is not None and key_subset not in KEY_SUBSETS:
+            raise ValueError(f"block {index}: unknown key subset {key_subset!r}")
+        self.key_subset = key_subset
+
+    @property
+    def is_cross(self) -> bool:
+        return self.key_subset is not None
+
+    @classmethod
+    def from_checkpoint(
+        cls, ck: LazyCheckpoint, prefix: str, index: int, consumed: Set[str], cfg: DiTConfig
+    ) -> "DiTBlock":
+        is_cross = index % 2 == 0  # cross_block_parity == "even"
+        key_subset = cfg.cross_key_subset(index) if is_cross else None
+        kv_dim = cfg.cross_attention_dim if is_cross else cfg.width
+        norm1 = AdaLayerNorm(
+            Linear.from_checkpoint(ck, prefix + "norm1.linear", consumed, (2 * cfg.width, cfg.width)),
+            cfg.width,
+            cfg.adaln_ln_eps,
+        )
+        attn = MultiHeadAttention.from_checkpoint(
+            ck, prefix + "attn1.", consumed, cfg.width, kv_dim, cfg.n_heads, cfg.head_dim
+        )
+        ff = FeedForward.from_checkpoint(ck, prefix + "ff.", consumed, cfg.width, cfg.ff_dim)
+        return cls(index, norm1, attn, ff, cfg.norm3_eps, key_subset)
+
+    def forward(
+        self,
+        x: Tensor,
+        one_plus_scale: Tensor,
+        shift: Tensor,
+        kv: Optional[Tensor] = None,
+        key_mask: Optional[Tensor] = None,
+        hoisted_kv: Optional[Tuple[Tensor, Tensor]] = None,
+    ) -> Tensor:
+        h = self.norm1(x, one_plus_scale, shift)
+        if self.is_cross:
+            q = self.attn.project_q(h)
+            if hoisted_kv is not None:
+                if kv is not None or key_mask is not None:
+                    raise ValueError(f"block {self.index}: pass either hoisted K/V or (kv, key_mask), not both")
+                a = self.attn.attend(q, hoisted_kv[0], hoisted_kv[1], None)
+            else:
+                if kv is None:
+                    raise ValueError(f"block {self.index}: cross-attention block needs kv or hoisted_kv")
+                k, v = self.attn.project_kv(kv)
+                a = self.attn.attend(q, k, v, key_mask)
+        else:
+            if kv is not None or key_mask is not None or hoisted_kv is not None:
+                raise ValueError(f"block {self.index}: self-attention block takes no key/value source")
+            a = self.attn(h)
+        x = x + a
+        return x + self.ff(self.norm3(x))
+
+
+class DiTOutputHead(nn.Module):
+    """Output block (cross_attention_dit.py:299-306 / dit.py:407-414): ``shift, scale = proj_out_1(silu(temb)).chunk(2)``
+    -- **shift first**, the opposite order to the blocks -- ``LN(x, eps 1e-6, no affine) * (1 + scale) + shift`` ->
+    ``proj_out_2`` (1536 -> 1024)."""
+
+    def __init__(self, proj_out_1: Linear, proj_out_2: Linear, dim: int, eps: float):
+        super().__init__()
+        if proj_out_1.out_features != 2 * dim or proj_out_2.in_features != dim:
+            raise ValueError("DiTOutputHead: projection widths mismatch")
+        self.proj_out_1, self.proj_out_2 = proj_out_1, proj_out_2
+        self.norm_out = LayerNorm(dim, eps)
+
+    @classmethod
+    def from_checkpoint(cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], cfg: DiTConfig) -> "DiTOutputHead":
+        p1 = Linear.from_checkpoint(ck, prefix + "proj_out_1", consumed, (2 * cfg.width, cfg.width))
+        p2 = Linear.from_checkpoint(ck, prefix + "proj_out_2", consumed, (cfg.out_dim, cfg.width))
+        return cls(p1, p2, cfg.width, cfg.out_norm_eps)
+
+    def modulation(self, temb: Tensor) -> Tuple[Tensor, Tensor]:
+        """``(1 + scale, shift)`` of the output head (chunk order shift, scale)."""
+        shift, scale = self.proj_out_1(F.silu(temb)).chunk(2, dim=-1)
+        return 1.0 + scale, shift
+
+    def forward(self, x: Tensor, one_plus_scale: Tensor, shift: Tensor) -> Tensor:
+        return self.proj_out_2(self.norm_out(x) * one_plus_scale[:, None, :] + shift[:, None, :])
+
+
+@dataclass(frozen=True)
+class StepModulation:
+    """Every timestep-dependent vector of one denoising step (weight-loader-spec.md §4.6 'precompute'): ``temb``
+    ``[1, 1536]``, per block ``(1 + scale, shift)`` and the output head ``(1 + scale, shift)``, all ``[1, 1536]``."""
+
+    bucket: int
+    temb: Tensor
+    block_one_plus_scale: Tuple[Tensor, ...]
+    block_shift: Tuple[Tensor, ...]
+    head_one_plus_scale: Tensor
+    head_shift: Tensor
+
+    @property
+    def n_blocks(self) -> int:
+        return len(self.block_one_plus_scale)
+
+
+def select_keys(
+    subset: str, image_mask: Optional[Tensor], backbone_attention_mask: Optional[Tensor], seq_len: int
+) -> Optional[Tensor]:
+    """Boolean key mask ``[B, S]`` of a cross-attention key subset (arch-n16 §7.4, arch-n17 §3.3):
+    ``text`` -> ``~image_mask & backbone_attention_mask``; ``image`` -> ``image_mask & backbone_attention_mask``;
+    ``all`` -> None (N1.5 applies no key mask, ``VLAdapterConfig.masked`` is False)."""
+    if subset == "all":
+        return None
+    if image_mask is None or backbone_attention_mask is None:
+        raise ValueError(f"key subset {subset!r} needs image_mask and backbone_attention_mask")
+    for name, m in (("image_mask", image_mask), ("backbone_attention_mask", backbone_attention_mask)):
+        if m.dtype != torch.bool:
+            raise TypeError(f"{name} must be bool, got {m.dtype}")
+        if m.ndim != 2 or m.shape[-1] != seq_len:
+            raise ValueError(f"{name} must be [B, S={seq_len}], got {tuple(m.shape)}")
+    if subset == "text":
+        return (~image_mask) & backbone_attention_mask
+    if subset == "image":
+        return image_mask & backbone_attention_mask
+    raise ValueError(f"unknown key subset {subset!r}")
+
+
+class DiT(nn.Module):
+    """``cross_attention_dit.DiT`` (N1.5) / ``dit.AlternateVLDiT`` (N1.6, N1.7) in fp32 (synthesis §1.5).
+
+    ``forward`` supports three interchangeable cross-attention forms:
+
+    * ``cross_form="mask"``   -- reference: K/V from all ``S`` VL tokens + boolean key mask (N1.5: no mask);
+    * ``cross_form="gather"`` -- K/V from the gathered key subset only (no mask);
+    * ``cross_kv=...``        -- hoisted K/V from :meth:`hoist_cross_kv` (gather form computed once per inference).
+
+    and an optional precomputed :class:`StepModulation` (``modulation=``) in place of the live timestep encoder.
+    """
+
+    def __init__(
+        self, cfg: DiTConfig, timestep_encoder: TimestepEncoder, blocks: Sequence[DiTBlock], out: DiTOutputHead
+    ):
+        super().__init__()
+        if len(blocks) != cfg.n_blocks:
+            raise ValueError(f"DiT: {len(blocks)} blocks != {cfg.n_blocks}")
+        self.cfg = cfg
+        self.timestep_encoder = timestep_encoder
+        self.blocks = nn.ModuleList(blocks)
+        self.out = out
+
+    @classmethod
+    def from_checkpoint(cls, ck: LazyCheckpoint, prefix: str, consumed: Set[str], cfg: DiTConfig) -> "DiT":
+        te = TimestepEncoder.from_checkpoint(ck, prefix + "timestep_encoder.timestep_embedder.", consumed, cfg)
+        blocks = [
+            DiTBlock.from_checkpoint(ck, f"{prefix}transformer_blocks.{i}.", i, consumed, cfg)
+            for i in range(cfg.n_blocks)
+        ]
+        out = DiTOutputHead.from_checkpoint(ck, prefix, consumed, cfg)
+        return cls(cfg, te, blocks, out)
+
+    # ------------------------------------------------------------------ head padding
+    @property
+    def head_dim_pad(self) -> int:
+        return self.blocks[0].attn.head_dim_pad
+
+    def set_head_dim_pad(self, pad: int) -> None:
+        """Pad (or un-pad) every block's attention heads to ``pad`` columns; the scale stays ``48 ** -0.5``."""
+        for blk in self.blocks:
+            blk.attn.set_head_dim_pad(pad)
+
+    # ------------------------------------------------------------------ timestep-dependent vectors
+    def modulation(self, t_bucket: int) -> StepModulation:
+        """Live path: ``temb`` and every ``(1 + scale, shift)`` of one bucket."""
+        temb = self.timestep_encoder(t_bucket)
+        ops, shs = [], []
+        for blk in self.blocks:
+            o, s = blk.norm1.modulation(temb)
+            ops.append(o)
+            shs.append(s)
+        ho, hs = self.out.modulation(temb)
+        return StepModulation(int(t_bucket), temb, tuple(ops), tuple(shs), ho, hs)
+
+    # ------------------------------------------------------------------ cross-attention key sets
+    def key_indices(
+        self, subset: str, image_mask: Optional[Tensor], backbone_attention_mask: Optional[Tensor], seq_len: int
+    ) -> Optional[Tensor]:
+        """Gather indices of ``subset`` (batch 1) or None for ``all``."""
+        mask = select_keys(subset, image_mask, backbone_attention_mask, seq_len)
+        if mask is None:
+            return None
+        if mask.shape[0] != 1:
+            raise ValueError("gather form is defined for batch 1")
+        idx = mask[0].nonzero(as_tuple=False).flatten()
+        if idx.numel() == 0:
+            raise ValueError(f"key subset {subset!r} selects no token")
+        return idx
+
+    def hoist_cross_kv(
+        self, vl_embs: Tensor, image_mask: Optional[Tensor], backbone_attention_mask: Optional[Tensor]
+    ) -> Dict[int, Tuple[Tensor, Tensor]]:
+        """K/V of every cross block over its gathered key subset -- computed once per inference and reused by the 4
+        denoising steps (arch-n15 §3.6; static-shape-plan §6.2 'hoisted K/V buffers')."""
+        seq_len = vl_embs.shape[1]
+        gathered: Dict[str, Tensor] = {}
+        out: Dict[int, Tuple[Tensor, Tensor]] = {}
+        for blk in self.blocks:
+            if not blk.is_cross:
+                continue
+            if blk.key_subset not in gathered:
+                idx = self.key_indices(blk.key_subset, image_mask, backbone_attention_mask, seq_len)
+                gathered[blk.key_subset] = vl_embs if idx is None else vl_embs[:, idx]
+            out[blk.index] = blk.attn.project_kv(gathered[blk.key_subset])
+        return out
+
+    # ------------------------------------------------------------------ forward
+    def forward(
+        self,
+        sa_embs: Tensor,
+        vl_embs: Tensor,
+        t_bucket: int,
+        image_mask: Optional[Tensor] = None,
+        backbone_attention_mask: Optional[Tensor] = None,
+        *,
+        modulation: Optional[StepModulation] = None,
+        cross_form: CrossForm = "mask",
+        cross_kv: Optional[Dict[int, Tuple[Tensor, Tensor]]] = None,
+        taps: Optional[Dict[str, Tensor]] = None,
+        tap_suffix: str = "",
+    ) -> Tensor:
+        cfg = self.cfg
+        _check_shape("sa_embs", sa_embs, (1, cfg.n_query_tokens, cfg.width))
+        if vl_embs.ndim != 3 or vl_embs.shape[0] != 1 or vl_embs.shape[-1] != cfg.cross_attention_dim:
+            raise ValueError(f"vl_embs must be [1, S, {cfg.cross_attention_dim}], got {tuple(vl_embs.shape)}")
+        if cross_form not in CROSS_FORMS:
+            raise ValueError(f"cross_form must be one of {CROSS_FORMS}, got {cross_form!r}")
+        seq_len = vl_embs.shape[1]
+
+        mod = self.modulation(t_bucket) if modulation is None else modulation
+        if mod.bucket != int(t_bucket) or mod.n_blocks != cfg.n_blocks:
+            raise ValueError(
+                f"modulation is for bucket {mod.bucket} / {mod.n_blocks} blocks, need {t_bucket} / {cfg.n_blocks}"
+            )
+        if taps is not None:
+            taps["temb" + tap_suffix] = mod.temb
+
+        masks: Dict[str, Optional[Tensor]] = {}
+        gathered: Dict[str, Tensor] = {}
+        x = sa_embs.contiguous()
+        for i, blk in enumerate(self.blocks):
+            ops, sh = mod.block_one_plus_scale[i], mod.block_shift[i]
+            if not blk.is_cross:
+                x = blk(x, ops, sh)
+            elif cross_kv is not None:
+                if blk.index not in cross_kv:
+                    raise KeyError(f"cross_kv has no entry for block {blk.index}")
+                x = blk(x, ops, sh, hoisted_kv=cross_kv[blk.index])
+            elif cross_form == "mask":
+                if blk.key_subset not in masks:
+                    masks[blk.key_subset] = select_keys(blk.key_subset, image_mask, backbone_attention_mask, seq_len)
+                x = blk(x, ops, sh, kv=vl_embs, key_mask=masks[blk.key_subset])
+            else:  # gather
+                if blk.key_subset not in gathered:
+                    idx = self.key_indices(blk.key_subset, image_mask, backbone_attention_mask, seq_len)
+                    gathered[blk.key_subset] = vl_embs if idx is None else vl_embs[:, idx]
+                x = blk(x, ops, sh, kv=gathered[blk.key_subset], key_mask=None)
+            if taps is not None:
+                taps[f"dit_block{i}_out" + tap_suffix] = x
+        if taps is not None:
+            taps["dit_block_last_out" + tap_suffix] = x
+        y = self.out(x, mod.head_one_plus_scale, mod.head_shift)
+        if taps is not None:
+            taps["dit_out" + tap_suffix] = y
+        return y
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Action head
+# --------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass
+class Conditioning:
+    """Per-inference constants of the denoising loop (everything that does not depend on the step)."""
+
+    vl_embs: Tensor  # [1, S, 2048] = DiT encoder_hidden_states
+    state_features: Tensor  # [1, 1, 1536]
+    image_mask: Optional[Tensor]  # bool [1, S] (N1.6 / N1.7)
+    backbone_attention_mask: Optional[Tensor]  # bool [1, S]
+    cross_kv: Optional[Dict[int, Tuple[Tensor, Tensor]]] = None  # hoisted K/V per cross block (gather form)
+
+
+class ActionHead(nn.Module):
+    """The complete GR00T action head for one embodiment slot (synthesis §1.4-1.6).
+
+    Public API::
+
+        head = ActionHead.from_checkpoint("n17", embodiment_id=24)
+        cond = head.prepare(backbone_features, state, embodiment_id, image_mask, backbone_attention_mask, taps=taps)
+        v    = head.denoise_step(actions, t_bucket, cond, taps=taps, tap_suffix="[k=0]")   # velocity [1, H, D]
+
+    ``prepare`` runs the VL adapter and the state encoder once; ``denoise_step`` runs action encoder -> ``sa_embs``
+    -> DiT -> decoder -> velocity rows ``-H:``.  The sampler (:mod:`.sampler`) drives the 4 Euler steps.
+    """
+
+    def __init__(
+        self,
+        cfg: GR00TConfig,
+        embodiment_id: int,
+        vl_adapter: VLAdapter,
+        state_encoder: EmbodimentMLP,
+        action_encoder: ActionEncoder,
+        position_embedding: Tensor,
+        future_tokens: Optional[Tensor],
+        dit: DiT,
+        action_decoder: EmbodimentMLP,
+    ):
+        super().__init__()
+        enc = cfg.encoders
+        self.cfg = cfg
+        self.version = cfg.version
+        self.embodiment_id = int(embodiment_id)
+        self.vl_adapter = vl_adapter
+        self.state_encoder = state_encoder
+        self.action_encoder = action_encoder
+        _check_shape("position_embedding", position_embedding, (enc.action_horizon, enc.input_embedding_dim))
+        self.register_buffer("position_embedding", _fp32(position_embedding).contiguous())
+        if cfg.dit.n_future_tokens > 0:
+            if future_tokens is None:
+                raise ValueError(f"{cfg.version}: {cfg.dit.n_future_tokens} future tokens expected")
+            _check_shape("future_tokens", future_tokens, (cfg.dit.n_future_tokens, enc.input_embedding_dim))
+            self.register_buffer("future_tokens", _fp32(future_tokens).contiguous())
+        else:
+            if future_tokens is not None:
+                raise ValueError(f"{cfg.version}: unexpected future tokens")
+            self.future_tokens = None
+        self.dit = dit
+        self.action_decoder = action_decoder
+        if 1 + cfg.dit.n_future_tokens + enc.action_horizon != cfg.dit.n_query_tokens:
+            raise ValueError("query-token bookkeeping is inconsistent")
+
+    # ------------------------------------------------------------------ loading
+    @classmethod
+    def from_checkpoint(cls, version: str, embodiment_id: int, ck: Optional[LazyCheckpoint] = None) -> "ActionHead":
+        """Build the head for ``embodiment_id`` from the raw checkpoint keys; every ``action_head.*`` key is consumed."""
+        cfg = get_config(version)
+        if ck is None:
+            ck = LazyCheckpoint(version)
+        enc = cfg.encoders
+        if not 0 <= embodiment_id < enc.max_num_embodiments:
+            raise IndexError(f"embodiment_id {embodiment_id} out of range [0, {enc.max_num_embodiments})")
+        consumed: Set[str] = set()
+        ah = cfg.checkpoint.action_head_prefix
+        p_state, p_action, p_decoder = cfg.checkpoint.embodiment_prefixes
+        n = enc.max_num_embodiments
+
+        vl_adapter = VLAdapter.from_checkpoint(ck, cfg, consumed)
+        state_encoder = EmbodimentMLP.from_checkpoint(ck, p_state, embodiment_id, consumed, enc.state_encoder_dims, n)
+        action_encoder = ActionEncoder.from_checkpoint(ck, p_action, embodiment_id, consumed, enc)
+        action_decoder = EmbodimentMLP.from_checkpoint(
+            ck, p_decoder, embodiment_id, consumed, enc.action_decoder_dims, n
+        )
+
+        pos_key = ah + "position_embedding.weight"
+        _check_shape(pos_key, torch.empty(ck.shape(pos_key)), (enc.position_embedding_rows, enc.input_embedding_dim))
+        position_embedding = ck.rows(pos_key, 0, enc.action_horizon, torch.float32)
+        consumed.add(pos_key)
+
+        future_tokens = None
+        ft_key = ah + "future_tokens.weight"
+        if cfg.dit.n_future_tokens > 0:
+            future_tokens = ck.get(ft_key, torch.float32)
+            consumed.add(ft_key)
+
+        dit = DiT.from_checkpoint(ck, cfg.checkpoint.dit_prefix, consumed, cfg.dit)
+
+        unconsumed = sorted(set(ck.list_by_prefix(ah)) - consumed)
+        if unconsumed:
+            raise ValueError(f"{version}: {len(unconsumed)} action_head keys not consumed, e.g. {unconsumed[:5]}")
+        return cls(
+            cfg,
+            embodiment_id,
+            vl_adapter,
+            state_encoder,
+            action_encoder,
+            position_embedding,
+            future_tokens,
+            dit,
+            action_decoder,
+        )
+
+    # ------------------------------------------------------------------ once per inference
+    def _check_embodiment(self, embodiment_id) -> None:
+        e = int(embodiment_id.reshape(-1)[0]) if isinstance(embodiment_id, Tensor) else int(embodiment_id)
+        if isinstance(embodiment_id, Tensor) and embodiment_id.numel() != 1:
+            raise ValueError("batch 1: embodiment_id must have one element")
+        if e != self.embodiment_id:
+            raise ValueError(f"head was built for embodiment slot {self.embodiment_id}, got {e}")
+
+    def encode_state(self, state: Tensor) -> Tensor:
+        """``state [1, 1, max_state_dim]`` (N1.7: ``[B, T_hist, D].view(B, 1, -1)``) -> ``state_features [1, 1, 1536]``."""
+        enc = self.cfg.encoders
+        if state.ndim != 3 or state.shape[0] != 1:
+            raise ValueError(f"state must be [1, T, D], got {tuple(state.shape)}")
+        state = state.reshape(1, 1, -1)
+        _check_shape("state (flattened)", state, (1, 1, enc.max_state_dim))
+        return self.state_encoder(_fp32(state))
+
+    @torch.no_grad()
+    def prepare(
+        self,
+        backbone_features: Tensor,
+        state: Tensor,
+        embodiment_id,
+        image_mask: Optional[Tensor] = None,
+        backbone_attention_mask: Optional[Tensor] = None,
+        *,
+        hoist_cross_kv: bool = False,
+        taps: Optional[Dict[str, Tensor]] = None,
+    ) -> Conditioning:
+        """VL adapter + state encoder (+ optional hoisted cross K/V).  Masks are converted to bool (N1.5 stores int64)."""
+        self._check_embodiment(embodiment_id)
+        bf = _fp32(backbone_features)
+        if image_mask is not None:
+            image_mask = image_mask.to(torch.bool)
+        if backbone_attention_mask is not None:
+            backbone_attention_mask = backbone_attention_mask.to(torch.bool)
+        if self.cfg.dit.cross_key_set != "all" and (image_mask is None or backbone_attention_mask is None):
+            raise ValueError(f"{self.version}: image_mask and backbone_attention_mask are required")
+        vl_embs = self.vl_adapter(bf, taps)
+        state_features = self.encode_state(state)
+        if taps is not None:
+            taps["state_features"] = state_features
+            taps["position_embedding"] = self.position_embedding
+        cross_kv = self.dit.hoist_cross_kv(vl_embs, image_mask, backbone_attention_mask) if hoist_cross_kv else None
+        return Conditioning(vl_embs, state_features, image_mask, backbone_attention_mask, cross_kv)
+
+    # ------------------------------------------------------------------ per denoising step
+    def build_sa_embs(
+        self,
+        actions: Tensor,
+        t_bucket: int,
+        state_features: Tensor,
+        taps: Optional[Dict[str, Tensor]] = None,
+        tap_suffix: str = "",
+    ) -> Tensor:
+        """``cat(state_features, [future_tokens], action_encoder(actions, t) + pos[0:H])`` -> ``[1, T_q, 1536]``."""
+        enc = self.cfg.encoders
+        _check_shape("actions", actions, (1, enc.action_horizon, enc.max_action_dim))
+        _check_shape("state_features", state_features, (1, 1, enc.input_embedding_dim))
+        a = self.action_encoder(_fp32(actions), t_bucket)
+        if taps is not None:
+            taps["action_encoder_out" + tap_suffix] = a
+        a = a + self.position_embedding[None]
+        parts = [state_features]
+        if self.future_tokens is not None:
+            parts.append(self.future_tokens[None])
+        parts.append(a)
+        sa = torch.cat(parts, dim=1)
+        if taps is not None:
+            taps["sa_embs" + tap_suffix] = sa
+        return sa
+
+    def decode(self, dit_out: Tensor, taps: Optional[Dict[str, Tensor]] = None, tap_suffix: str = "") -> Tensor:
+        """Action decoder on all query rows; the velocity is the last ``H`` rows (synthesis §1.6)."""
+        pred = self.action_decoder(dit_out)
+        if taps is not None:
+            taps["action_decoder_out" + tap_suffix] = pred
+        v = pred[:, -self.cfg.encoders.action_horizon :]
+        if taps is not None:
+            taps["pred_velocity" + tap_suffix] = v
+        return v
+
+    @torch.no_grad()
+    def denoise_step(
+        self,
+        actions: Tensor,
+        t_bucket: int,
+        cond: Conditioning,
+        *,
+        modulation: Optional[StepModulation] = None,
+        cross_form: CrossForm = "mask",
+        taps: Optional[Dict[str, Tensor]] = None,
+        tap_suffix: str = "",
+    ) -> Tensor:
+        """One evaluation of the velocity field ``v(actions, t_bucket)`` -> ``[1, H, max_action_dim]``."""
+        if taps is not None:
+            taps["noisy_actions_in" + tap_suffix] = _fp32(actions)
+            taps["timestep" + tap_suffix] = torch.tensor([int(t_bucket)], dtype=torch.int64)
+        sa = self.build_sa_embs(actions, t_bucket, cond.state_features, taps, tap_suffix)
+        y = self.dit(
+            sa,
+            cond.vl_embs,
+            t_bucket,
+            cond.image_mask,
+            cond.backbone_attention_mask,
+            modulation=modulation,
+            cross_form=cross_form,
+            cross_kv=cond.cross_kv,
+            taps=taps,
+            tap_suffix=tap_suffix,
+        )
+        return self.decode(y, taps, tap_suffix)
+
+    def __repr__(self) -> str:  # keep the module tree out of pytest output
+        return f"ActionHead({self.version}, embodiment={self.embodiment_id}, dit_blocks={self.cfg.dit.n_blocks}, head_dim_pad={self.dit.head_dim_pad})"

code/models/experimental/gr00t/reference/model.py

@@ -0,0 +1,524 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""End-to-end fp32 CPU reference of GR00T N1.5 / N1.6 / N1.7: raw observation -> physical actions.
+
+:class:`Gr00tReference` glues the host pipeline and the torch reference modules together exactly the way the device
+model will (``01-architecture-synthesis.md`` §1.7-1.8 dataflow)::
+
+    Observation --encode--> ModelInputs --backbone--> features [S, 2048] --action head + sampler--> x_4 --decode--> actions
+      (common.preprocessing / prompts)   (reference.backbone)      (reference.action_head / sampler)    (common.normalization)
+
+* **encode**: :func:`common.preprocessing.encode` (images -> pixel values, prompt -> ids, state -> normalised
+  vector, static slot layout + RoPE tables; ``foundation-f2-host.md`` §2).
+* **backbone**: :class:`reference.backbone.Backbone` on the *unpadded* sequence (batch 1, pure causal mask, the
+  golden case).  The RoPE tables / mRoPE ids of the padded host layout are gathered at the real-token slots
+  (``ModelInputs.slots.slot_of_token``), so the host tables are the ones exercised, not the backbone's own builder.
+* **action head + sampler**: :class:`reference.action_head.ActionHead` (one embodiment slot) driven by
+  :class:`reference.sampler.FlowMatchingSampler` (4 Euler steps, ``SamplerConfig``; the fp32 Euler convention by
+  default, the official bf16 conventions on request -- ``golden-tap-map-and-thresholds.md`` §2.1).
+* **decode**: :func:`common.normalization.decode` (per-group min-max un-normalisation; N1.6 / N1.7 RELATIVE keys are
+  composed with the raw observation state; ``foundation-f2-host.md`` §3).
+
+Noise: the reference policies draw ``randn`` after a fixed seed on every call (N1.5 ``manual_seed(0)``,
+``flow_matching_action_head.py:364-368``; N1.6 / N1.7 seed 42, ``golden/n16/README.md`` §"initial_noise",
+``golden/n17/README.md`` §"Determinism / seed").  :meth:`Gr00tReference.make_noise` mirrors that with a CPU
+``torch.Generator`` (the CPU stream differs from the CUDA stream of the goldens, so tests inject the golden noise).
+
+Everything is fp32, CPU, deterministic, batch 1; no ``ttnn`` import.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Mapping, Optional, Tuple, Union
+
+import torch
+from torch import Tensor
+
+from models.experimental.gr00t.common import normalization
+from models.experimental.gr00t.common.checkpoint import LazyCheckpoint
+from models.experimental.gr00t.common.configs import GR00T_VERSIONS, GR00TConfig, get_config
+from models.experimental.gr00t.common.golden import GoldenSet
+from models.experimental.gr00t.common.normalization import EmbodimentSpec, get_embodiment_spec
+from models.experimental.gr00t.common.preprocessing import ModelInputs, Observation, encode, load_golden_observation
+from models.experimental.gr00t.reference.action_head import ActionHead, CrossForm
+from models.experimental.gr00t.reference.backbone import Backbone, BackboneInputs
+from models.experimental.gr00t.reference.sampler import EULER_DTYPES, AdaLNTables, FlowMatchingSampler
+
+# Seed the reference policies use for the flow-matching noise (module docstring).  CPU generator here.
+DEFAULT_NOISE_SEED: Mapping[str, int] = {"n15": 0, "n16": 42, "n17": 42}
+
+STAGES: Tuple[str, ...] = ("encode", "backbone", "head_prepare", "sampler", "decode", "total")
+
+
+@dataclass
+class ReferenceOutput:
+    """Everything one inference produced (``actions`` is ``None`` when no observation was decoded)."""
+
+    version: str
+    inputs: ModelInputs
+    noise: Tensor  # [1, H, max_action_dim] fp32, the x_0 actually integrated
+    backbone_features: Tensor  # [1, S, 2048] fp32
+    action_pred_normalized: Tensor  # [1, H, max_action_dim] fp32 (x_4)
+    actions: Optional[Dict[str, Tensor]]  # {group: [1, H, D] fp32 physical actions}
+    taps: Dict[str, Tensor] = field(default_factory=dict)
+    timing: Dict[str, float] = field(default_factory=dict)  # seconds per stage (STAGES)
+
+    @property
+    def seq_len(self) -> int:
+        return int(self.inputs.seq_len)
+
+    def valid_actions(self, spec: EmbodimentSpec) -> Tensor:
+        """``action_pred_normalized[:, :H, :D_real]`` -- the trained region (golden-tap-map §3.1 'valid slices')."""
+        return self.action_pred_normalized[:, : spec.action_horizon, : spec.action_dim]
+
+
+class Gr00tReference:
+    """fp32 CPU reference policy for one (version, embodiment) pair.
+
+    ::
+
+        ref = Gr00tReference("n17")                       # DROID slot 24, ~11 GB fp32 resident, ~1 s to build
+        actions = ref.get_action(observation, seed=42)    # {'eef_9d': [1, 40, 9], 'gripper_position': ..., ...}
+        out = ref.infer(observation, noise=golden_noise, return_taps=True)   # full result incl. taps and timing
+        out = ref.forward_from_inputs(model_inputs, noise)                   # from pre-encoded inputs (tests)
+
+    ``device`` / ``dtype`` are part of the signature for symmetry with the device model but only ``"cpu"`` /
+    ``torch.float32`` are implemented (the reference modules hold fp32 CPU buffers); anything else raises.
+    """
+
+    def __init__(
+        self,
+        version: str,
+        embodiment: Optional[str] = None,
+        device: Union[str, torch.device] = "cpu",
+        dtype: torch.dtype = torch.float32,
+        *,
+        checkpoint: Optional[LazyCheckpoint] = None,
+        euler_dtype: str = "fp32",
+        cross_form: CrossForm = "mask",
+        hoist_cross_kv: bool = False,
+        precompute_adaln: bool = False,
+    ):
+        if version not in GR00T_VERSIONS:
+            raise KeyError(f"unknown GR00T version {version!r}; expected one of {GR00T_VERSIONS}")
+        if torch.device(device).type != "cpu":
+            raise NotImplementedError(f"Gr00tReference runs on CPU only (got device={device!r})")
+        if dtype != torch.float32:
+            raise NotImplementedError(f"Gr00tReference is fp32 only (got dtype={dtype}); bf16 belongs to the tt/ model")
+        if euler_dtype not in EULER_DTYPES:
+            raise ValueError(f"euler_dtype must be one of {EULER_DTYPES}, got {euler_dtype!r}")
+        self.cfg: GR00TConfig = get_config(version)
+        self.version = version
+        self.device = torch.device(device)
+        self.dtype = dtype
+        self.euler_dtype = euler_dtype
+        self.cross_form: CrossForm = cross_form
+        self.hoist_cross_kv = hoist_cross_kv
+
+        tag = embodiment if embodiment is not None else self.cfg.canonical_embodiment
+        self.spec: EmbodimentSpec = get_embodiment_spec(version, tag)
+        self.embodiment_tag = tag
+        self.embodiment_id = int(self.spec.embodiment_id)
+        if self.embodiment_id != self.cfg.embodiment_id(tag):
+            raise ValueError(
+                f"{version}/{tag}: embodiment id {self.embodiment_id} (processor files) != {self.cfg.embodiment_id(tag)} (configs)"
+            )
+
+        t0 = time.perf_counter()
+        self.ck = checkpoint if checkpoint is not None else LazyCheckpoint(version)
+        self.backbone = Backbone(version, self.ck)
+        t1 = time.perf_counter()
+        self.head = ActionHead.from_checkpoint(version, self.embodiment_id, self.ck)
+        self.sampler = FlowMatchingSampler(self.head)
+        self.adaln_tables: Optional[AdaLNTables] = self.sampler.precompute_adaln() if precompute_adaln else None
+        t2 = time.perf_counter()
+        self.load_timing = {"backbone_s": t1 - t0, "head_s": t2 - t1, "total_s": t2 - t0}
+
+    # ------------------------------------------------------------------ host side
+    @property
+    def noise_shape(self) -> Tuple[int, int, int]:
+        return tuple(self.cfg.sampler.noise_shape)  # type: ignore[return-value]
+
+    def make_noise(self, seed: Optional[int] = None) -> Tensor:
+        """``randn(noise_shape)`` from a CPU generator seeded with ``seed`` (default: the version's reference seed)."""
+        s = int(DEFAULT_NOISE_SEED[self.version] if seed is None else seed)
+        g = torch.Generator(device="cpu").manual_seed(s)
+        return torch.randn(self.noise_shape, generator=g, dtype=torch.float32)
+
+    def _resolve_noise(self, noise: Optional[Tensor], seed: Optional[int]) -> Tensor:
+        if noise is not None:
+            if seed is not None:
+                raise ValueError("pass either noise or seed, not both")
+            if not isinstance(noise, Tensor):
+                raise TypeError(f"noise must be a torch.Tensor, got {type(noise).__name__}")
+            if tuple(noise.shape) != self.noise_shape:
+                raise ValueError(f"noise must have shape {self.noise_shape}, got {tuple(noise.shape)}")
+            if not noise.is_floating_point():
+                raise TypeError(f"noise must be floating point, got {noise.dtype}")
+            return noise.detach().to("cpu", torch.float32)
+        return self.make_noise(seed)
+
+    def encode(self, observation: Observation) -> ModelInputs:
+        """:func:`common.preprocessing.encode` for this model's embodiment (the observation's tag must agree)."""
+        if observation.embodiment_tag != self.embodiment_tag:
+            raise ValueError(
+                f"model is built for embodiment {self.embodiment_tag!r} (slot {self.embodiment_id}); "
+                f"observation carries {observation.embodiment_tag!r}"
+            )
+        return encode(self.version, observation, embodiment=self.embodiment_tag)
+
+    def backbone_inputs(self, mi: ModelInputs) -> BackboneInputs:
+        """Unpadded :class:`BackboneInputs` from the padded host layout of ``mi``.
+
+        The host tables live in the static ``S_pad`` layout (``static-shape-plan.md`` §4.3-4.4); real token ``i`` sits
+        at ``slot_of_token[i]``, so ``rope_cos[0, slot_of_token]`` is the ``[S, 128]`` table of the reference sequence
+        (N1.6 text-slot padding keeps position ``i`` for token ``i``, so this is the ``arange`` table; N1.7's mRoPE ids
+        are the golden ``llm_position_ids`` for the first ``S`` tokens, ``foundation-f2-host.md`` §2).
+        """
+        if mi.version != self.version:
+            raise ValueError(f"inputs are for {mi.version}, model is {self.version}")
+        if int(mi.embodiment_id.reshape(-1)[0]) != self.embodiment_id:
+            raise ValueError(
+                f"inputs carry embodiment slot {int(mi.embodiment_id.reshape(-1)[0])}, model {self.embodiment_id}"
+            )
+        if mi.input_ids.shape != (1, mi.seq_len) or mi.attention_mask.shape != (1, mi.seq_len):
+            raise ValueError(f"input_ids / attention_mask must be [1, S={mi.seq_len}]")
+        if not bool((mi.attention_mask != 0).all()):
+            raise ValueError("the reference backbone runs the unpadded B=1 sequence; attention_mask must be all ones")
+        slot = mi.slots.slot_of_token
+        if tuple(slot.shape) != (mi.seq_len,):
+            raise ValueError(f"slot_of_token must be [S], got {tuple(slot.shape)}")
+        rope_cos = mi.rope_cos[0][slot]
+        rope_sin = mi.rope_sin[0][slot]
+        position_ids = None
+        if self.version == "n17":
+            if mi.position_ids.ndim != 3 or mi.position_ids.shape[:2] != (3, 1):
+                raise ValueError(f"N1.7 position_ids must be [3, 1, S_pad], got {tuple(mi.position_ids.shape)}")
+            position_ids = mi.position_ids[:, 0, :][:, slot]
+        return self.backbone.prepare_inputs(
+            mi.input_ids[0],
+            mi.pixel_values,
+            image_grid_thw=mi.image_grid_thw,
+            rope_cos=rope_cos,
+            rope_sin=rope_sin,
+            position_ids=position_ids,
+        )
+
+    # ------------------------------------------------------------------ model
+    @torch.no_grad()
+    def forward_from_inputs(
+        self,
+        inputs: ModelInputs,
+        noise: Optional[Tensor] = None,
+        seed: Optional[int] = None,
+        return_taps: bool = False,
+        *,
+        euler_dtype: Optional[str] = None,
+    ) -> ReferenceOutput:
+        """Backbone + action head + sampler on pre-encoded inputs -> normalised action chunk (no decode).
+
+        ``taps`` (when ``return_taps``) merges the backbone taps (``vit_*``, ``projector_*``, ``llm_*``,
+        ``backbone_features``), the head taps (``vlln_out`` ... ``action_pred_normalized``, per-step ``[k=<step>]``)
+        and the host tensors ``initial_noise``, ``image_mask``, ``backbone_attention_mask``, ``llm_rotary_cos/sin``,
+        ``llm_position_ids`` (N1.7) under the golden tap names of ``golden-tap-map-and-thresholds.md`` §2.
+        """
+        ed = self.euler_dtype if euler_dtype is None else euler_dtype
+        if ed not in EULER_DTYPES:
+            raise ValueError(f"euler_dtype must be one of {EULER_DTYPES}, got {ed!r}")
+        x0 = self._resolve_noise(noise, seed)
+        timing: Dict[str, float] = {}
+
+        t0 = time.perf_counter()
+        bi = self.backbone_inputs(inputs)
+        if return_taps:
+            features, taps = self.backbone(bi, return_taps=True)
+        else:
+            features, taps = self.backbone(bi), {}
+        t1 = time.perf_counter()
+        timing["backbone"] = t1 - t0
+
+        features_b = features[None]  # [1, S, 2048]
+        image_mask = bi.image_mask[None]
+        attn_mask = inputs.attention_mask.to(torch.bool)
+        head_taps: Optional[Dict[str, Tensor]] = taps if return_taps else None
+        cond = self.head.prepare(
+            features_b,
+            inputs.state,
+            inputs.embodiment_id,
+            image_mask,
+            attn_mask,
+            hoist_cross_kv=self.hoist_cross_kv,
+            taps=head_taps,
+        )
+        t2 = time.perf_counter()
+        timing["head_prepare"] = t2 - t1
+        x = self.sampler.sample(
+            x0, cond, tables=self.adaln_tables, cross_form=self.cross_form, euler_dtype=ed, taps=head_taps
+        )
+        t3 = time.perf_counter()
+        timing["sampler"] = t3 - t2
+        if return_taps:
+            taps["initial_noise"] = x0
+            taps["image_mask"] = image_mask
+            taps["backbone_attention_mask"] = attn_mask
+            taps["llm_rotary_cos"] = bi.rope_cos
+            taps["llm_rotary_sin"] = bi.rope_sin
+            if bi.position_ids is not None:
+                taps["llm_position_ids"] = bi.position_ids
+        if tuple(x.shape) != self.noise_shape:
+            raise AssertionError(f"sampler returned {tuple(x.shape)}, expected {self.noise_shape}")
+        return ReferenceOutput(
+            version=self.version,
+            inputs=inputs,
+            noise=x0,
+            backbone_features=features_b,
+            action_pred_normalized=x,
+            actions=None,
+            taps=taps,
+            timing=timing,
+        )
+
+    def decode(self, action_pred_normalized: Tensor, observation: Observation) -> Dict[str, Tensor]:
+        """:func:`common.normalization.decode` with this model's embodiment (the observation supplies the reference
+        state of RELATIVE keys)."""
+        if observation.embodiment_tag != self.embodiment_tag:
+            raise ValueError(f"observation embodiment {observation.embodiment_tag!r} != model {self.embodiment_tag!r}")
+        return normalization.decode(self.version, action_pred_normalized, observation, embodiment=self.embodiment_tag)
+
+    @torch.no_grad()
+    def infer(
+        self,
+        observation: Observation,
+        noise: Optional[Tensor] = None,
+        seed: Optional[int] = None,
+        return_taps: bool = False,
+        *,
+        euler_dtype: Optional[str] = None,
+    ) -> ReferenceOutput:
+        """encode -> forward -> decode; the full :class:`ReferenceOutput` with per-stage timing."""
+        t0 = time.perf_counter()
+        mi = self.encode(observation)
+        t1 = time.perf_counter()
+        out = self.forward_from_inputs(mi, noise=noise, seed=seed, return_taps=return_taps, euler_dtype=euler_dtype)
+        t2 = time.perf_counter()
+        out.actions = self.decode(out.action_pred_normalized, observation)
+        t3 = time.perf_counter()
+        out.timing["encode"] = t1 - t0
+        out.timing["decode"] = t3 - t2
+        out.timing["total"] = t3 - t0
+        return out
+
+    def get_action(
+        self, observation: Observation, noise: Optional[Tensor] = None, seed: Optional[int] = None
+    ) -> Dict[str, Tensor]:
+        """Raw observation -> ``{action key: physical action [1, H, D] fp32}`` (the policy API).
+
+        ``noise`` overrides the flow-matching x_0 (shape ``SamplerConfig.noise_shape``); otherwise it is drawn from a
+        CPU generator seeded with ``seed`` (default ``DEFAULT_NOISE_SEED[version]``).  Same seed -> bit-identical output.
+        """
+        return self.infer(observation, noise=noise, seed=seed).actions  # type: ignore[return-value]
+
+    __call__ = get_action
+
+    def __repr__(self) -> str:
+        return (
+            f"Gr00tReference({self.version}, embodiment={self.embodiment_tag!r} (slot {self.embodiment_id}), "
+            f"euler_dtype={self.euler_dtype!r}, cross_form={self.cross_form!r})"
+        )
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Golden-sample plumbing shared by the tests and the CLI
+# --------------------------------------------------------------------------------------------------------------------
+
+
+def golden_obs_dir(gs: GoldenSet) -> Path:
+    """``obs/`` directory next to the fp32 run of a golden sample (``golden/n15/obs``, ``golden/n16/fp32_math/obs``,
+    ``golden/n17/droid_fp32_sdpa/obs``, and the multi-sample equivalents)."""
+    d = gs.path("input_ids").parent.parent / "obs"
+    if not d.is_dir():
+        raise FileNotFoundError(f"{gs.version}/{gs.sample}: no obs/ directory at {d}")
+    return d
+
+
+def load_golden_sample(version: str, sample: Optional[str] = None) -> Tuple[GoldenSet, Observation]:
+    """``(GoldenSet, raw Observation)`` of a golden sample (``None`` / ``"canonical"``, an N1.7 extra, or a multi name)."""
+    gs = GoldenSet(version, sample)
+    obs = load_golden_observation(version, golden_obs_dir(gs))
+    return gs, obs
+
+
+def golden_sample_from_path(path: Union[str, Path]) -> Tuple[str, str]:
+    """Map a golden directory (``golden/n17``, ``golden/n17/g1_synthetic_fp32_sdpa``, ``golden/n15_multi/t3_s20_seed1``,
+    ``golden/n16_multi/t2_s50_fp32_sdpa``) to ``(version, sample name)``."""
+    p = Path(path).expanduser().resolve()
+    parts = p.parts
+    for i, part in enumerate(parts):
+        if part in GR00T_VERSIONS:
+            version = part
+            rest = parts[i + 1 :]
+            if not rest:
+                return version, "canonical"
+            if version == "n17" and len(rest) == 1:
+                name = rest[0]
+                for suffix in ("_fp32_sdpa", "_bf16_fa2"):
+                    if name.endswith(suffix):
+                        name = name[: -len(suffix)]
+                if name == "droid":
+                    return version, "canonical"
+                return version, name
+            raise ValueError(f"{p}: not a golden sample directory")
+        if part.endswith("_multi") and part[: -len("_multi")] in GR00T_VERSIONS:
+            version = part[: -len("_multi")]
+            rest = parts[i + 1 :]
+            if not rest:
+                raise ValueError(f"{p}: name the sample under {part}/")
+            name = rest[0]
+            if version == "n16":
+                for suffix in ("_fp32_sdpa", "_bf16_fa2"):
+                    if name.endswith(suffix):
+                        name = name[: -len(suffix)]
+            return version, name
+    raise ValueError(f"{p}: no GR00T version component in the path")
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Golden tap mapping (shared by tests/reference/test_e2e_vs_golden.py and run_reference.py)
+# --------------------------------------------------------------------------------------------------------------------
+
+
+# golden input tap -> key of ModelInputs.golden_inputs()
+GOLDEN_INPUT_KEYS: Dict[str, Dict[str, str]] = {
+    "n15": {
+        "input_ids": "eagle_input_ids",
+        "attention_mask": "eagle_attention_mask",
+        "pixel_values": "eagle_pixel_values",
+        "image_geometry": "eagle_image_sizes",
+        "state": "state",
+        "embodiment_id": "embodiment_id",
+    },
+    "n16": {
+        "input_ids": "input_ids",
+        "attention_mask": "attention_mask",
+        "pixel_values": "pixel_values.0",
+        "image_geometry": "image_sizes",
+        "state": "state",
+        "embodiment_id": "embodiment_id",
+    },
+    "n17": {
+        "input_ids": "input_ids",
+        "attention_mask": "attention_mask",
+        "pixel_values": "pixel_values",
+        "image_geometry": "image_grid_thw",
+        "state": "state",
+        "embodiment_id": "embodiment_id",
+    },
+}
+
+
+N16_WINDOWED_TAPS: Tuple[str, ...] = ("vit_embeddings", "vit_block_first", "vit_block_last")
+
+
+def n16_reverse_mapping(gs: GoldenSet) -> torch.Tensor:
+    p = gs.path("input_ids").parent / "vision_reverse_mapping.pt"
+    if not p.is_file():
+        raise FileNotFoundError(p)
+    rm = torch.load(p, map_location="cpu", weights_only=True)
+    if rm.ndim != 1 or rm.dtype != torch.int64:
+        raise ValueError(f"vision_reverse_mapping must be a 1-D int64 index, got {tuple(rm.shape)} {rm.dtype}")
+    return rm
+
+
+def n16_windowed_to_raster(gs: GoldenSet, ref: torch.Tensor) -> torch.Tensor:
+    """N1.6 vision goldens are stored in Eagle window order: ``golden[0][reverse_mapping]`` is raster order
+    (foundation-f3a §3), i.e. the order of the reference's ``vit_*`` taps."""
+    if ref.ndim != 3 or ref.shape[0] != 1:
+        raise ValueError(f"windowed vision golden must be [1, P, C], got {tuple(ref.shape)}")
+    return ref[0][n16_reverse_mapping(gs)][None]
+
+
+def n16_raster_to_windowed(gs: GoldenSet, got: torch.Tensor) -> torch.Tensor:
+    """Inverse of :func:`n16_windowed_to_raster` (for the official gate, which loads the windowed golden)."""
+    if got.ndim != 3 or got.shape[0] != 1:
+        raise ValueError(f"raster vision tensor must be [1, P, C], got {tuple(got.shape)}")
+    w = torch.empty_like(got)
+    w[0][n16_reverse_mapping(gs)] = got[0]
+    return w
+
+
+def reference_tap_tensor(out: ReferenceOutput, gs: GoldenSet, tap: str, kw: Dict[str, Any]) -> Optional[torch.Tensor]:
+    """The reference's counterpart of golden ``tap`` (``None`` when the reference has no such tensor)."""
+    v = gs.version
+    cfg = get_config(v)
+    taps = out.taps
+    if tap in GOLDEN_INPUT_KEYS[v]:
+        return out.inputs.golden_inputs()[GOLDEN_INPUT_KEYS[v][tap]]
+    if tap == "vit_embeddings":
+        return taps["vit_patch_embed"] if v == "n17" else taps["vit_embeddings"]  # N1.7 golden is PRE pos-add
+    if tap == "vit_block_first":
+        return taps["vit_block_0"]
+    if tap == "vit_block_last":
+        return taps[f"vit_block_{cfg.vision.n_layers - 1}"]
+    if tap == "vit_post_ln":
+        return taps.get("vit_post_ln")
+    if tap == "vit_deepstack_mergers":
+        return taps[f"vit_deepstack_{kw['deepstack']}"]
+    if tap == "llm_layer_first":
+        return taps["llm_layer_0"]
+    if tap == "llm_layer_last":
+        return taps[f"llm_layer_{cfg.llm.n_layers_executed - 1}"]
+    if tap == "action_pred_valid":
+        h, d = gs.valid_hd
+        return out.action_pred_normalized[:, :h, :d]
+    if tap == "unnormalized_actions":
+        if out.actions is None:
+            raise ValueError("decode() was not run")
+        return out.actions[kw["group"]]
+    if "step" in kw:
+        return taps.get(f"{tap}[k={kw['step']}]")
+    return taps.get(tap)  # projector_out, llm_*, backbone_*, image_mask, vlln_out, ..., action_pred_normalized
+
+
+def golden_tap_tensor(gs: GoldenSet, tap: str, kw: Dict[str, Any]) -> torch.Tensor:
+    ref = gs.load(tap, **kw)
+    if gs.version == "n16" and tap in N16_WINDOWED_TAPS:
+        ref = n16_windowed_to_raster(gs, ref)
+    return ref
+
+
+def reconcile_shape(got: torch.Tensor, ref: torch.Tensor) -> torch.Tensor:
+    """The reference drops the batch axis (``[S, C]`` vs golden ``[1, S, C]``; ``[3, S]`` vs ``[3, 1, S]``): reshape
+    when the element counts agree, raise otherwise."""
+    if tuple(got.shape) == tuple(ref.shape):
+        return got
+    if got.numel() == ref.numel():
+        return got.reshape(ref.shape)
+    raise ValueError(f"shape {tuple(got.shape)} vs golden {tuple(ref.shape)}")
+
+
+def summarize_timing(timing: Mapping[str, float]) -> str:
+    return " ".join(f"{k}={timing[k] * 1e3:.1f}ms" for k in STAGES if k in timing)
+
+
+__all__ = [
+    "DEFAULT_NOISE_SEED",
+    "GOLDEN_INPUT_KEYS",
+    "N16_WINDOWED_TAPS",
+    "STAGES",
+    "Gr00tReference",
+    "ReferenceOutput",
+    "golden_obs_dir",
+    "golden_sample_from_path",
+    "golden_tap_tensor",
+    "load_golden_sample",
+    "n16_raster_to_windowed",
+    "n16_reverse_mapping",
+    "n16_windowed_to_raster",
+    "reconcile_shape",
+    "reference_tap_tensor",
+    "summarize_timing",
+]

code/models/experimental/gr00t/reference/qwen3vl_vision.py

@@ -0,0 +1,381 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Qwen3-VL vision tower of GR00T N1.7 (``Qwen3VLVisionModel`` of Cosmos-Reason2-2B) in plain fp32 torch.
+
+Executable specification for the N1.7-only device tower (``01-architecture-synthesis.md`` §1.1 / §2.1 "Qwen3-VL vision
+block"; arch-n17 §2.2; ``host-layout-helpers-validation.md`` §2):
+
+* patch embedding ``Conv3d(3 -> 1024, (2, 16, 16))`` == ``Linear(1536 -> 1024)`` on the processor's ``(c, t, ph, pw)``
+  rows (no column permutation, ``host-layout`` §2.3); rows arrive in **merge-window order**
+  ``(grid_t, gh/2, gw/2, mh, mw)``;
+* learned ``pos_embed [2304, 1024]`` (48 x 48) bilinearly 4-tap interpolated to each image's ``(h, w)`` grid and permuted
+  to the same merge-window order, added once before block 0 (HF ``fast_pos_embed_interpolate``); the golden tap
+  ``vis_patch_embed_out`` is taken **before** this add;
+* 2-D RoPE theta 1e4, 16 frequencies per axis from full-resolution ``(row, col)`` patch coordinates, rotate-half layout
+  ``cos/sin [P, 64]``, applied in fp32 to q and k in **every** block (HF ``rot_pos_emb`` / ``apply_rotary_pos_emb_vision``);
+* 24 blocks ``x += attn(LN1 x); x += mlp(LN2 x)``: fused ``qkv Linear(1024 -> 3072)`` + bias split as
+  ``reshape(P, 3, 16, 64)``, ``proj``, scale ``64**-0.5``, bidirectional attention **per image** (``cu_seqlens``);
+  ``linear_fc1 1024 -> 4096`` GELU-tanh ``linear_fc2``; LN eps 1e-6 affine;
+* deepstack mergers after blocks 5 / 11 / 17 (post-concat LN(4096)) and the final ``merger`` (pre-concat LN(1024)),
+  each ``-> Linear(4096 -> 4096) -> GELU(erf) -> Linear(4096 -> 2048)``, grouping 4 consecutive rows.
+
+Host tables (``vision_pos_embeds``, ``vision_rope_tables``, ``vision_cu_seqlens``) are pure functions of ``grid_thw``;
+they are DEDUPE CANDIDATES with ``common/preprocessing.py``.  No ``ttnn`` import.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict, List, Optional, Sequence, Tuple
+
+import torch
+import torch.nn.functional as F
+
+from models.experimental.gr00t.reference.projectors import MergeMLPProjector, merge_consecutive_rows
+from models.experimental.gr00t.reference.qwen3 import apply_rope, rope_inv_freq
+from models.experimental.gr00t.reference.siglip import full_attention, gelu_tanh, layer_norm
+
+WeightGetter = Callable[[str], torch.Tensor]
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Host tables (functions of grid_thw only)
+# --------------------------------------------------------------------------------------------------------------------
+
+
+def _check_grid(grid_thw: torch.Tensor) -> None:
+    if grid_thw.ndim != 2 or grid_thw.shape[1] != 3:
+        raise ValueError(f"grid_thw must be [n_img, 3] (t, h, w), got {tuple(grid_thw.shape)}")
+
+
+def vision_pos_embeds(
+    pos_table: torch.Tensor, grid_thw: torch.Tensor, num_grid_per_side: int = 48, spatial_merge_size: int = 2
+) -> torch.Tensor:
+    """``[sum(t*h*w), D]`` position rows in merge-window order -- pure-torch copy of HF ``fast_pos_embed_interpolate``
+    (``modeling_qwen3_vl.py:642-701``; ``host-layout`` §2.4: taps ``linspace(0, 47, h)`` / ``linspace(0, 47, w)``,
+    floor/ceil corners clipped to 47, bilinear weights, then ``view(t, h/2, 2, w/2, 2, D).permute(0, 1, 3, 2, 4, 5)``).
+    """
+    _check_grid(grid_thw)
+    if pos_table.ndim != 2 or pos_table.shape[0] != num_grid_per_side**2:
+        raise ValueError(f"pos table {tuple(pos_table.shape)} is not {num_grid_per_side}^2 rows")
+    m = spatial_merge_size
+    out: List[torch.Tensor] = []
+    for t, h, w in grid_thw.tolist():
+        t, h, w = int(t), int(h), int(w)
+        if h % m or w % m:
+            raise ValueError(f"grid ({h}, {w}) not divisible by the merge size {m}")
+        h_idx = torch.linspace(0, num_grid_per_side - 1, h)
+        w_idx = torch.linspace(0, num_grid_per_side - 1, w)
+        h_floor = h_idx.int()
+        w_floor = w_idx.int()
+        h_ceil = (h_floor + 1).clip(max=num_grid_per_side - 1)
+        w_ceil = (w_floor + 1).clip(max=num_grid_per_side - 1)
+        dh = h_idx - h_floor
+        dw = w_idx - w_floor
+        base_h = (h_floor * num_grid_per_side).long()
+        base_h_ceil = (h_ceil * num_grid_per_side).long()
+        corners = [
+            (base_h[:, None] + w_floor.long()[None, :]).flatten(),
+            (base_h[:, None] + w_ceil.long()[None, :]).flatten(),
+            (base_h_ceil[:, None] + w_floor.long()[None, :]).flatten(),
+            (base_h_ceil[:, None] + w_ceil.long()[None, :]).flatten(),
+        ]
+        weights = [
+            ((1 - dh)[:, None] * (1 - dw)[None, :]).flatten(),
+            ((1 - dh)[:, None] * dw[None, :]).flatten(),
+            (dh[:, None] * (1 - dw)[None, :]).flatten(),
+            (dh[:, None] * dw[None, :]).flatten(),
+        ]
+        pe = pos_table[corners[0]] * weights[0][:, None]
+        for c, wt in zip(corners[1:], weights[1:]):
+            pe = pe + pos_table[c] * wt[:, None]
+        pe = pe.repeat(t, 1)
+        pe = pe.view(t, h // m, m, w // m, m, -1).permute(0, 1, 3, 2, 4, 5).reshape(t * h * w, -1)
+        out.append(pe)
+    return torch.cat(out, dim=0)
+
+
+def vision_rope_position_ids(grid_thw: torch.Tensor, spatial_merge_size: int = 2) -> torch.Tensor:
+    """``[P, 2]`` full-resolution ``(row, col)`` patch coordinates in merge-window order (HF ``rot_pos_emb``,
+    ``modeling_qwen3_vl.py:603-640``)."""
+    _check_grid(grid_thw)
+    m = spatial_merge_size
+    out: List[torch.Tensor] = []
+    for t, h, w in grid_thw.tolist():
+        t, h, w = int(t), int(h), int(w)
+        rows = torch.arange(h).view(h // m, m, 1, 1).expand(h // m, m, w // m, m).permute(0, 2, 1, 3).reshape(-1)
+        cols = torch.arange(w).view(1, 1, w // m, m).expand(h // m, m, w // m, m).permute(0, 2, 1, 3).reshape(-1)
+        out.append(torch.stack((rows, cols), dim=-1).repeat(t, 1))
+    return torch.cat(out, dim=0)
+
+
+def vision_rope_tables(
+    grid_thw: torch.Tensor, head_dim: int = 64, spatial_merge_size: int = 2, theta: float = 10000.0
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """``cos, sin [P, head_dim]``: ``emb[0:16] = row * inv_freq``, ``emb[16:32] = col * inv_freq`` (16 frequencies of
+    ``Qwen3VLVisionRotaryEmbedding(dim=32)``), duplicated to 64 (rotate-half layout); ``host-layout`` §2.5."""
+    pos = vision_rope_position_ids(grid_thw, spatial_merge_size)
+    inv = rope_inv_freq(head_dim // 2, theta)  # 16 frequencies (dim = head_dim/2 = 32 -> 16)
+    freqs = (pos.float()[:, :, None] * inv[None, None, :]).flatten(1)  # [P, 32] = (row freqs | col freqs)
+    emb = torch.cat((freqs, freqs), dim=-1)
+    return emb.cos(), emb.sin()
+
+
+def vision_cu_seqlens(grid_thw: torch.Tensor) -> List[int]:
+    """Attention segment boundaries ``[0, n_1, n_1 + n_2, …]``: one segment per frame per image (HF
+    ``repeat_interleave(h*w, t).cumsum``)."""
+    _check_grid(grid_thw)
+    bounds = [0]
+    for t, h, w in grid_thw.tolist():
+        for _ in range(int(t)):
+            bounds.append(bounds[-1] + int(h) * int(w))
+    return bounds
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Modules
+# --------------------------------------------------------------------------------------------------------------------
+
+
+class Qwen3VLPatchEmbed:
+    """``Linear(1536 -> 1024)`` + bias on ``(c, t, ph, pw)`` rows (``Conv3d`` kernel flattened by ``reshape``)."""
+
+    def __init__(self, weight: torch.Tensor, bias: torch.Tensor):
+        if weight.ndim == 5:
+            weight = weight.reshape(weight.shape[0], -1).contiguous()  # (c, t, ph, pw) column order, no permutation
+        if weight.ndim != 2 or bias.shape != (weight.shape[0],):
+            raise ValueError(f"patch weight/bias {tuple(weight.shape)} / {tuple(bias.shape)}")
+        self.weight, self.bias = weight, bias
+        self.in_features, self.hidden = weight.shape[1], weight.shape[0]
+
+    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        """``[P, 1536] -> [P, 1024]`` (the golden ``vis_patch_embed_out``, before the pos-embed add)."""
+        if pixel_values.ndim != 2 or pixel_values.shape[1] != self.in_features:
+            raise ValueError(f"pixel_values must be [P, {self.in_features}], got {tuple(pixel_values.shape)}")
+        return F.linear(pixel_values, self.weight, self.bias)
+
+    __call__ = forward
+
+
+class Qwen3VLVisionAttention:
+    """Fused-qkv bidirectional attention 16 x 64 with 2-D RoPE (fp32) and per-image segments."""
+
+    def __init__(
+        self, w_qkv: torch.Tensor, b_qkv: torch.Tensor, w_proj: torch.Tensor, b_proj: torch.Tensor, n_heads: int
+    ):
+        hidden = w_qkv.shape[1]
+        if tuple(w_qkv.shape) != (3 * hidden, hidden) or b_qkv.shape != (3 * hidden,):
+            raise ValueError(f"fused qkv {tuple(w_qkv.shape)} / {tuple(b_qkv.shape)} != (3*{hidden}, {hidden})")
+        if tuple(w_proj.shape) != (hidden, hidden) or b_proj.shape != (hidden,):
+            raise ValueError(f"proj {tuple(w_proj.shape)} / {tuple(b_proj.shape)}")
+        if hidden % n_heads:
+            raise ValueError(f"hidden {hidden} not divisible by {n_heads} heads")
+        self.w_qkv, self.b_qkv, self.w_proj, self.b_proj = w_qkv, b_qkv, w_proj, b_proj
+        self.n_heads = n_heads
+        self.head_dim = hidden // n_heads
+        self.scale = self.head_dim**-0.5
+
+    def forward(self, x: torch.Tensor, cos: torch.Tensor, sin: torch.Tensor, cu_seqlens: Sequence[int]) -> torch.Tensor:
+        """``x [P, C]``, ``cos/sin [P, head_dim]`` -> ``[P, C]``."""
+        p = x.shape[0]
+        h, d = self.n_heads, self.head_dim
+        q, k, v = F.linear(x, self.w_qkv, self.b_qkv).reshape(p, 3, h, d).permute(1, 2, 0, 3)  # each [H, P, d]
+        q = apply_rope(q.float(), cos, sin)
+        k = apply_rope(k.float(), cos, sin)
+        if cu_seqlens[0] != 0 or cu_seqlens[-1] != p:
+            raise ValueError(f"cu_seqlens {list(cu_seqlens)} do not cover {p} patches")
+        outs = []
+        for a, b in zip(cu_seqlens[:-1], cu_seqlens[1:]):
+            outs.append(full_attention(q[:, a:b], k[:, a:b], v[:, a:b], self.scale))
+        o = torch.cat(outs, dim=1).transpose(0, 1).reshape(p, h * d)
+        return F.linear(o, self.w_proj, self.b_proj)
+
+    __call__ = forward
+
+
+class Qwen3VLVisionBlock:
+    """``x += attn(LN1 x); x += fc2(gelu_tanh(fc1(LN2 x)))`` (``Qwen3VLVisionBlock``, LN eps 1e-6)."""
+
+    def __init__(
+        self,
+        ln1_w: torch.Tensor,
+        ln1_b: torch.Tensor,
+        attn: Qwen3VLVisionAttention,
+        ln2_w: torch.Tensor,
+        ln2_b: torch.Tensor,
+        fc1_w: torch.Tensor,
+        fc1_b: torch.Tensor,
+        fc2_w: torch.Tensor,
+        fc2_b: torch.Tensor,
+        eps: float,
+    ):
+        self.ln1_w, self.ln1_b, self.attn = ln1_w, ln1_b, attn
+        self.ln2_w, self.ln2_b = ln2_w, ln2_b
+        self.fc1_w, self.fc1_b, self.fc2_w, self.fc2_b = fc1_w, fc1_b, fc2_w, fc2_b
+        self.eps = eps
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        cos: torch.Tensor,
+        sin: torch.Tensor,
+        cu_seqlens: Sequence[int],
+        return_taps: bool = False,
+    ) -> Tuple[torch.Tensor, Dict[str, torch.Tensor]]:
+        h = layer_norm(x, self.ln1_w, self.ln1_b, self.eps)
+        a = self.attn(h, cos, sin, cu_seqlens)
+        x = x + a
+        h2 = layer_norm(x, self.ln2_w, self.ln2_b, self.eps)
+        m = F.linear(gelu_tanh(F.linear(h2, self.fc1_w, self.fc1_b)), self.fc2_w, self.fc2_b)
+        x = x + m
+        taps = {"ln1": h, "attn": a, "ln2": h2, "mlp": m} if return_taps else {}
+        return x, taps
+
+    __call__ = forward
+
+
+class Qwen3VLVisionEncoder:
+    """Patch embed + pos add -> 24 blocks (2-D RoPE, per-image attention) -> deepstack mergers + final merger."""
+
+    def __init__(
+        self,
+        patch_embed: Qwen3VLPatchEmbed,
+        pos_table: torch.Tensor,
+        blocks: Sequence[Qwen3VLVisionBlock],
+        merger: MergeMLPProjector,
+        deepstack_mergers: Sequence[MergeMLPProjector],
+        deepstack_layers: Sequence[int],
+        num_grid_per_side: int = 48,
+        spatial_merge_size: int = 2,
+        rope_theta: float = 10000.0,
+    ):
+        if len(deepstack_mergers) != len(deepstack_layers):
+            raise ValueError(f"{len(deepstack_mergers)} deepstack mergers for layers {tuple(deepstack_layers)}")
+        if merger.ln_position != "pre_concat" or any(m.ln_position != "post_concat" for m in deepstack_mergers):
+            raise ValueError("Qwen3-VL: final merger is pre-concat LN(1024), deepstack mergers post-concat LN(4096)")
+        self.patch_embed = patch_embed
+        self.pos_table = pos_table
+        self.blocks: List[Qwen3VLVisionBlock] = list(blocks)
+        self.merger = merger
+        self.deepstack_mergers: List[MergeMLPProjector] = list(deepstack_mergers)
+        self.deepstack_layers = tuple(deepstack_layers)
+        self.num_grid_per_side = num_grid_per_side
+        self.spatial_merge_size = spatial_merge_size
+        self.rope_theta = rope_theta
+        self.hidden = patch_embed.hidden
+        self.head_dim = blocks[0].attn.head_dim
+
+    @property
+    def n_layers(self) -> int:
+        return len(self.blocks)
+
+    def host_tables(self, grid_thw: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[int]]:
+        """``(pos_embeds [P, D], cos [P, hd], sin [P, hd], cu_seqlens)`` -- everything the device needs per layout."""
+        pos = vision_pos_embeds(self.pos_table, grid_thw, self.num_grid_per_side, self.spatial_merge_size)
+        cos, sin = vision_rope_tables(grid_thw, self.head_dim, self.spatial_merge_size, self.rope_theta)
+        return pos, cos, sin, vision_cu_seqlens(grid_thw)
+
+    def forward(
+        self,
+        pixel_values: torch.Tensor,
+        grid_thw: torch.Tensor,
+        return_taps: bool = False,
+        detail_blocks: Sequence[int] = (0,),
+    ) -> Tuple[torch.Tensor, List[torch.Tensor], Dict[str, torch.Tensor]]:
+        """``pixel_values [P, 1536]`` + ``grid_thw [n_img, 3]`` -> ``(image_embeds [P/4, 2048], deepstack [3 x [P/4, 2048]],
+        taps)``.  Taps: ``patch_embed`` (pre-pos), ``embeddings`` (post-pos), ``block_{i}``, ``block_{i}_{ln1,attn,ln2,mlp}``
+        for ``detail_blocks``, ``deepstack_{d}``, ``merger``."""
+        pos, cos, sin, cu = self.host_tables(grid_thw)
+        lin = self.patch_embed(pixel_values)
+        if lin.shape[0] != pos.shape[0]:
+            raise ValueError(f"{lin.shape[0]} patch rows but grid_thw implies {pos.shape[0]}")
+        x = lin + pos
+        taps: Dict[str, torch.Tensor] = {}
+        if return_taps:
+            taps["patch_embed"] = lin
+            taps["embeddings"] = x
+        deepstack: List[torch.Tensor] = []
+        for i, blk in enumerate(self.blocks):
+            x, bt = blk(x, cos, sin, cu, return_taps and i in detail_blocks)
+            if return_taps:
+                taps[f"block_{i}"] = x
+                for k, v in bt.items():
+                    taps[f"block_{i}_{k}"] = v
+            if i in self.deepstack_layers:
+                d = self.deepstack_layers.index(i)
+                feat, _ = self.deepstack_mergers[d](x, merge_consecutive_rows)
+                deepstack.append(feat)
+                if return_taps:
+                    taps[f"deepstack_{d}"] = feat
+        out, _ = self.merger(x, merge_consecutive_rows)
+        if return_taps:
+            taps["merger"] = out
+        return out, deepstack, taps
+
+    __call__ = forward
+
+    @classmethod
+    def from_getter(
+        cls,
+        w: WeightGetter,
+        n_layers: int,
+        n_heads: int,
+        ln_eps: float,
+        merger_ln_eps: float,
+        deepstack_layers: Sequence[int],
+        num_grid_per_side: int = 48,
+        spatial_merge_size: int = 2,
+        rope_theta: float = 10000.0,
+    ) -> "Qwen3VLVisionEncoder":
+        """Build from canonical keys under ``visual.`` (``patch_embed.proj.*``, ``pos_embed.weight``, ``blocks.N.*``,
+        ``merger.*``, ``deepstack_merger_list.k.*``; ``weight-loader-spec.md`` §2.3 / §4.2 N1.7)."""
+        patch = Qwen3VLPatchEmbed(w("patch_embed.proj.weight"), w("patch_embed.proj.bias"))
+        blocks = []
+        for i in range(n_layers):
+            p = f"blocks.{i}."
+            attn = Qwen3VLVisionAttention(
+                w(p + "attn.qkv.weight"),
+                w(p + "attn.qkv.bias"),
+                w(p + "attn.proj.weight"),
+                w(p + "attn.proj.bias"),
+                n_heads,
+            )
+            blocks.append(
+                Qwen3VLVisionBlock(
+                    w(p + "norm1.weight"),
+                    w(p + "norm1.bias"),
+                    attn,
+                    w(p + "norm2.weight"),
+                    w(p + "norm2.bias"),
+                    w(p + "mlp.linear_fc1.weight"),
+                    w(p + "mlp.linear_fc1.bias"),
+                    w(p + "mlp.linear_fc2.weight"),
+                    w(p + "mlp.linear_fc2.bias"),
+                    ln_eps,
+                )
+            )
+        merger = MergeMLPProjector.from_getter(
+            w, "merger.norm.", "merger.linear_fc1.", "merger.linear_fc2.", merger_ln_eps, "pre_concat"
+        )
+        deep = [
+            MergeMLPProjector.from_getter(
+                w,
+                f"deepstack_merger_list.{d}.norm.",
+                f"deepstack_merger_list.{d}.linear_fc1.",
+                f"deepstack_merger_list.{d}.linear_fc2.",
+                merger_ln_eps,
+                "post_concat",
+            )
+            for d in range(len(deepstack_layers))
+        ]
+        return cls(
+            patch,
+            w("pos_embed.weight"),
+            blocks,
+            merger,
+            deep,
+            deepstack_layers,
+            num_grid_per_side,
+            spatial_merge_size,
+            rope_theta,
+        )

code/models/experimental/gr00t/reference/sampler.py

@@ -0,0 +1,239 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Flow-matching Euler sampler of the GR00T action head (synthesis §1.6; arch-n15 §3.7, arch-n16 §7.6, arch-n17 §3.4).
+
+::
+
+    x_0 = noise                                   # [1, H, max_action_dim], supplied by the caller (all dims noisy)
+    for k in 0..3:  bucket_k = int(k / 4 * 1000)  # 0, 250, 500, 750
+        v_k = head(x_k, bucket_k)                 # velocity = decoder rows -H:
+        x_{k+1} = x_k + 0.25 * v_k
+    return x_4                                    # normalised action chunk
+
+Two device-oriented decompositions are available and asserted equal to the live path by the tests:
+
+* :func:`precompute_adaln_tables` -- every timestep-dependent vector (``temb``, per-block ``(1 + scale, shift)``, output
+  head ``(1 + scale, shift)``) for the 4 fixed buckets, computed from the raw ``norm1.linear`` / ``proj_out_1`` /
+  timestep-encoder weights (weight-loader-spec.md §4.6 'precompute'); ``FlowMatchingSampler.sample(tables=...)`` runs
+  the DiT with them instead of the live timestep encoder.
+* ``hoist_cross_kv=True`` -- cross-attention K/V of the 8 / 16 cross blocks computed once from the gathered key subset
+  and reused for the 4 steps (arch-n15 §3.6).
+
+Euler dtype conventions (golden-tap-map-and-thresholds.md §2.1, ``SamplerConfig.euler_dtype``):
+
+* ``"fp32"``                          -- the fp32 goldens: everything fp32 (default here).
+* ``"fp32_actions_bf16_velocity"``    -- N1.5 official autocast path: actions stay fp32, ``0.25 * bf16(v)`` added.
+* ``"bf16"``                          -- N1.6 / N1.7 official path: ``bf16(bf16(x) + 0.25 * bf16(v))``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Sequence, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+from models.experimental.gr00t.common.configs import SamplerConfig
+from models.experimental.gr00t.reference.action_head import ActionHead, Conditioning, CrossForm, DiT, StepModulation
+
+EULER_DTYPES: Tuple[str, ...] = ("fp32", "fp32_actions_bf16_velocity", "bf16")
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Precomputed AdaLN tables
+# --------------------------------------------------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class AdaLNTables:
+    """``(1 + scale, shift)`` of every DiT block and of the output head, plus ``temb``, for each sampler bucket.
+
+    ``steps[i]`` is the :class:`StepModulation` of ``buckets[i]``; :meth:`as_tensor` packs the modulation vectors into
+    one ``[n_steps, 2 * n_blocks + 2, 1536]`` table (row order: block0 one_plus_scale, block0 shift, block1 ..., head
+    one_plus_scale, head shift) -- the layout a device port would upload (weight-loader §4.6 'layout options').
+    """
+
+    buckets: Tuple[int, ...]
+    steps: Tuple[StepModulation, ...]
+
+    def step(self, k: int) -> StepModulation:
+        return self.steps[k]
+
+    def for_bucket(self, bucket: int) -> StepModulation:
+        for s in self.steps:
+            if s.bucket == bucket:
+                return s
+        raise KeyError(f"no precomputed modulation for bucket {bucket}; have {self.buckets}")
+
+    @property
+    def n_blocks(self) -> int:
+        return self.steps[0].n_blocks
+
+    @property
+    def n_vectors(self) -> int:
+        """Modulation vectors stored (excluding ``temb``): ``n_steps * (2 * n_blocks + 2)`` = 136 (N1.5) / 264 (N1.6, N1.7)."""
+        return len(self.steps) * (2 * self.n_blocks + 2)
+
+    def as_tensor(self) -> Tensor:
+        rows = []
+        for s in self.steps:
+            vecs = []
+            for o, sh in zip(s.block_one_plus_scale, s.block_shift):
+                vecs += [o, sh]
+            vecs += [s.head_one_plus_scale, s.head_shift]
+            rows.append(torch.cat(vecs, dim=0))
+        return torch.stack(rows, dim=0)
+
+
+def precompute_adaln_tables(dit: DiT, buckets: Sequence[int] = (0, 250, 500, 750)) -> AdaLNTables:
+    """Host-side precompute of weight-loader-spec.md §4.6 from the raw weights (independent of ``DiT.modulation``)::
+
+    proj  = [cos e, sin e],  e = t * exp(-ln(1e4) * arange(128) / 127)
+    temb  = W2 @ silu(W1 @ proj + b1) + b2
+    s     = silu(temb)
+    block: scale, shift = (Wn @ s + bn).chunk(2)   -> (1 + scale, shift)        (scale FIRST)
+    head:  shift, scale = (Wp @ s + bp).chunk(2)   -> (1 + scale, shift)        (shift FIRST)
+    """
+    steps = []
+    te = dit.timestep_encoder
+    for b in buckets:
+        proj = te.projection(int(b))
+        temb = F.linear(
+            F.silu(F.linear(proj, te.linear_1.weight, te.linear_1.bias)), te.linear_2.weight, te.linear_2.bias
+        )
+        s = F.silu(temb)
+        ops, shs = [], []
+        for blk in dit.blocks:
+            scale, shift = F.linear(s, blk.norm1.linear.weight, blk.norm1.linear.bias).chunk(2, dim=-1)
+            ops.append(1.0 + scale)
+            shs.append(shift)
+        h_shift, h_scale = F.linear(s, dit.out.proj_out_1.weight, dit.out.proj_out_1.bias).chunk(2, dim=-1)
+        steps.append(StepModulation(int(b), temb, tuple(ops), tuple(shs), 1.0 + h_scale, h_shift))
+    return AdaLNTables(tuple(int(b) for b in buckets), tuple(steps))
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Euler update
+# --------------------------------------------------------------------------------------------------------------------
+
+
+def euler_update(actions: Tensor, velocity: Tensor, dt: float, euler_dtype: str = "fp32") -> Tensor:
+    """``x + dt * v`` under one of the three reference dtype conventions (golden-tap-map §2.1 'Euler update dtype').
+
+    Returns fp32 in every mode (the bf16 modes return bf16-representable values)."""
+    if tuple(actions.shape) != tuple(velocity.shape):
+        raise ValueError(f"actions {tuple(actions.shape)} vs velocity {tuple(velocity.shape)}")
+    if euler_dtype == "fp32":
+        return actions.to(torch.float32) + dt * velocity.to(torch.float32)
+    if euler_dtype == "fp32_actions_bf16_velocity":
+        # autocast: the decoder output is bf16, `dt * v` stays bf16 (dt = 0.25 is exact), fp32 + bf16 -> fp32
+        return actions.to(torch.float32) + (dt * velocity.to(torch.bfloat16)).to(torch.float32)
+    if euler_dtype == "bf16":
+        v = velocity.to(torch.bfloat16)
+        return (actions.to(torch.bfloat16) + dt * v).to(torch.float32)
+    raise ValueError(f"euler_dtype must be one of {EULER_DTYPES}, got {euler_dtype!r}")
+
+
+# --------------------------------------------------------------------------------------------------------------------
+# Sampler
+# --------------------------------------------------------------------------------------------------------------------
+
+
+class FlowMatchingSampler:
+    """4-step Euler flow matching over an :class:`ActionHead` (``SamplerConfig`` of the version)."""
+
+    def __init__(self, head: ActionHead, cfg: Optional[SamplerConfig] = None):
+        self.head = head
+        self.cfg = cfg if cfg is not None else head.cfg.sampler
+        if self.cfg.timestep_buckets != tuple(
+            self.cfg.timestep_bucket(k) for k in range(self.cfg.num_inference_timesteps)
+        ):
+            raise ValueError("SamplerConfig buckets are inconsistent with int(k / N * buckets)")
+        if abs(self.cfg.dt - 1.0 / self.cfg.num_inference_timesteps) > 1e-12:
+            raise ValueError("SamplerConfig.dt != 1 / num_inference_timesteps")
+
+    @property
+    def buckets(self) -> Tuple[int, ...]:
+        return self.cfg.timestep_buckets
+
+    def precompute_adaln(self) -> AdaLNTables:
+        return precompute_adaln_tables(self.head.dit, self.buckets)
+
+    @torch.no_grad()
+    def sample(
+        self,
+        noise: Tensor,
+        cond: Conditioning,
+        *,
+        tables: Optional[AdaLNTables] = None,
+        cross_form: CrossForm = "mask",
+        euler_dtype: str = "fp32",
+        taps: Optional[Dict[str, Tensor]] = None,
+    ) -> Tensor:
+        """Integrate from ``noise`` (``[1, H, max_action_dim]``) to the normalised action chunk.
+
+        ``taps`` (optional dict) receives every per-step tap under the golden key convention ``"<tap>[k=<step>]"``
+        (``noisy_actions_in``, ``timestep``, ``action_encoder_out``, ``sa_embs``, ``temb``, ``dit_block{i}_out``,
+        ``dit_block_last_out``, ``dit_out``, ``action_decoder_out``, ``pred_velocity``, ``actions_out``) and the final
+        ``action_pred_normalized``.
+        """
+        if euler_dtype not in EULER_DTYPES:
+            raise ValueError(f"euler_dtype must be one of {EULER_DTYPES}, got {euler_dtype!r}")
+        if tuple(noise.shape) != self.cfg.noise_shape:
+            raise ValueError(f"noise must be {self.cfg.noise_shape}, got {tuple(noise.shape)}")
+        x = noise.to(torch.float32)
+        if euler_dtype == "bf16":
+            x = x.to(torch.bfloat16).to(torch.float32)  # the official path feeds bf16(noise) (golden-tap-map §1)
+        for k in range(self.cfg.num_inference_timesteps):
+            bucket = self.cfg.timestep_bucket(k)
+            suffix = f"[k={k}]"
+            mod = tables.for_bucket(bucket) if tables is not None else None
+            v = self.head.denoise_step(
+                x, bucket, cond, modulation=mod, cross_form=cross_form, taps=taps, tap_suffix=suffix
+            )
+            x = euler_update(x, v, self.cfg.dt, euler_dtype)
+            if taps is not None:
+                taps["actions_out" + suffix] = x
+        if taps is not None:
+            taps["action_pred_normalized"] = x
+        return x
+
+    @torch.no_grad()
+    def run(
+        self,
+        backbone_features: Tensor,
+        state: Tensor,
+        embodiment_id,
+        noise: Tensor,
+        image_mask: Optional[Tensor] = None,
+        backbone_attention_mask: Optional[Tensor] = None,
+        *,
+        hoist_cross_kv: bool = False,
+        tables: Optional[AdaLNTables] = None,
+        cross_form: CrossForm = "mask",
+        euler_dtype: str = "fp32",
+        return_taps: bool = False,
+    ) -> Tuple[Tensor, Dict[str, Tensor]]:
+        """``prepare`` + ``sample``; returns ``(action_pred_normalized, taps)`` (``taps`` empty unless requested)."""
+        taps: Dict[str, Tensor] = {}
+        cond = self.head.prepare(
+            backbone_features,
+            state,
+            embodiment_id,
+            image_mask,
+            backbone_attention_mask,
+            hoist_cross_kv=hoist_cross_kv,
+            taps=taps if return_taps else None,
+        )
+        x = self.sample(
+            noise,
+            cond,
+            tables=tables,
+            cross_form=cross_form,
+            euler_dtype=euler_dtype,
+            taps=taps if return_taps else None,
+        )
+        return x, taps

code/models/experimental/gr00t/tests/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0

code/scripts/bench_http.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: © 2026 Tenstorrent USA, Inc.
+# SPDX-License-Identifier: Apache-2.0
+"""HTTP latency of a running GR00T policy server: POST the shipped demo observation N times and report medians.
+
+Standard library only.  The numbers are the server's own ``timing_ms`` fields (``device`` = the four Metal trace
+replays incl. input upload and the action readback; ``total`` = the whole ``/predict`` handler) plus the client's
+wall-clock per request on the same host (adds JSON encode/decode and HTTP framing).
+
+    python scripts/bench_http.py --url http://127.0.0.1:20000 [--reps 50] [--warmup 10] [--out bench.json]
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import statistics
+import sys
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any, Dict, List
+
+HERE = Path(__file__).resolve().parent
+DEMO_ROOT = HERE.parent / "gr00t_p150" / "demo"
+
+
+def load_request(demo_dir: Path, use_noise: bool) -> Dict[str, Any]:
+    with open(demo_dir / "observation.json") as fh:
+        obs = json.load(fh)
+    images = {
+        cam: [base64.b64encode((demo_dir / f).read_bytes()).decode("ascii") for f in files]
+        for cam, files in obs["cameras"].items()
+    }
+    req: Dict[str, Any] = {
+        "images": images,
+        "state": obs["state"],
+        "instruction": obs["instruction"],
+        "embodiment": obs["embodiment"],
+        "state_dtype": obs["state_dtype"],
+    }
+    if use_noise:
+        with open(demo_dir / "noise.json") as fh:
+            req["noise"] = json.load(fh)["data"]
+    return req
+
+
+def post(url: str, payload: bytes, timeout: float = 120.0) -> Dict[str, Any]:
+    r = urllib.request.Request(url, data=payload, headers={"Content-Type": "application/json"}, method="POST")
+    with urllib.request.urlopen(r, timeout=timeout) as resp:
+        if resp.status != 200:
+            raise RuntimeError(f"HTTP {resp.status}")
+        return json.loads(resp.read().decode())
+
+
+def pct(xs: List[float], q: float) -> float:
+    ys = sorted(xs)
+    k = max(0, min(len(ys) - 1, int(round(q * (len(ys) - 1)))))
+    return ys[k]
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--url", default="http://127.0.0.1:20000")
+    ap.add_argument("--reps", type=int, default=50)
+    ap.add_argument("--warmup", type=int, default=10)
+    ap.add_argument("--version", default=None, choices=["n15", "n16"], help="default: what /info reports")
+    ap.add_argument("--demo-dir", type=Path, default=None)
+    ap.add_argument(
+        "--seed-path", action="store_true", help="use the server's default seed instead of the golden noise"
+    )
+    ap.add_argument("--out", type=Path, default=None)
+    args = ap.parse_args()
+    url = args.url.rstrip("/")
+
+    with urllib.request.urlopen(f"{url}/info", timeout=30) as resp:
+        info = json.loads(resp.read().decode())
+    version = args.version or info.get("version")
+    demo_dir = args.demo_dir or (DEMO_ROOT / str(version))
+    payload = json.dumps(load_request(demo_dir, use_noise=not args.seed_path)).encode()
+
+    for _ in range(args.warmup):
+        post(f"{url}/predict", payload)
+    keys = ("decode", "encode", "device", "decode_actions", "total")
+    series: Dict[str, List[float]] = {k: [] for k in keys}
+    wall: List[float] = []
+    for _ in range(args.reps):
+        t0 = time.perf_counter()
+        r = post(f"{url}/predict", payload)
+        wall.append((time.perf_counter() - t0) * 1000.0)
+        for k in keys:
+            series[k].append(float(r["timing_ms"][k]))
+    summary: Dict[str, Any] = {
+        "url": url,
+        "model": info.get("name"),
+        "version": version,
+        "reps": args.reps,
+        "warmup": args.warmup,
+        "payload_bytes": len(payload),
+        "request": "demo observation" + (" + server default seed" if args.seed_path else " + golden noise"),
+        "timing_ms": {
+            k: {"median": statistics.median(v), "p90": pct(v, 0.9), "min": min(v), "max": max(v)}
+            for k, v in series.items()
+        },
+        "client_wall_ms": {
+            "median": statistics.median(wall),
+            "p90": pct(wall, 0.9),
+            "min": min(wall),
+            "max": max(wall),
+        },
+        "warmup_latency_ms": info.get("warmup_latency_ms"),
+    }
+    if args.out:
+        args.out.write_text(json.dumps(summary, indent=1))
+    t = summary["timing_ms"]
+    print(
+        f"{info.get('name')} {version}: n={args.reps} device median {t['device']['median']:.2f} ms (p90 {t['device']['p90']:.2f}) "
+        f"total median {t['total']['median']:.2f} ms (p90 {t['total']['p90']:.2f}) "
+        f"[decode {t['decode']['median']:.2f} encode {t['encode']['median']:.2f} decode_actions {t['decode_actions']['median']:.2f}] "
+        f"client wall median {summary['client_wall_ms']['median']:.1f} ms (p90 {summary['client_wall_ms']['p90']:.1f})"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

code/scripts/download_weights.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: Apache-2.0
+# Fetch the pinned nvidia/GR00T-N1.5-3B snapshot the GR00T-N1.5-3B-p150 package serves, into the HF cache
+# (`tt-model serve` does this automatically; this script is for host runs / offline hosts).
+# The weights are NVIDIA's (NVIDIA License, non-commercial use) -- read LICENSE in the snapshot before use.
+#
+#   bash scripts/download_weights.sh                      # -> ~/.cache/huggingface/hub/models--nvidia--GR00T-N1.5-3B/snapshots/869830fc.../
+#   HF_HOME=/some/dir bash scripts/download_weights.sh    # another hub cache (the server reads HF_HUB_CACHE / HF_HOME / ~/.cache/huggingface)
+set -euo pipefail
+REPO=nvidia/GR00T-N1.5-3B
+REVISION=869830fc749c35f34771aa5209f923ac57e4564e
+PY=${PYTHON:-python3}
+"$PY" - "$REPO" "$REVISION" <<'PY'
+import sys
+from huggingface_hub import snapshot_download
+
+repo, revision = sys.argv[1], sys.argv[2]
+patterns = ["model-*.safetensors", "model.safetensors.index.json", "config.json", "experiment_cfg/metadata.json", "LICENSE"]
+path = snapshot_download(repo_id=repo, revision=revision, allow_patterns=patterns)
+print(f"{repo} @ {revision}\n  -> {path}")
+PY

image/blobs/sha256/0b8bee58599dd50ebcc83819b473ea1eb586d722ee381103cbef6f32a1e1c780

@@ -0,0 +1 @@
+{"id":"7b14b5cfd31bdadda5d107644c6d4efdae9384a0386f40d03255eed4ce6c802d","parent":"19231fda800e2539c6e4cfd611e94b121ced3a710ae534efd4540cda9975f19a","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/1d1bc46ff8841de85f975ecd5e1203308bc2d6faf331d4aa9427d032f4fcc935

@@ -0,0 +1 @@
+{"id":"12d7cd873a75dd244c2f4c5376f0d6229f3d2c7f6270529efb2ec48c2b4081ef","parent":"5fb45e015e46e543747edd8c207913a9958ec718389d215335ae76c9e4e5ae37","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/370bb95b39281a3ded169a86bb7972b898b349503342e491db98470ce5b1af87

@@ -0,0 +1 @@
+{"id":"0b2d0a5af285ce86b6328abd3d09c8d698930ebed015cb00934c6cf8d5f81a49","parent":"8239f5f3bd9364f3693079f7feb5552c0d2076ca9c7ff66c247bdf4a982bcf0b","created":"2026-09-15T00:28:43.990879611+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"config":{"Hostname":"","Domainname":"","User":"tt","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":["PATH=/opt/tt-venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin","VENV=/opt/tt-venv","VIRTUAL_ENV=/opt/tt-venv","TT_METAL_RUNTIME_ROOT=/opt/tt-metal","TT_METAL_HOME=/opt/tt-metal","PYTHONPATH=/opt/tt-metal","LD_LIBRARY_PATH=/opt/tt-metal/build/lib:/opt/openmpi-v5.0.7-ulfm/lib","EXTRA_MODELS_DIR=","TT_VLLM_BUILTIN_MODELS=","TT_MODEL_KIND=tt-dit-server","HF_HOME=/hf","TT_METAL_CACHE=/cache","HOME=/home/tt","USER=tt","LOGNAME=tt"],"Cmd":["/usr/local/bin/serve-default.sh"],"ArgsEscaped":true,"Image":"","Volumes":null,"WorkingDir":"/home/tt/work","Entrypoint":["/usr/local/bin/entrypoint.sh"],"OnBuild":null,"Labels":{"org.opencontainers.image.revision":"668c290757550588d0ce46b180c344a462a2aaf5","org.opencontainers.image.version":"22.04","org.tenstorrent.tt-model":"gr00t-n1.5-3b-p150","org.tenstorrent.tt-model.arch":"blackhole","org.tenstorrent.tt-model.kind":"tt-dit-server","org.tenstorrent.tt-model.plugin":"","org.tenstorrent.tt-model.profiles":"default","org.tenstorrent.tt-model.repo":"changh95/GR00T-N1.5-3B-p150","org.tenstorrent.tt-model.tt-metal":"v0.79.0-dev20260914-1-g668c290757","org.tenstorrent.tt-model.weights":"nvidia/GR00T-N1.5-3B"}},"architecture":"amd64","os":"linux"}

image/blobs/sha256/3ac026cc87fbebb2f96c2cffe83a97e3c0593da7fd6dd97bbdbd84f934ab0751

@@ -0,0 +1 @@
+{"id":"81ded9a441b8b3eb72ecaf63ca8fc877b095eff468cffb70c172e1b43bf79f82","parent":"91c1d01879c35e53047eb2b7f5e2ed76b29667e4892c58a8b719492e8c885e06","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/443501bd3b7afce579bf743eeedd64809886653c29a9d7125614e8451cd61a7b

@@ -0,0 +1 @@
+{"architecture":"amd64","config":{"User":"tt","Env":["PATH=/opt/tt-venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin","VENV=/opt/tt-venv","VIRTUAL_ENV=/opt/tt-venv","TT_METAL_RUNTIME_ROOT=/opt/tt-metal","TT_METAL_HOME=/opt/tt-metal","PYTHONPATH=/opt/tt-metal","LD_LIBRARY_PATH=/opt/tt-metal/build/lib:/opt/openmpi-v5.0.7-ulfm/lib","EXTRA_MODELS_DIR=","TT_VLLM_BUILTIN_MODELS=","TT_MODEL_KIND=tt-dit-server","HF_HOME=/hf","TT_METAL_CACHE=/cache","HOME=/home/tt","USER=tt","LOGNAME=tt"],"Entrypoint":["/usr/local/bin/entrypoint.sh"],"Cmd":["/usr/local/bin/serve-default.sh"],"WorkingDir":"/home/tt/work","Labels":{"org.opencontainers.image.revision":"668c290757550588d0ce46b180c344a462a2aaf5","org.opencontainers.image.version":"22.04","org.tenstorrent.tt-model":"gr00t-n1.5-3b-p150","org.tenstorrent.tt-model.arch":"blackhole","org.tenstorrent.tt-model.kind":"tt-dit-server","org.tenstorrent.tt-model.plugin":"","org.tenstorrent.tt-model.profiles":"default","org.tenstorrent.tt-model.repo":"changh95/GR00T-N1.5-3B-p150","org.tenstorrent.tt-model.tt-metal":"v0.79.0-dev20260914-1-g668c290757","org.tenstorrent.tt-model.weights":"nvidia/GR00T-N1.5-3B"},"ArgsEscaped":true},"created":"2026-09-15T00:28:43.990879611+09:00","history":[{"created":"2026-09-03T12:14:51.139348462Z","created_by":"/bin/sh -c #(nop)  ARG RELEASE","empty_layer":true},{"created":"2026-09-03T12:14:51.170427469Z","created_by":"/bin/sh -c #(nop)  ARG LAUNCHPAD_BUILD_ARCH","empty_layer":true},{"created":"2026-09-03T12:14:51.200307479Z","created_by":"/bin/sh -c #(nop)  LABEL org.opencontainers.image.version=22.04","empty_layer":true},{"created":"2026-09-03T12:14:53.528689977Z","created_by":"/bin/sh -c #(nop) ADD file:81c01921c5f642ac2fcbfae682e489e8e64b347467d9fa1587707e310e64d790 in / "},{"created":"2026-09-03T12:14:54.045714841Z","created_by":"/bin/sh -c #(nop)  CMD [\"/bin/bash\"]","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG OMPI_DIR=/opt/openmpi-v5.0.7-ulfm","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG EXTRA_MODELS_DIR=","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG TT_MODEL_KIND","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_NAME","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_REPO","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_WEIGHTS","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_ARCH","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_PROFILES","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_TT_METAL_SHA","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_TT_METAL_DESCRIBE","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"ARG MODEL_PLUGIN_SHA","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:17:44.55093893+09:00","created_by":"RUN |11 OMPI_DIR=/opt/openmpi-v5.0.7-ulfm EXTRA_MODELS_DIR= TT_MODEL_KIND=tt-dit-server MODEL_NAME=gr00t-n1.5-3b-p150 MODEL_REPO=changh95/GR00T-N1.5-3B-p150 MODEL_WEIGHTS=nvidia/GR00T-N1.5-3B MODEL_ARCH=blackhole MODEL_PROFILES=default MODEL_TT_METAL_SHA=668c290757550588d0ce46b180c344a462a2aaf5 MODEL_TT_METAL_DESCRIBE=v0.79.0-dev20260914-1-g668c290757 MODEL_PLUGIN_SHA= /bin/sh -c apt-get update \u0026\u0026 apt-get install -y --no-install-recommends     libhwloc15 libnuma1 libatomic1 libudev1 libcap2 zlib1g     libmpc3 libmpfr6 libgmp10 libzstd1     libevent-core-2.1-7 libevent-pthreads-2.1-7     libgl1 libsndfile1 ca-certificates     \u0026\u0026 apt-get clean \u0026\u0026 rm -rf /var/lib/apt/lists/* # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:17:45.103027718+09:00","created_by":"RUN |11 OMPI_DIR=/opt/openmpi-v5.0.7-ulfm EXTRA_MODELS_DIR= TT_MODEL_KIND=tt-dit-server MODEL_NAME=gr00t-n1.5-3b-p150 MODEL_REPO=changh95/GR00T-N1.5-3B-p150 MODEL_WEIGHTS=nvidia/GR00T-N1.5-3B MODEL_ARCH=blackhole MODEL_PROFILES=default MODEL_TT_METAL_SHA=668c290757550588d0ce46b180c344a462a2aaf5 MODEL_TT_METAL_DESCRIBE=v0.79.0-dev20260914-1-g668c290757 MODEL_PLUGIN_SHA= /bin/sh -c existing=\"$(getent passwd 1000 | cut -d: -f1)\"     \u0026\u0026 if [ -n \"$existing\" ]; then          userdel -r \"$existing\" 2\u003e/dev/null || userdel \"$existing\";        fi     \u0026\u0026 useradd --uid 1000 --create-home --home-dir /home/tt --shell /bin/bash tt     \u0026\u0026 mkdir -p /home/tt/work/logs /cache /opt/tt-metal     \u0026\u0026 chown -R tt:tt /home/tt /cache /opt/tt-metal     \u0026\u0026 chmod 1777 /home/tt /home/tt/work /home/tt/work/logs /cache # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:26:50.12099139+09:00","created_by":"COPY /opt/openmpi-v5.0.7-ulfm /opt/openmpi-v5.0.7-ulfm # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:26:56.859028587+09:00","created_by":"COPY /opt/tenstorrent /opt/tenstorrent # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:26:57.871714714+09:00","created_by":"COPY /usr/local/share/uv /usr/local/share/uv # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:01.173123316+09:00","created_by":"COPY /opt/tt-venv /opt/tt-venv # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:01.349280216+09:00","created_by":"COPY /opt/vllm /opt/vllm # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:06.182311758+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/runtime /opt/tt-metal/runtime # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:10.459270679+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/build_Release /opt/tt-metal/build_Release # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:14.890865208+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/build /opt/tt-metal/build # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:22.091999446+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/tt_metal /opt/tt-metal/tt_metal # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:25.597581517+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/ttnn /opt/tt-metal/ttnn # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:26.78141524+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/tools /opt/tt-metal/tools # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:27.818810081+09:00","created_by":"COPY --chown=tt:tt /opt/tt-metal/setup.py /opt/tt-metal/pyproject.toml /opt/tt-metal/ # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:29.056067419+09:00","created_by":"COPY --chown=tt:tt code/ /opt/tt-metal/ # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:29.869952207+09:00","created_by":"COPY entrypoint.sh /usr/local/bin/entrypoint.sh # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"COPY --chmod=0755 serve-default.sh /usr/local/bin/serve-default.sh # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV VENV=/opt/tt-venv","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV VIRTUAL_ENV=/opt/tt-venv","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV PATH=/opt/tt-venv/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV TT_METAL_RUNTIME_ROOT=/opt/tt-metal","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV TT_METAL_HOME=/opt/tt-metal","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV PYTHONPATH=/opt/tt-metal","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV LD_LIBRARY_PATH=/opt/tt-metal/build/lib:/opt/openmpi-v5.0.7-ulfm/lib","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV EXTRA_MODELS_DIR=","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ARG TT_VLLM_BUILTIN_MODELS=","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV TT_VLLM_BUILTIN_MODELS=","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV TT_MODEL_KIND=tt-dit-server","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV HF_HOME=/hf","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV TT_METAL_CACHE=/cache","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV HOME=/home/tt","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV USER=tt","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"ENV LOGNAME=tt","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:30.701160452+09:00","created_by":"USER tt","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:27:31.7325366+09:00","created_by":"WORKDIR /home/tt/work","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:27:32.54518317+09:00","created_by":"COPY verify.sh /ctx/verify.sh # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:28:40.774081382+09:00","created_by":"RUN |12 OMPI_DIR=/opt/openmpi-v5.0.7-ulfm EXTRA_MODELS_DIR= TT_MODEL_KIND=tt-dit-server MODEL_NAME=gr00t-n1.5-3b-p150 MODEL_REPO=changh95/GR00T-N1.5-3B-p150 MODEL_WEIGHTS=nvidia/GR00T-N1.5-3B MODEL_ARCH=blackhole MODEL_PROFILES=default MODEL_TT_METAL_SHA=668c290757550588d0ce46b180c344a462a2aaf5 MODEL_TT_METAL_DESCRIBE=v0.79.0-dev20260914-1-g668c290757 MODEL_PLUGIN_SHA= TT_VLLM_BUILTIN_MODELS= /bin/sh -c bash /ctx/verify.sh # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:28:40.774081382+09:00","created_by":"USER root","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:28:43.990879611+09:00","created_by":"RUN |12 OMPI_DIR=/opt/openmpi-v5.0.7-ulfm EXTRA_MODELS_DIR= TT_MODEL_KIND=tt-dit-server MODEL_NAME=gr00t-n1.5-3b-p150 MODEL_REPO=changh95/GR00T-N1.5-3B-p150 MODEL_WEIGHTS=nvidia/GR00T-N1.5-3B MODEL_ARCH=blackhole MODEL_PROFILES=default MODEL_TT_METAL_SHA=668c290757550588d0ce46b180c344a462a2aaf5 MODEL_TT_METAL_DESCRIBE=v0.79.0-dev20260914-1-g668c290757 MODEL_PLUGIN_SHA= TT_VLLM_BUILTIN_MODELS= /bin/sh -c chmod -R a+rwX /home/tt # buildkit","comment":"buildkit.dockerfile.v0"},{"created":"2026-09-15T00:28:43.990879611+09:00","created_by":"USER tt","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:28:43.990879611+09:00","created_by":"LABEL org.tenstorrent.tt-model=gr00t-n1.5-3b-p150 org.tenstorrent.tt-model.repo=changh95/GR00T-N1.5-3B-p150 org.tenstorrent.tt-model.weights=nvidia/GR00T-N1.5-3B org.tenstorrent.tt-model.arch=blackhole org.tenstorrent.tt-model.kind=tt-dit-server org.tenstorrent.tt-model.profiles=default org.opencontainers.image.revision=668c290757550588d0ce46b180c344a462a2aaf5 org.tenstorrent.tt-model.tt-metal=v0.79.0-dev20260914-1-g668c290757 org.tenstorrent.tt-model.plugin=","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:28:43.990879611+09:00","created_by":"ENTRYPOINT [\"/usr/local/bin/entrypoint.sh\"]","comment":"buildkit.dockerfile.v0","empty_layer":true},{"created":"2026-09-15T00:28:43.990879611+09:00","created_by":"CMD [\"/usr/local/bin/serve-default.sh\"]","comment":"buildkit.dockerfile.v0","empty_layer":true}],"os":"linux","rootfs":{"type":"layers","diff_ids":["sha256:ea16cace89338c84eb6bcb91a7efdfcae6838fff359efe951858227436486c34","sha256:51823e2af991bff33ffec20f249ee6bdb4314e7b9cbdf91000f1d4f4a71e0012","sha256:ae776143cc7af24f72a82ba98ae76acb15de31e0367d51325d34a2c0ae9774b1","sha256:5a589f1aa835965af711da5a5217b53178226a35f12d46b268f651f27f50ab66","sha256:20cad74cf2e0718048ce7cad5032e4837d231af0ead9812353883170b27a8c89","sha256:8b5207d0ea018af069c35032458560c4f7228bdbd7be56f83c2c8d38720c48ad","sha256:96d36b6a923d9a423d4d024e1d8b2865ba17630ff6c943b8b5399135262a392c","sha256:bfb33d6feff769cce24063505762c22c182208e1c678d9f5d5024e09736323ed","sha256:a94f59fd3b1e98f96650b4d704cd34b87a23cf6663284a9e7450054eb6655b1e","sha256:d30f4ffbfa0e22bdd84b1f348824e7ac9852f52aad62567398dc32bc64b833f6","sha256:61e58277f929e3e211f0f965b1ed7e676f7cb507da697ebfaaeb031d50881155","sha256:ab1563d57f53302f322fde8a9eca85f76b8df4c53f5e5475747ef187aae66cfd","sha256:5de3eb86f710f06651b3ea02c107f8a5eb867c64f9d11c430af796102fcfe6f9","sha256:45d79cfe2597546eebcbb17d2d8fed625efbed07554b30ee8f2220ae6b74a6e9","sha256:ff89efbc286d449abab8814120c65f02fc6c051c498d955f18566cd0734a95d8","sha256:e72991f8dede710d8265ab8a49bd37bddfd9b4958934fa6f69e7f15c3c904c49","sha256:2368844ee84552082aa5dffa46d1d10eeb7ae2ca19b2b8a7dfeda01bd0569dac","sha256:9800a286b1c10fea7a3d177d6a9c1972383e555aa42fddfa538286053c654623","sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef","sha256:cfcbdcb92afa4680baac457e629510a6e55667a2c45d208620d6dcdc94a44e9c","sha256:1746b32b74db4426d73b785ed8574fea5e421dee1d36bc62b81613901dd15a1e","sha256:4d0e7c32d9164b460304d93dc180502d9492beffb5914aaa43ab93d98c14f97c"]}}

image/blobs/sha256/4568a8cf3754ec6555dfd72c99498a8a6d81c756cb843f869c32db42000f4f07

@@ -0,0 +1 @@
+{"id":"1ac9704e2f8a4d5d29fa88659ad705d2f16158f8312222b98570272754200b1c","parent":"6b74c1ea99d52673ac6ef692bd3c5873d2de286a0fcc425753fdb131eb99aa72","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/514ee738d1ef907136a924293b5033e43461f7b14c90428f3fdaf082d4bca600

@@ -0,0 +1 @@
+{"id":"19231fda800e2539c6e4cfd611e94b121ced3a710ae534efd4540cda9975f19a","parent":"2936fcd1226666b3c2513e2825f14e5a99c3ff4fc9dd24ac8741571d6c1fecf6","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/5628e13ce208b83d793af15fa41c28d1702e7a43e27c8c72944442d01e959a71

@@ -0,0 +1 @@
+{"id":"e618d643825753f4550a54eacfd500e6e7652078cf4168c9ef3f869701db7fc5","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/5f1f271cd6c23c85e2bbe2b1601abb2143184d033d1e93853029f959402b64c3

@@ -0,0 +1 @@
+{"id":"17be60e495073261a8d023e6447bf638526af346e74fc420cbb2bfb54d996833","parent":"6ecf5ff235091d534b1398dc7b8a249889b15a958fb4788a3c109c4b350dd8d2","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/60d99486d4e943a3a234fd3001d031f22c99fa65f933b048f3bc272051148d81

@@ -0,0 +1 @@
+{"id":"f0c5ef0e38047417380a9c2efe4dab8455a6bb182f3308c79c98664a50bac4c0","parent":"17be60e495073261a8d023e6447bf638526af346e74fc420cbb2bfb54d996833","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/6c3dd1840f3cb732d89c764a387e4742bffa52990892993301bc49819ef39be5

@@ -0,0 +1 @@
+{"id":"8239f5f3bd9364f3693079f7feb5552c0d2076ca9c7ff66c247bdf4a982bcf0b","parent":"1238be44de2e9550ca38cfe414ec5326953ed54dc9ae503f3cba1025dab6a2c5","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/746d6df035900c8d4ad4ad98c30b5cd4050eb272fb1ef5d19d0330c27a38f18e

@@ -0,0 +1 @@
+{"id":"91c1d01879c35e53047eb2b7f5e2ed76b29667e4892c58a8b719492e8c885e06","parent":"2da341b5a7879df7bf157e6bb65cd528dfbd1bcf928107a2c9511c5c1b3cdaf7","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/75df73761a6599a1f76198e180ea6ea4845564fd787cdb1a85bb96fc9490e4e2

@@ -0,0 +1 @@
+{"id":"a14eec88ef93717bfe2b45846415b064324e5996669e7e7f3e1707632801c805","parent":"1ac9704e2f8a4d5d29fa88659ad705d2f16158f8312222b98570272754200b1c","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/7da1668187b2357115d5ede196f3848c315c32695c103c2991fe8d09bcea1fb5

@@ -0,0 +1 @@
+{"id":"5fb45e015e46e543747edd8c207913a9958ec718389d215335ae76c9e4e5ae37","parent":"7b14b5cfd31bdadda5d107644c6d4efdae9384a0386f40d03255eed4ce6c802d","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/8836ac07b9ab1d87c8f9759bcc86240cb196a2de00ed7efbd06d8b91b25cd4d9

@@ -0,0 +1 @@
+{"id":"2da341b5a7879df7bf157e6bb65cd528dfbd1bcf928107a2c9511c5c1b3cdaf7","parent":"14ed07f3336ada962a82269352e617a0bf348e6f425b7533c44244530a1187b0","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/8b2c5066cae93333c326dc28469add1060522ce7553473cc67a464531afd31e9

@@ -0,0 +1 @@
+{"id":"2936fcd1226666b3c2513e2825f14e5a99c3ff4fc9dd24ac8741571d6c1fecf6","parent":"1031dddc9543787c54ae3956c460ec749c1a3e798c8f05b25c3e8455de1ed974","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/92387b8093f65f78b3f65ac14f4c1fface25891d185815c29ca124a9cacb5a9e

@@ -0,0 +1 @@
+{"id":"1031dddc9543787c54ae3956c460ec749c1a3e798c8f05b25c3e8455de1ed974","parent":"5a10e48ae8d8ff84ab16cfca7e66bfb43764d2d85c829945921d4af55f5dc3cd","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/95a774a140ea0bdf3c88f347e5a26834bef4d22301cd5300cc925c9cd0a728dd

@@ -0,0 +1 @@
+{"id":"5a10e48ae8d8ff84ab16cfca7e66bfb43764d2d85c829945921d4af55f5dc3cd","parent":"f0c5ef0e38047417380a9c2efe4dab8455a6bb182f3308c79c98664a50bac4c0","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/a2491fe22925746efefa576db546cd62a39b33b9378a7205bb119d6f5a2d06b4

@@ -0,0 +1 @@
+{"id":"6ecf5ff235091d534b1398dc7b8a249889b15a958fb4788a3c109c4b350dd8d2","parent":"e618d643825753f4550a54eacfd500e6e7652078cf4168c9ef3f869701db7fc5","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/ceda6a792461a030c40385b7e455fcfd3b56ab238855e2af19f623ff962e325a

@@ -0,0 +1 @@
+{"schemaVersion":2,"mediaType":"application/vnd.oci.image.manifest.v1+json","config":{"mediaType":"application/vnd.oci.image.config.v1+json","digest":"sha256:443501bd3b7afce579bf743eeedd64809886653c29a9d7125614e8451cd61a7b","size":14429},"layers":[{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:ea16cace89338c84eb6bcb91a7efdfcae6838fff359efe951858227436486c34","size":80641024},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:51823e2af991bff33ffec20f249ee6bdb4314e7b9cbdf91000f1d4f4a71e0012","size":204086784},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:ae776143cc7af24f72a82ba98ae76acb15de31e0367d51325d34a2c0ae9774b1","size":352256},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:5a589f1aa835965af711da5a5217b53178226a35f12d46b268f651f27f50ab66","size":33464832},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:20cad74cf2e0718048ce7cad5032e4837d231af0ead9812353883170b27a8c89","size":454126592},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:8b5207d0ea018af069c35032458560c4f7228bdbd7be56f83c2c8d38720c48ad","size":187652608},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:96d36b6a923d9a423d4d024e1d8b2865ba17630ff6c943b8b5399135262a392c","size":1245465600},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:bfb33d6feff769cce24063505762c22c182208e1c678d9f5d5024e09736323ed","size":2048},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:a94f59fd3b1e98f96650b4d704cd34b87a23cf6663284a9e7450054eb6655b1e","size":454626304},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:d30f4ffbfa0e22bdd84b1f348824e7ac9852f52aad62567398dc32bc64b833f6","size":136048640},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:61e58277f929e3e211f0f965b1ed7e676f7cb507da697ebfaaeb031d50881155","size":136048640},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:ab1563d57f53302f322fde8a9eca85f76b8df4c53f5e5475747ef187aae66cfd","size":195663360},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:5de3eb86f710f06651b3ea02c107f8a5eb867c64f9d11c430af796102fcfe6f9","size":69021184},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:45d79cfe2597546eebcbb17d2d8fed625efbed07554b30ee8f2220ae6b74a6e9","size":5885952},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:ff89efbc286d449abab8814120c65f02fc6c051c498d955f18566cd0734a95d8","size":23040},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:e72991f8dede710d8265ab8a49bd37bddfd9b4958934fa6f69e7f15c3c904c49","size":10117632},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:2368844ee84552082aa5dffa46d1d10eeb7ae2ca19b2b8a7dfeda01bd0569dac","size":4608},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:9800a286b1c10fea7a3d177d6a9c1972383e555aa42fddfa538286053c654623","size":5120},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef","size":1024},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:cfcbdcb92afa4680baac457e629510a6e55667a2c45d208620d6dcdc94a44e9c","size":6144},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:1746b32b74db4426d73b785ed8574fea5e421dee1d36bc62b81613901dd15a1e","size":1684480},{"mediaType":"application/vnd.oci.image.layer.v1.tar","digest":"sha256:4d0e7c32d9164b460304d93dc180502d9492beffb5914aaa43ab93d98c14f97c","size":39936}]}

image/blobs/sha256/dfdf267c677095544bf7ac50b1a0f6678eb93662a45aeb30f77f976ac4ace6de

@@ -0,0 +1 @@
+{"id":"00f2159936b314d8fbbbd37a75ac10517a79e0da0c80bdb4b8b4b1a1cda406f1","parent":"12d7cd873a75dd244c2f4c5376f0d6229f3d2c7f6270529efb2ec48c2b4081ef","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/e0c4814cde1d85e88a2dd6121d00c886b5b04f8206434ec4a0e14aca6a8a1769

@@ -0,0 +1 @@
+{"id":"6b74c1ea99d52673ac6ef692bd3c5873d2de286a0fcc425753fdb131eb99aa72","parent":"81ded9a441b8b3eb72ecaf63ca8fc877b095eff468cffb70c172e1b43bf79f82","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/e13438a9103dc3ce3126a1a1711007fdf9c31bfabfeadeae010327901fc39b88

@@ -0,0 +1 @@
+{"id":"1238be44de2e9550ca38cfe414ec5326953ed54dc9ae503f3cba1025dab6a2c5","parent":"a14eec88ef93717bfe2b45846415b064324e5996669e7e7f3e1707632801c805","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/blobs/sha256/e8d4979d8340f3b13fb626dab5702018f87bd5b44295909f6fdd0c2734a7910f

@@ -0,0 +1 @@
+{"id":"14ed07f3336ada962a82269352e617a0bf348e6f425b7533c44244530a1187b0","parent":"00f2159936b314d8fbbbd37a75ac10517a79e0da0c80bdb4b8b4b1a1cda406f1","created":"1970-01-01T09:00:00+09:00","container_config":{"Hostname":"","Domainname":"","User":"","AttachStdin":false,"AttachStdout":false,"AttachStderr":false,"Tty":false,"OpenStdin":false,"StdinOnce":false,"Env":null,"Cmd":null,"Image":"","Volumes":null,"WorkingDir":"","Entrypoint":null,"OnBuild":null,"Labels":null},"os":"linux"}

image/index.json

@@ -0,0 +1 @@
+{"schemaVersion":2,"mediaType":"application/vnd.oci.image.index.v1+json","manifests":[{"mediaType":"application/vnd.oci.image.manifest.v1+json","digest":"sha256:ceda6a792461a030c40385b7e455fcfd3b56ab238855e2af19f623ff962e325a","size":3616,"annotations":{"io.containerd.image.name":"docker.io/tt-model/gr00t-n1.5-3b-p150:443501bd3b7a","org.opencontainers.image.ref.name":"443501bd3b7a"}}]}

image/manifest.json

@@ -0,0 +1 @@
+[{"Config":"blobs/sha256/443501bd3b7afce579bf743eeedd64809886653c29a9d7125614e8451cd61a7b","RepoTags":["tt-model/gr00t-n1.5-3b-p150:443501bd3b7a"],"Layers":["blobs/sha256/ea16cace89338c84eb6bcb91a7efdfcae6838fff359efe951858227436486c34","blobs/sha256/51823e2af991bff33ffec20f249ee6bdb4314e7b9cbdf91000f1d4f4a71e0012","blobs/sha256/ae776143cc7af24f72a82ba98ae76acb15de31e0367d51325d34a2c0ae9774b1","blobs/sha256/5a589f1aa835965af711da5a5217b53178226a35f12d46b268f651f27f50ab66","blobs/sha256/20cad74cf2e0718048ce7cad5032e4837d231af0ead9812353883170b27a8c89","blobs/sha256/8b5207d0ea018af069c35032458560c4f7228bdbd7be56f83c2c8d38720c48ad","blobs/sha256/96d36b6a923d9a423d4d024e1d8b2865ba17630ff6c943b8b5399135262a392c","blobs/sha256/bfb33d6feff769cce24063505762c22c182208e1c678d9f5d5024e09736323ed","blobs/sha256/a94f59fd3b1e98f96650b4d704cd34b87a23cf6663284a9e7450054eb6655b1e","blobs/sha256/d30f4ffbfa0e22bdd84b1f348824e7ac9852f52aad62567398dc32bc64b833f6","blobs/sha256/61e58277f929e3e211f0f965b1ed7e676f7cb507da697ebfaaeb031d50881155","blobs/sha256/ab1563d57f53302f322fde8a9eca85f76b8df4c53f5e5475747ef187aae66cfd","blobs/sha256/5de3eb86f710f06651b3ea02c107f8a5eb867c64f9d11c430af796102fcfe6f9","blobs/sha256/45d79cfe2597546eebcbb17d2d8fed625efbed07554b30ee8f2220ae6b74a6e9","blobs/sha256/ff89efbc286d449abab8814120c65f02fc6c051c498d955f18566cd0734a95d8","blobs/sha256/e72991f8dede710d8265ab8a49bd37bddfd9b4958934fa6f69e7f15c3c904c49","blobs/sha256/2368844ee84552082aa5dffa46d1d10eeb7ae2ca19b2b8a7dfeda01bd0569dac","blobs/sha256/9800a286b1c10fea7a3d177d6a9c1972383e555aa42fddfa538286053c654623","blobs/sha256/5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef","blobs/sha256/cfcbdcb92afa4680baac457e629510a6e55667a2c45d208620d6dcdc94a44e9c","blobs/sha256/1746b32b74db4426d73b785ed8574fea5e421dee1d36bc62b81613901dd15a1e","blobs/sha256/4d0e7c32d9164b460304d93dc180502d9492beffb5914aaa43ab93d98c14f97c"],"LayerSources":{"sha256:1746b32b74db4426d73b785ed8574fea5e421dee1d36bc62b81613901dd15a1e":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":1684480,"digest":"sha256:1746b32b74db4426d73b785ed8574fea5e421dee1d36bc62b81613901dd15a1e"},"sha256:20cad74cf2e0718048ce7cad5032e4837d231af0ead9812353883170b27a8c89":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":454126592,"digest":"sha256:20cad74cf2e0718048ce7cad5032e4837d231af0ead9812353883170b27a8c89"},"sha256:2368844ee84552082aa5dffa46d1d10eeb7ae2ca19b2b8a7dfeda01bd0569dac":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":4608,"digest":"sha256:2368844ee84552082aa5dffa46d1d10eeb7ae2ca19b2b8a7dfeda01bd0569dac"},"sha256:45d79cfe2597546eebcbb17d2d8fed625efbed07554b30ee8f2220ae6b74a6e9":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":5885952,"digest":"sha256:45d79cfe2597546eebcbb17d2d8fed625efbed07554b30ee8f2220ae6b74a6e9"},"sha256:4d0e7c32d9164b460304d93dc180502d9492beffb5914aaa43ab93d98c14f97c":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":39936,"digest":"sha256:4d0e7c32d9164b460304d93dc180502d9492beffb5914aaa43ab93d98c14f97c"},"sha256:51823e2af991bff33ffec20f249ee6bdb4314e7b9cbdf91000f1d4f4a71e0012":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":204086784,"digest":"sha256:51823e2af991bff33ffec20f249ee6bdb4314e7b9cbdf91000f1d4f4a71e0012"},"sha256:5a589f1aa835965af711da5a5217b53178226a35f12d46b268f651f27f50ab66":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":33464832,"digest":"sha256:5a589f1aa835965af711da5a5217b53178226a35f12d46b268f651f27f50ab66"},"sha256:5de3eb86f710f06651b3ea02c107f8a5eb867c64f9d11c430af796102fcfe6f9":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":69021184,"digest":"sha256:5de3eb86f710f06651b3ea02c107f8a5eb867c64f9d11c430af796102fcfe6f9"},"sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":1024,"digest":"sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef"},"sha256:61e58277f929e3e211f0f965b1ed7e676f7cb507da697ebfaaeb031d50881155":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":136048640,"digest":"sha256:61e58277f929e3e211f0f965b1ed7e676f7cb507da697ebfaaeb031d50881155"},"sha256:8b5207d0ea018af069c35032458560c4f7228bdbd7be56f83c2c8d38720c48ad":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":187652608,"digest":"sha256:8b5207d0ea018af069c35032458560c4f7228bdbd7be56f83c2c8d38720c48ad"},"sha256:96d36b6a923d9a423d4d024e1d8b2865ba17630ff6c943b8b5399135262a392c":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":1245465600,"digest":"sha256:96d36b6a923d9a423d4d024e1d8b2865ba17630ff6c943b8b5399135262a392c"},"sha256:9800a286b1c10fea7a3d177d6a9c1972383e555aa42fddfa538286053c654623":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":5120,"digest":"sha256:9800a286b1c10fea7a3d177d6a9c1972383e555aa42fddfa538286053c654623"},"sha256:a94f59fd3b1e98f96650b4d704cd34b87a23cf6663284a9e7450054eb6655b1e":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":454626304,"digest":"sha256:a94f59fd3b1e98f96650b4d704cd34b87a23cf6663284a9e7450054eb6655b1e"},"sha256:ab1563d57f53302f322fde8a9eca85f76b8df4c53f5e5475747ef187aae66cfd":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":195663360,"digest":"sha256:ab1563d57f53302f322fde8a9eca85f76b8df4c53f5e5475747ef187aae66cfd"},"sha256:ae776143cc7af24f72a82ba98ae76acb15de31e0367d51325d34a2c0ae9774b1":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":352256,"digest":"sha256:ae776143cc7af24f72a82ba98ae76acb15de31e0367d51325d34a2c0ae9774b1"},"sha256:bfb33d6feff769cce24063505762c22c182208e1c678d9f5d5024e09736323ed":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":2048,"digest":"sha256:bfb33d6feff769cce24063505762c22c182208e1c678d9f5d5024e09736323ed"},"sha256:cfcbdcb92afa4680baac457e629510a6e55667a2c45d208620d6dcdc94a44e9c":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":6144,"digest":"sha256:cfcbdcb92afa4680baac457e629510a6e55667a2c45d208620d6dcdc94a44e9c"},"sha256:d30f4ffbfa0e22bdd84b1f348824e7ac9852f52aad62567398dc32bc64b833f6":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":136048640,"digest":"sha256:d30f4ffbfa0e22bdd84b1f348824e7ac9852f52aad62567398dc32bc64b833f6"},"sha256:e72991f8dede710d8265ab8a49bd37bddfd9b4958934fa6f69e7f15c3c904c49":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":10117632,"digest":"sha256:e72991f8dede710d8265ab8a49bd37bddfd9b4958934fa6f69e7f15c3c904c49"},"sha256:ea16cace89338c84eb6bcb91a7efdfcae6838fff359efe951858227436486c34":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":80641024,"digest":"sha256:ea16cace89338c84eb6bcb91a7efdfcae6838fff359efe951858227436486c34"},"sha256:ff89efbc286d449abab8814120c65f02fc6c051c498d955f18566cd0734a95d8":{"mediaType":"application/vnd.oci.image.layer.v1.tar","size":23040,"digest":"sha256:ff89efbc286d449abab8814120c65f02fc6c051c498d955f18566cd0734a95d8"}}}]

image/oci-layout

@@ -0,0 +1 @@
+{"imageLayoutVersion": "1.0.0"}

image/repositories

@@ -0,0 +1 @@
+{"tt-model/gr00t-n1.5-3b-p150":{"443501bd3b7a":"4d0e7c32d9164b460304d93dc180502d9492beffb5914aaa43ab93d98c14f97c"}}

requirements.lock

@@ -0,0 +1,87 @@
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anyio==4.15.1
+certifi==2026.7.22
+cfgv==3.5.0
+charset-normalizer==3.5.1
+click==8.5.0
+contourpy==1.3.3
+cycler==0.12.1
+distlib==0.4.3
+distro==1.9.0
+elastic-transport==9.4.2
+elasticsearch==9.5.1
+fastapi==0.141.1
+filelock==3.32.6
+fonttools==4.65.0
+fsspec==2026.7.0
+graphviz==0.21
+h11==0.16.0
+hf-xet==1.6.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.31.0
+identify==2.6.19
+idna==3.19
+iniconfig==2.3.0
+Jinja2==3.1.6
+kiwisolver==1.5.1
+linkify-it-py==2.2.0
+loguru==0.7.3
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+matplotlib==3.11.2
+mdit-py-plugins==0.6.1
+mdurl==0.1.2
+ml_dtypes==0.5.4
+mpmath==1.3.0
+networkx==3.6.1
+nodeenv==1.10.0
+numpy==1.26.4
+opencv-python-headless==4.8.1.78
+packaging==26.3
+pandas==3.0.5
+pillow==12.3.0
+platformdirs==4.11.8
+pluggy==1.6.0
+pre_commit==4.6.2
+psutil==7.2.2
+pydantic==2.13.5
+pydantic_core==2.46.5
+Pygments==2.21.0
+pyluwen==0.9.0
+pyparsing==3.3.2
+pytest==9.1.1
+python-dateutil==2.9.0.post0
+python-discovery==1.6.0
+PyYAML==6.0.3
+regex==2026.9.10
+requests==2.34.2
+rich==15.0.0
+safetensors==0.8.0
+seaborn==0.13.2
+setuptools==80.10.2
+setuptools-scm==8.1.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==1.6.0
+sympy==1.14.0
+textual==8.2.8
+tokenizers==0.22.2
+tomli==2.4.1
+torch==2.11.0+cpu
+torchvision==0.26.0+cpu
+tqdm==4.70.1
+transformers==5.12.1
+tt-smi==6.5.0
+tt-tools-common==1.6.0
+tt-umd==0.9.10
+ttnn==0.65.2.dev10011
+typer==0.27.2
+typing-inspection==0.4.4
+typing_extensions==4.16.0
+urllib3==2.7.0
+uvicorn==0.53.0
+virtualenv==21.7.9
+wheel==0.48.0

tt_kernel_manifest.json

@@ -0,0 +1,138 @@
+{
+  "schema_version": "5.1",
+  "name": "gr00t-n1.5-3b-p150",
+  "tt_metal_version": "0.65.2.dev10011",
+  "arch": "blackhole",
+  "device_count": 1,
+  "producer": {
+    "tt_kernel_version": "0.1.0",
+    "created_at": "2026-09-14T15:30:00.783347+00:00",
+    "hostname": "deepgadget"
+  },
+  "weights": {
+    "repo_id": "nvidia/GR00T-N1.5-3B",
+    "revision": "869830fc749c35f34771aa5209f923ac57e4564e",
+    "allow_patterns": [
+      "model-*.safetensors",
+      "model.safetensors.index.json",
+      "config.json",
+      "experiment_cfg/metadata.json",
+      "LICENSE"
+    ],
+    "ignore_patterns": null,
+    "repo_type": "model"
+  },
+  "mesh": null,
+  "entrypoint": null,
+  "resources": null,
+  "capabilities": null,
+  "env": {},
+  "bundled": null,
+  "deps": null,
+  "container": {
+    "image": {
+      "registry": "hf",
+      "repository": "gr00t-n1.5-3b-p150",
+      "tag": "tt-model/gr00t-n1.5-3b-p150:443501bd3b7a",
+      "digest": "sha256:443501bd3b7afce579bf743eeedd64809886653c29a9d7125614e8451cd61a7b"
+    },
+    "kind": "tt-dit-server",
+    "runtime": {
+      "app": "gr00t_p150.server.app:app",
+      "mesh_shape_env": "TT_MESH_SHAPE",
+      "packages": [
+        "numpy>=1.24.4,<2",
+        "safetensors",
+        "huggingface_hub",
+        "transformers==5.12.1",
+        "opencv-python-headless==4.8.1.78",
+        "torchvision==0.26.0",
+        "pytest"
+      ],
+      "lock": "requirements.lock"
+    },
+    "serve": {
+      "hardware": "p150",
+      "mesh_device": "P150",
+      "port": 20000,
+      "max_model_len": null,
+      "max_num_seqs": null,
+      "block_size": null,
+      "server_timeout": null,
+      "capabilities": null,
+      "additional_config": {},
+      "args": [],
+      "env": {
+        "TT_WEIGHTS_REVISION": "869830fc749c35f34771aa5209f923ac57e4564e",
+        "TT_METAL_VISIBLE_DEVICES": "0",
+        "TT_DEVICE_ID": "0",
+        "GR00T_VERSION": "n15",
+        "GR00T_EMBODIMENT": "gr1",
+        "GR00T_LAYOUT": "gr1",
+        "GR00T_POLICY": "mixed_dit",
+        "GR00T_TRACE_LAYOUT": "per_stage",
+        "GR00T_TOKENIZER_DIR_N15": "/opt/tt-metal/gr00t_p150/assets/tokenizer/n15",
+        "GR00T_PROJECT_ROOT": "/nonexistent",
+        "GR00T_GOLDEN_ROOT": "/nonexistent",
+        "GR00T_TT_CACHE": "/weight-cache/gr00t-tt",
+        "GR00T_WARMUP_RUNS": "3"
+      }
+    },
+    "serve_profiles": [
+      {
+        "hardware": null,
+        "mesh_device": null,
+        "port": null,
+        "max_model_len": null,
+        "max_num_seqs": null,
+        "block_size": null,
+        "server_timeout": null,
+        "capabilities": null,
+        "additional_config": {},
+        "args": [],
+        "env": {},
+        "name": "default",
+        "description": null
+      }
+    ],
+    "default_profile": null,
+    "code_dir": "code",
+    "verify": [
+      "import gr00t_p150.server.app as a; assert a.app; import sys; assert 'ttnn' not in sys.modules, 'server import must be side-effect free'",
+      "import models.experimental.gr00t.tt.model as m; assert m.Gr00tTT",
+      "from models.experimental.gr00t.common import preprocessing, normalization, prompts, checkpoint, weights, configs; assert configs.HF_SNAPSHOT_SHAS['n15'] == '869830fc749c35f34771aa5209f923ac57e4564e'",
+      "import pytest, models.common.utility_functions; import models.tt_dit.utils.matmul as mm; assert mm.get_matmul_config",
+      "import models.demos.deepseek_v3_b1.unified_kernel_descriptor as u; assert u.UnifiedKernelDescriptor",
+      "import models.tt_dit.encoders.qwen3vl.vision_qwen3vl",
+      "import models.experimental.gr00t.tt.layers, models.experimental.gr00t.tt.qwen3vl_vision, models.experimental.gr00t.tt.megakernel.descriptors",
+      "import safetensors, huggingface_hub, cv2, numpy, PIL; assert int(numpy.__version__.split('.')[0]) < 2, numpy.__version__",
+      "import transformers; assert transformers.__version__ == '5.12.1', transformers.__version__",
+      "import torchvision; assert torchvision.__version__.startswith('0.26.0'), torchvision.__version__",
+      "from pathlib import Path; d = Path('/opt/tt-metal/gr00t_p150/assets/tokenizer/n15'); assert all((d / f).is_file() for f in ('vocab.json', 'merges.txt', 'tokenizer_config.json', 'special_tokens_map.json', 'added_tokens.json')), sorted(p.name for p in d.iterdir())",
+      "import os; os.environ['GR00T_TOKENIZER_DIR_N15'] = '/opt/tt-metal/gr00t_p150/assets/tokenizer/n15'; from models.experimental.gr00t.common.prompts import get_tokenizer; t = get_tokenizer('n15'); assert t.convert_tokens_to_ids('<IMG_CONTEXT>') == 151669",
+      "from pathlib import Path; assert Path('/opt/tt-metal/models/experimental/gr00t/common/golden_tap_map.json').is_file()",
+      "from pathlib import Path; assert Path('/opt/tt-metal/gr00t_p150/server/smoke_test.py').is_file() and Path('/opt/tt-metal/scripts/bench_http.py').is_file()",
+      "from pathlib import Path; d = Path('/opt/tt-metal/gr00t_p150/demo/n15'); assert all((d / f).is_file() for f in ('observation.json', 'noise.json', 'expected.json', 'frames/ego_view_t0.png')), sorted(str(p) for p in d.rglob('*'))",
+      "import ttnn; assert all(hasattr(ttnn, a) for a in ('begin_trace_capture', 'end_trace_capture', 'execute_trace', 'release_trace', 'copy_host_to_device_tensor', 'MinimalMatmulConfig'))",
+      "from gr00t_p150.server.app import parse_mesh_shape as p; assert p('1x1') == p('(1, 1)') == p('1,1') == (1, 1)"
+    ],
+    "built": {
+      "image": "tt-model/gr00t-n1.5-3b-p150:443501bd3b7a",
+      "repo": "changh95/GR00T-N1.5-3B-p150",
+      "tt_model_version": "0.1.0",
+      "created_at": "2026-09-14T15:17:00+00:00",
+      "tt_metal": {
+        "sha": "668c290757550588d0ce46b180c344a462a2aaf5",
+        "describe": "v0.79.0-dev20260914-1-g668c290757",
+        "dirty": false,
+        "scm_version": "0.65.2.dev10011",
+        "mode": "local",
+        "remote": "https://github.com/tenstorrent/tt-metal.git",
+        "branch": "HEAD",
+        "pushed": true
+      },
+      "code_sha256": "a2771515bca98527e302292524e9c1d28db4941cec8eb276bc8c8344d14358e9",
+      "image_digest": "sha256:443501bd3b7afce579bf743eeedd64809886653c29a9d7125614e8451cd61a7b"
+    }
+  }
+}