sync 2e7068faf55e

Browse files

Files changed (13) hide show

README.md +89 -0
build/webgpu/bench.json +173 -0
build/webgpu/manifest.json +483 -0
build/webgpu/metadata.json +25 -0
build/webgpu/resize-antialias.wgsl.jinja +159 -0
build/webgpu/resize-coord-transform-5d.wgsl.jinja +224 -0
build/webgpu/resize-coord-transform.wgsl.jinja +313 -0
build/webgpu/resize-cubic.wgsl.jinja +118 -0
build/webgpu/resize-generic.wgsl.jinja +409 -0
build/webgpu/resize-linear-2x-stencil-x8.wgsl.jinja +81 -0
build/webgpu/resize-linear-2x-stencil.wgsl.jinja +124 -0
build/webgpu/resize-nearest-integer-scale.wgsl.jinja +73 -0
build/webgpu/test.json +0 -0

README.md CHANGED Viewed

@@ -1,3 +1,92 @@
 ---
 license: apache-2.0
 ---

 ---
+library_name: kernels
 license: apache-2.0
+tags:
+- kernel
+- webgpu
+- wgsl
 ---
+# ai.onnx.Resize
+`ai.onnx`  ·  standard ONNX operator  ·  ONNX opset ≥ 19
+## Description
+Resizes the input tensor by sampling neighboring input values. Output dimensions are determined by per-axis scale factors or explicit target sizes. Supports `nearest`, `linear`, and `cubic` interpolation with configurable coordinate transformation modes.
+See the [ONNX `Resize` spec](https://onnx.ai/onnx/operators/onnx__Resize.html) for the reference semantics.
+## Inputs
+| Name | Bind key | Logical dtype | Rank | Shape | Description | Presence |
+| --- | --- | --- | --- | --- | --- | --- |
+| `X` | `x` | `T` | — | — | N-D input tensor to be resized. | required |
+## Outputs
+| Name | Bind key | Logical dtype | Rank | Shape | Description | Presence |
+| --- | --- | --- | --- | --- | --- | --- |
+| `Y` | `y` | `T` | same as `X` | — | N-D output tensor after resizing. | required |
+## Attributes
+Attributes and default values (overridable per request):
+| Attribute | Default | Description |
+| --- | --- | --- |
+| `mode` | `"nearest"` | Interpolation mode: `"nearest"` (default), `"linear"` (bilinear/N-linear), or `"cubic"` (bicubic/N-cubic). |
+| `coordinate_transformation_mode` | `"half_pixel"` | How to map a coordinate in the output tensor back to the input tensor; supported modes include `"half_pixel"`, `"pytorch_half_pixel"`, `"align_corners"`, `"asymmetric"`, and `"tf_crop_and_resize"`. |
+| `nearest_mode` | `"round_prefer_floor"` | Rounding strategy used when `mode` is `"nearest"`: `"round_prefer_floor"` (default), `"round_prefer_ceil"`, `"floor"`, or `"ceil"`. |
+| `cubic_coeff_a` | `-0.75` | Coefficient `a` in the cubic interpolation filter; the default is -0.75. Valid only when `mode` is `"cubic"`. |
+| `roi` | `[]` | Values of the optional `roi` tensor, supplied as `[starts..., ends...]` with one pair per input axis or per `axes` entry; used only by `"tf_crop_and_resize"`. |
+| `scales` | `[]` | Values of the optional `scales` tensor. Supply one positive value per input axis, or one per `axes` entry when that attribute is present; omit it when the output shape represents the exact `sizes` input. |
+| `extrapolation_value` | `0` | Fill value used for out-of-bounds samples when `coordinate_transformation_mode` is `"tf_crop_and_resize"`. |
+| `antialias` | `0` | When set to 1, stretches the resampling filter during downscaling so that more input pixels contribute to each output pixel, reducing aliasing. |
+| `exclude_outside` | `0` | When set to 1, zero-weights sampling locations that fall outside the input tensor and renormalizes the remaining weights to sum to 1. |
+| `keep_aspect_ratio_policy` | `"stretch"` | How explicit sizes preserve aspect ratio. Only the default `"stretch"` policy is supported; `"not_larger"` and `"not_smaller"` are not yet implemented. |
+| `axes` | — | Optional axes to resize. When omitted, the scale values or requested output size apply to every input axis. |
+## Type constraints
+| Variable | Allowed dtypes |
+| --- | --- |
+| `T` | `float32`, `float16`, `uint8`, `int8` |
+## Files
+- [`metadata.json`](build/webgpu/metadata.json) — kernel metadata (id, digests, provenance)
+- [`manifest.json`](build/webgpu/manifest.json) — the op contract (source of truth)
+- [`test.json`](build/webgpu/test.json) — correctness cases
+- [`bench.json`](build/webgpu/bench.json) — benchmark + tuning cases
+- [`resize-antialias.wgsl.jinja`](build/webgpu/resize-antialias.wgsl.jinja)
+- [`resize-coord-transform-5d.wgsl.jinja`](build/webgpu/resize-coord-transform-5d.wgsl.jinja)
+- [`resize-coord-transform.wgsl.jinja`](build/webgpu/resize-coord-transform.wgsl.jinja)
+- [`resize-cubic.wgsl.jinja`](build/webgpu/resize-cubic.wgsl.jinja)
+- [`resize-generic.wgsl.jinja`](build/webgpu/resize-generic.wgsl.jinja)
+- [`resize-linear-2x-stencil-x8.wgsl.jinja`](build/webgpu/resize-linear-2x-stencil-x8.wgsl.jinja)
+- [`resize-linear-2x-stencil.wgsl.jinja`](build/webgpu/resize-linear-2x-stencil.wgsl.jinja)
+- [`resize-nearest-integer-scale.wgsl.jinja`](build/webgpu/resize-nearest-integer-scale.wgsl.jinja)
+## Use with `@huggingface/kernels`
+The loader automatically allocates outputs whose metadata it can derive from the manifest contract and this call.
+The explicit `outputs` entries provide shape and logical dtype metadata for the results listed below:
+- `y`
+Each entry either requests an optional result or supplies metadata that cannot be inferred from the inputs.
+The `version: 1` option selects the published kernel contract; it is independent of any operator opset, contrib `since_version`, or model version.
+Replace each `*Data` placeholder with a typed array containing the corresponding input data.
+```js
+import { getKernel } from "@huggingface/kernels";
+const kernel = await getKernel("webgpu-kernels/ai.onnx.Resize", { version: 1 });
+// Explicit destinations request optional results or supply metadata that cannot be inferred.
+const { y } = await kernel({ x: { data: xData, shape: [1, 1, 2, 4] } }, {
+  outputs: { y: { shape: [1, 1, 1, 2], dtype: "float32" } },
+});
+```

build/webgpu/bench.json ADDED Viewed

	@@ -0,0 +1,173 @@

+{
+  "op": "ai.onnx.Resize",
+  "tunableSpace": { "WORKGROUP_SIZE": [64, 128, 256] },
+  "cases": [
+    {
+      "name": "nchw_1x64_256_to_512_linear_decoder",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 64, 256, 256], "dist": "normal", "seed": 731, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 64, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x64_256_to_512_linear_asymmetric_decoder",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "asymmetric" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 64, 256, 256], "dist": "normal", "seed": 732, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 64, 512, 512] } },
+      "bench": { "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }] }
+    },
+    {
+      "name": "nchw_1x3_256_to_512_linear",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 3, 256, 256] } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 3, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x32_256_to_512_linear_align_corners_large",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "align_corners" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 32, 256, 256], "dist": "normal", "seed": 751, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 32, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x3_256_to_512_linear_align_corners_fallback",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "align_corners" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 3, 256, 256] } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 3, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x3_256_to_512_nearest_2x",
+      "attrs": { "mode": "nearest", "coordinate_transformation_mode": "asymmetric", "nearest_mode": "floor" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 3, 256, 256] } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 3, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x128_64_to_128_nearest_2x_f16_vae",
+      "preset": "smoke",
+      "attrs": {
+        "mode": "nearest",
+        "coordinate_transformation_mode": "asymmetric",
+        "nearest_mode": "floor",
+        "scales": [1, 1, 2, 2]
+      },
+      "inputs": { "x": { "dtype": "float16", "shape": [1, 128, 64, 64], "dist": "normal", "seed": 601, "scale": 0.2 } },
+      "outputs": { "y": { "dtype": "float16", "shape": [1, 128, 128, 128] } },
+      "bench": { "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 2" }] }
+    },
+    {
+      "name": "nchw_1x3_176_to_528_nearest_3x",
+      "attrs": { "mode": "nearest", "coordinate_transformation_mode": "asymmetric", "nearest_mode": "floor" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 3, 176, 176] } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 3, 528, 528] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x3_128_to_512_nearest_4x",
+      "attrs": {
+        "mode": "nearest",
+        "coordinate_transformation_mode": "half_pixel",
+        "nearest_mode": "round_prefer_floor"
+      },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 3, 128, 128] } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 3, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x64_256_to_510_linear_w_odd_scalar_cliff",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 64, 256, 256], "dist": "normal", "seed": 781, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 64, 512, 510] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "nchw_1x64_256_to_512_linear_f16_vec4_decoder",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float16", "shape": [1, 64, 256, 256], "dist": "normal", "seed": 782, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float16", "shape": [1, 64, 512, 512] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 2" }]
+      }
+    },
+    {
+      "name": "nchw_1x64_256_to_510_linear_f16_w_odd_scalar_cliff",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float16", "shape": [1, 64, 256, 256], "dist": "normal", "seed": 783, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float16", "shape": [1, 64, 512, 510] } },
+      "bench": { "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 2" }] }
+    },
+    {
+      "name": "nchw_1x64_512_to_256_linear_downsample_vec4",
+      "preset": "smoke",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 64, 512, 512], "dist": "normal", "seed": 784, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 64, 256, 256] } },
+      "bench": {
+        "primary": true,
+        "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }]
+      }
+    },
+    {
+      "name": "antialias_linear_8x_downsample_tap_explosion_stress",
+      "preset": "stress",
+      "attrs": {
+        "mode": "linear",
+        "antialias": 1,
+        "coordinate_transformation_mode": "half_pixel",
+        "scales": [1, 1, 0.125, 0.125]
+      },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 32, 256, 256], "dist": "normal", "seed": 901, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 32, 32, 32], "dist": "empty" } },
+      "bench": { "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }] }
+    },
+    {
+      "name": "generic_nhwc_linear_2x_upsample_scalar_no_vec4_stress",
+      "preset": "stress",
+      "attrs": { "mode": "linear", "coordinate_transformation_mode": "half_pixel" },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 256, 256, 16], "dist": "normal", "seed": 902, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 512, 512, 16], "dist": "empty" } },
+      "bench": { "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }] }
+    },
+    {
+      "name": "generic_rank5_cubic_64tap_unroll_stress",
+      "preset": "stress",
+      "attrs": { "mode": "cubic", "coordinate_transformation_mode": "half_pixel", "cubic_coeff_a": -0.75 },
+      "inputs": { "x": { "dtype": "float32", "shape": [1, 1, 32, 32, 32], "dist": "normal", "seed": 903, "scale": 1 } },
+      "outputs": { "y": { "dtype": "float32", "shape": [1, 1, 64, 64, 64], "dist": "empty" } },
+      "bench": { "metrics": [{ "type": "bandwidth", "value": "(numel(shapes.x) + numel(shapes.y)) * 4" }] }
+    }
+  ]
+}

build/webgpu/manifest.json ADDED Viewed

	@@ -0,0 +1,483 @@

+{
+  "domain": "ai.onnx",
+  "name": "Resize",
+  "sinceVersion": 19,
+  "description": "Resizes the input tensor by sampling neighboring input values. Output dimensions are determined by per-axis scale factors or explicit target sizes. Supports `nearest`, `linear`, and `cubic` interpolation with configurable coordinate transformation modes.",
+  "inputs": [{ "role": "X", "dtype": "T", "description": "N-D input tensor to be resized." }],
+  "outputs": [{ "role": "Y", "dtype": "T", "description": "N-D output tensor after resizing.", "rank": "ranks.X" }],
+  "attributes": {
+    "mode": "nearest",
+    "coordinate_transformation_mode": "half_pixel",
+    "nearest_mode": "round_prefer_floor",
+    "cubic_coeff_a": -0.75,
+    "roi": [],
+    "scales": [],
+    "extrapolation_value": 0,
+    "antialias": 0,
+    "exclude_outside": 0,
+    "keep_aspect_ratio_policy": "stretch"
+  },
+  "attributeDescriptions": {
+    "mode": "Interpolation mode: `\"nearest\"` (default), `\"linear\"` (bilinear/N-linear), or `\"cubic\"` (bicubic/N-cubic).",
+    "coordinate_transformation_mode": "How to map a coordinate in the output tensor back to the input tensor; supported modes include `\"half_pixel\"`, `\"pytorch_half_pixel\"`, `\"align_corners\"`, `\"asymmetric\"`, and `\"tf_crop_and_resize\"`.",
+    "nearest_mode": "Rounding strategy used when `mode` is `\"nearest\"`: `\"round_prefer_floor\"` (default), `\"round_prefer_ceil\"`, `\"floor\"`, or `\"ceil\"`.",
+    "cubic_coeff_a": "Coefficient `a` in the cubic interpolation filter; the default is -0.75. Valid only when `mode` is `\"cubic\"`.",
+    "roi": "Values of the optional `roi` tensor, supplied as `[starts..., ends...]` with one pair per input axis or per `axes` entry; used only by `\"tf_crop_and_resize\"`.",
+    "scales": "Values of the optional `scales` tensor. Supply one positive value per input axis, or one per `axes` entry when that attribute is present; omit it when the output shape represents the exact `sizes` input.",
+    "extrapolation_value": "Fill value used for out-of-bounds samples when `coordinate_transformation_mode` is `\"tf_crop_and_resize\"`.",
+    "antialias": "When set to 1, stretches the resampling filter during downscaling so that more input pixels contribute to each output pixel, reducing aliasing.",
+    "exclude_outside": "When set to 1, zero-weights sampling locations that fall outside the input tensor and renormalizes the remaining weights to sum to 1.",
+    "axes": "Optional axes to resize. When omitted, the scale values or requested output size apply to every input axis.",
+    "keep_aspect_ratio_policy": "How explicit sizes preserve aspect ratio. Only the default `\"stretch\"` policy is supported; `\"not_larger\"` and `\"not_smaller\"` are not yet implemented."
+  },
+  "attributeConstraints": {
+    "mode": { "values": ["nearest", "linear", "cubic"] },
+    "coordinate_transformation_mode": {
+      "values": ["half_pixel", "half_pixel_symmetric", "pytorch_half_pixel", "align_corners", "asymmetric", "tf_crop_and_resize"]
+    },
+    "nearest_mode": { "values": ["round_prefer_floor", "round_prefer_ceil", "floor", "ceil"] },
+    "antialias": { "values": [0, 1] },
+    "exclude_outside": { "values": [0, 1] },
+    "keep_aspect_ratio_policy": { "values": ["stretch"] }
+  },
+  "typeConstraints": { "T": ["float32", "float16", "uint8", "int8"] },
+  "args": {
+    "x": { "kind": "tensor", "semantic": "X", "role": "input" },
+    "y": { "kind": "tensor", "semantic": "Y", "role": "output" }
+  },
+  "tunables": { "WORKGROUP_SIZE": 256 },
+  "derive": {
+    "deviceWorkgroupCap": "min(device.limits.maxComputeInvocationsPerWorkgroup, device.limits.maxComputeWorkgroupSizeX)",
+    "storageBufferLimit": "min(device.limits.maxStorageBufferBindingSize, device.limits.maxBufferSize)",
+    "nchw4dContract": "ranks.X == 4 and ranks.Y == 4 and dim(shapes.X, 0) == dim(shapes.Y, 0) and dim(shapes.X, 1) == dim(shapes.Y, 1)",
+    "axesContract": "not has(attrs, \"axes\") or ((attrs.axes | length) > 0 and (attrs.axes | length) <= ranks.X and isUniqueIntList(attrs.axes, 0 - ranks.X, ranks.X, ranks.X))",
+    "scalesContract": "(attrs.scales | length) == 0 or ((not has(attrs, \"axes\") and (attrs.scales | length) == ranks.X) or (has(attrs, \"axes\") and (attrs.scales | length) == (attrs.axes | length)))",
+    "roiContract": "(attrs.roi | length) == 0 or (attrs.roi | length) == 2 * ((attrs.axes | length) if has(attrs, \"axes\") else ranks.X)",
+    "noExplicitScales": "(attrs.scales | length) == 0",
+    "spatialSpecializedScales": "noExplicitScales or (not has(attrs, \"axes\") and (attrs.scales | length) == ranks.X and ranks.X >= 2 and attrs.scales[0] == 1 and attrs.scales[1] == 1)",
+    "workgroupSize": "min(tunables.WORKGROUP_SIZE, deviceWorkgroupCap)",
+    "storageFits": "numel(shapes.X) * dtypeBytes(dtypes.T) <= storageBufferLimit and numel(shapes.Y) * dtypeBytes(dtypes.T) <= storageBufferLimit",
+    "dispatchFits": "numel(shapes.Y) <= device.limits.maxComputeWorkgroupsPerDimension * device.limits.maxComputeWorkgroupsPerDimension * workgroupSize",
+    "portableResources": "axesContract and scalesContract and roiContract and workgroupSize > 0 and storageFits and dispatchFits",
+    "f16X8PortableOk": "device.features.has(\"subgroups\") or not (has(device.adapterInfo, \"subgroupMinSize\") and has(device.adapterInfo, \"subgroupMaxSize\") and device.adapterInfo.subgroupMinSize == 8 and device.adapterInfo.subgroupMaxSize <= 32)",
+    "rank4Vec4Preferred": "not has(device.adapterInfo, \"subgroupMaxSize\") or device.adapterInfo.subgroupMaxSize <= 32"
+  },
+  "constants": { "scalar": "dtypes.T" },
+  "bindingSets": {
+    "static": [
+      { "name": "x", "arg": "x", "semantic": "X", "buffer": { "type": "read-only-storage" }, "elementType": "$scalar" },
+      { "name": "y", "arg": "y", "semantic": "Y", "buffer": { "type": "storage" }, "elementType": "$outputElement" }
+    ],
+    "rank4": [
+      { "name": "x", "arg": "x", "semantic": "X", "buffer": { "type": "read-only-storage" }, "elementType": "$scalar" },
+      { "name": "y", "arg": "y", "semantic": "Y", "buffer": { "type": "storage" }, "elementType": "$outputElement" },
+      {
+        "name": "params",
+        "semantic": "kernel.params",
+        "buffer": { "type": "uniform" },
+        "struct": {
+          "name": "Params",
+          "fields": [
+            { "name": "count", "type": "u32", "value": "numel(shapes.Y)" },
+            { "name": "C", "type": "u32", "value": "dim(shapes.X, 1)" },
+            { "name": "inH", "type": "u32", "value": "dim(shapes.X, 2)" },
+            { "name": "inW", "type": "u32", "value": "dim(shapes.X, 3)" },
+            { "name": "outH", "type": "u32", "value": "dim(shapes.Y, 2)" },
+            { "name": "outW", "type": "u32", "value": "dim(shapes.Y, 3)" },
+            { "name": "scaleH", "type": "f32", "value": "attrs.scales[2] if not noExplicitScales else 0" },
+            { "name": "scaleW", "type": "f32", "value": "attrs.scales[3] if not noExplicitScales else 0" }
+          ]
+        }
+      }
+    ],
+    "rank4Cubic": [
+      { "name": "x", "arg": "x", "semantic": "X", "buffer": { "type": "read-only-storage" }, "elementType": "$scalar" },
+      { "name": "y", "arg": "y", "semantic": "Y", "buffer": { "type": "storage" }, "elementType": "$scalar" },
+      {
+        "name": "params",
+        "semantic": "kernel.params",
+        "buffer": { "type": "uniform" },
+        "struct": {
+          "name": "Params",
+          "fields": [
+            { "name": "count", "type": "u32", "value": "numel(shapes.Y)" },
+            { "name": "C", "type": "u32", "value": "dim(shapes.X, 1)" },
+            { "name": "inH", "type": "u32", "value": "dim(shapes.X, 2)" },
+            { "name": "inW", "type": "u32", "value": "dim(shapes.X, 3)" },
+            { "name": "outH", "type": "u32", "value": "dim(shapes.Y, 2)" },
+            { "name": "outW", "type": "u32", "value": "dim(shapes.Y, 3)" },
+            { "name": "scaleH", "type": "f32", "value": "attrs.scales[2] if not noExplicitScales else 0" },
+            { "name": "scaleW", "type": "f32", "value": "attrs.scales[3] if not noExplicitScales else 0" },
+            { "name": "coeffA", "type": "f32", "value": "attrs.cubic_coeff_a" }
+          ]
+        }
+      }
+    ],
+    "rank5Scalar": [
+      { "name": "x", "arg": "x", "semantic": "X", "buffer": { "type": "read-only-storage" }, "elementType": "$scalar" },
+      { "name": "y", "arg": "y", "semantic": "Y", "buffer": { "type": "storage" }, "elementType": "$scalar" },
+      {
+        "name": "params",
+        "semantic": "kernel.params",
+        "buffer": { "type": "uniform" },
+        "struct": {
+          "name": "Params",
+          "fields": [
+            { "name": "count", "type": "u32", "value": "numel(shapes.Y)" },
+            { "name": "C", "type": "u32", "value": "dim(shapes.X, 1)" },
+            { "name": "inD", "type": "u32", "value": "dim(shapes.X, 2)" },
+            { "name": "inH", "type": "u32", "value": "dim(shapes.X, 3)" },
+            { "name": "inW", "type": "u32", "value": "dim(shapes.X, 4)" },
+            { "name": "outD", "type": "u32", "value": "dim(shapes.Y, 2)" },
+            { "name": "outH", "type": "u32", "value": "dim(shapes.Y, 3)" },
+            { "name": "outW", "type": "u32", "value": "dim(shapes.Y, 4)" },
+            { "name": "scaleD", "type": "f32", "value": "attrs.scales[2] if not noExplicitScales else 0" },
+            { "name": "scaleH", "type": "f32", "value": "attrs.scales[3] if not noExplicitScales else 0" },
+            { "name": "scaleW", "type": "f32", "value": "attrs.scales[4] if not noExplicitScales else 0" }
+          ]
+        }
+      }
+    ]
+  },
+  "variants": [
+    {
+      "id": "linear_2x_stencil_f16_x8",
+      "priority": 22,
+      "when": ["nchw4dContract", "numel(shapes.Y) > 0", "attrs.mode == \"linear\"", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\")", "dim(shapes.Y, 2) == dim(shapes.X, 2) * 2", "dim(shapes.Y, 3) == dim(shapes.X, 3) * 2", "dim(shapes.Y, 3) % 8 == 0", "dtypes.T == \"f16\"", "f16X8PortableOk", "f16Ok(dtypes.T)", "portableResources", "noExplicitScales"],
+      "constants": { "vectorScalar": "\"vec4<f16>\"", "outputElement": "\"vec4<f16>\"" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.linear2xStencilF16X8",
+          "source": {
+            "shader": "resize-linear-2x-stencil-x8.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "coordinateMode": "attrs.coordinate_transformation_mode"
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y) / 8", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "nearest_integer_scale_vec4",
+      "priority": 21,
+      "when": ["nchw4dContract", "numel(shapes.Y) > 0", "attrs.mode == \"nearest\"", "((attrs.coordinate_transformation_mode == \"asymmetric\" and attrs.nearest_mode == \"floor\") or (attrs.coordinate_transformation_mode == \"half_pixel\" and (attrs.nearest_mode == \"round_prefer_floor\" or attrs.nearest_mode == \"round_prefer_ceil\")))", "(dim(shapes.Y, 2) == dim(shapes.X, 2) * 2 or dim(shapes.Y, 2) == dim(shapes.X, 2) * 3 or dim(shapes.Y, 2) == dim(shapes.X, 2) * 4)", "(dim(shapes.Y, 3) == dim(shapes.X, 3) * 2 or dim(shapes.Y, 3) == dim(shapes.X, 3) * 3 or dim(shapes.Y, 3) == dim(shapes.X, 3) * 4)", "dim(shapes.Y, 3) % 4 == 0", "f16Ok(dtypes.T)", "portableResources", "noExplicitScales"],
+      "constants": {
+        "usesF16": "dtypes.T == \"f16\"",
+        "vectorScalar": "\"vec4<\" ~ dtypes.T ~ \">\"",
+        "outputElement": "\"vec4<\" ~ dtypes.T ~ \">\""
+      },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.nearestIntegerScaleVec4",
+          "source": {
+            "shader": "resize-nearest-integer-scale.wgsl.jinja",
+            "inputs": { "xShape": "shapes.X", "yShape": "shapes.Y", "vec4": true }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y) / 4", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "nearest_integer_scale",
+      "priority": 20,
+      "when": ["nchw4dContract", "numel(shapes.Y) > 0", "attrs.mode == \"nearest\"", "((attrs.coordinate_transformation_mode == \"asymmetric\" and attrs.nearest_mode == \"floor\") or (attrs.coordinate_transformation_mode == \"half_pixel\" and (attrs.nearest_mode == \"round_prefer_floor\" or attrs.nearest_mode == \"round_prefer_ceil\")))", "(dim(shapes.Y, 2) == dim(shapes.X, 2) * 2 or dim(shapes.Y, 2) == dim(shapes.X, 2) * 3 or dim(shapes.Y, 2) == dim(shapes.X, 2) * 4)", "(dim(shapes.Y, 3) == dim(shapes.X, 3) * 2 or dim(shapes.Y, 3) == dim(shapes.X, 3) * 3 or dim(shapes.Y, 3) == dim(shapes.X, 3) * 4)", "f16Ok(dtypes.T)", "portableResources", "noExplicitScales"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.nearestIntegerScale",
+          "source": {
+            "shader": "resize-nearest-integer-scale.wgsl.jinja",
+            "inputs": { "xShape": "shapes.X", "yShape": "shapes.Y", "vec4": false }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "linear_2x_stencil_vec4",
+      "priority": 20,
+      "when": ["nchw4dContract", "numel(shapes.Y) > 0", "attrs.mode == \"linear\"", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\")", "dim(shapes.Y, 2) == dim(shapes.X, 2) * 2", "dim(shapes.Y, 3) == dim(shapes.X, 3) * 2", "dim(shapes.Y, 3) % 4 == 0", "f16Ok(dtypes.T)", "portableResources", "noExplicitScales"],
+      "constants": {
+        "usesF16": "dtypes.T == \"f16\"",
+        "vectorScalar": "\"vec4<\" ~ dtypes.T ~ \">\"",
+        "outputElement": "\"vec4<\" ~ dtypes.T ~ \">\""
+      },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.linear2xStencilVec4",
+          "source": {
+            "shader": "resize-linear-2x-stencil.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "vec4": true
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y) / 4", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "linear_2x_stencil",
+      "priority": 19,
+      "when": ["nchw4dContract", "numel(shapes.Y) > 0", "attrs.mode == \"linear\"", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\")", "dim(shapes.Y, 2) == dim(shapes.X, 2) * 2", "dim(shapes.Y, 3) == dim(shapes.X, 3) * 2", "f16Ok(dtypes.T)", "portableResources", "noExplicitScales"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.linear2xStencil",
+          "source": {
+            "shader": "resize-linear-2x-stencil.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "coordinateMode": "attrs.coordinate_transformation_mode"
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "nchw_rank4_vec4",
+      "priority": 1,
+      "when": ["nchw4dContract", "(attrs.mode == \"nearest\" or attrs.mode == \"linear\")", "attrs.coordinate_transformation_mode != \"tf_crop_and_resize\"", "(attrs.antialias != 1 or attrs.mode == \"nearest\")", "dim(shapes.Y, 3) % 4 == 0", "f16Ok(dtypes.T)", "portableResources", "spatialSpecializedScales"],
+      "demoteWhen": ["not rank4Vec4Preferred"],
+      "constants": {
+        "usesF16": "dtypes.T == \"f16\"",
+        "vectorScalar": "\"vec4<\" ~ dtypes.T ~ \">\"",
+        "outputElement": "\"vec4<\" ~ dtypes.T ~ \">\""
+      },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.Vec4",
+          "source": {
+            "shader": "resize-coord-transform.wgsl.jinja",
+            "inputs": {
+              "mode": "attrs.mode",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "nearestMode": "attrs.nearest_mode",
+              "vec4": true,
+              "vecType": "\"vec4<\" ~ dtypes.T ~ \">\""
+            }
+          },
+          "bindings": "rank4",
+          "dispatch": { "threads": "numel(shapes.Y) / 4", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "nchw_rank4_scalar_x4",
+      "priority": 2,
+      "when": ["nchw4dContract", "(attrs.mode == \"nearest\" or attrs.mode == \"linear\")", "attrs.coordinate_transformation_mode != \"tf_crop_and_resize\"", "(attrs.antialias != 1 or attrs.mode == \"nearest\")", "dim(shapes.Y, 3) >= 4", "dim(shapes.Y, 3) % 4 != 0", "f16Ok(dtypes.T)", "portableResources", "spatialSpecializedScales"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.ScalarX4",
+          "source": {
+            "shader": "resize-coord-transform.wgsl.jinja",
+            "inputs": {
+              "mode": "attrs.mode",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "nearestMode": "attrs.nearest_mode",
+              "scalarX4": true
+            }
+          },
+          "bindings": "rank4",
+          "dispatch": {
+            "threads": "dim(shapes.Y, 0) * dim(shapes.Y, 1) * dim(shapes.Y, 2) * ceil(dim(shapes.Y, 3) / 4)",
+            "workgroupSize": "workgroupSize"
+          }
+        }
+      ]
+    },
+    {
+      "id": "nchw_rank4",
+      "when": ["nchw4dContract", "(attrs.mode == \"nearest\" or attrs.mode == \"linear\")", "attrs.coordinate_transformation_mode != \"tf_crop_and_resize\"", "(attrs.antialias != 1 or attrs.mode == \"nearest\")", "f16Ok(dtypes.T)", "portableResources", "spatialSpecializedScales"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize",
+          "source": {
+            "shader": "resize-coord-transform.wgsl.jinja",
+            "inputs": {
+              "mode": "attrs.mode",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "nearestMode": "attrs.nearest_mode"
+            }
+          },
+          "bindings": "rank4",
+          "dispatch": { "threads": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "ncdhw_rank5",
+      "when": ["ranks.X == 5", "ranks.Y == 5", "dim(shapes.X, 0) == dim(shapes.Y, 0)", "dim(shapes.X, 1) == dim(shapes.Y, 1)", "(attrs.mode == \"nearest\" or attrs.mode == \"linear\")", "attrs.coordinate_transformation_mode != \"tf_crop_and_resize\"", "(attrs.antialias != 1 or attrs.mode == \"nearest\")", "f16Ok(dtypes.T)", "portableResources", "spatialSpecializedScales"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.Ncdhw",
+          "source": {
+            "shader": "resize-coord-transform-5d.wgsl.jinja",
+            "inputs": {
+              "mode": "attrs.mode",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "nearestMode": "attrs.nearest_mode"
+            }
+          },
+          "bindings": "rank5Scalar",
+          "dispatch": { "threads": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "nchw_rank4_cubic",
+      "when": ["nchw4dContract", "(attrs.antialias != 1)", "attrs.mode == \"cubic\"", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\" or attrs.coordinate_transformation_mode == \"align_corners\")", "f16Ok(dtypes.T)", "portableResources", "spatialSpecializedScales"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.Cubic",
+          "source": {
+            "shader": "resize-cubic.wgsl.jinja",
+            "inputs": {
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "excludeOutside": "attrs.exclude_outside if attrs.exclude_outside else 0"
+            }
+          },
+          "bindings": "rank4Cubic",
+          "dispatch": { "threads": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "generic_rank_n",
+      "priority": 0,
+      "when": ["ranks.X == ranks.Y", "ranks.X >= 1", "numel(shapes.Y) > 0", "(attrs.mode == \"nearest\" or attrs.mode == \"linear\")", "(attrs.antialias != 1 or attrs.mode == \"nearest\")", "(attrs.coordinate_transformation_mode == \"tf_crop_and_resize\" or ranks.X < 4 or ranks.X > 5 or dim(shapes.X, 0) != dim(shapes.Y, 0) or dim(shapes.X, 1) != dim(shapes.Y, 1) or not spatialSpecializedScales)", "f16Ok(dtypes.T)", "portableResources"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.Generic",
+          "source": {
+            "shader": "resize-generic.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "mode": "attrs.mode",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "nearestMode": "attrs.nearest_mode",
+              "roi": "attrs.roi",
+              "scales": "attrs.scales",
+              "extrapolationValue": "attrs.extrapolation_value",
+              "excludeOutside": "attrs.exclude_outside if attrs.exclude_outside else 0",
+              "axes": "attrs.axes if has(attrs, \"axes\") else []"
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "antialias_linear",
+      "priority": 5,
+      "when": ["ranks.X == ranks.Y", "ranks.X >= 2", "numel(shapes.Y) > 0", "attrs.mode == \"linear\"", "attrs.antialias == 1", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\" or attrs.coordinate_transformation_mode == \"align_corners\")", "f16Ok(dtypes.T)", "portableResources"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.AntialiasLinear",
+          "source": {
+            "shader": "resize-antialias.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "excludeOutside": "attrs.exclude_outside == 1",
+              "scales": "attrs.scales",
+              "axes": "attrs.axes if has(attrs, \"axes\") else []"
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "antialias_cubic",
+      "priority": 5,
+      "when": ["ranks.X == ranks.Y", "ranks.X >= 2", "numel(shapes.Y) > 0", "attrs.mode == \"cubic\"", "attrs.antialias == 1", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\" or attrs.coordinate_transformation_mode == \"align_corners\")", "f16Ok(dtypes.T)", "portableResources"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.AntialiasCubic",
+          "source": {
+            "shader": "resize-antialias.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "excludeOutside": "attrs.exclude_outside == 1",
+              "scales": "attrs.scales",
+              "filter": "\"cubic\"",
+              "coeffA": "attrs.cubic_coeff_a",
+              "axes": "attrs.axes if has(attrs, \"axes\") else []"
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    },
+    {
+      "id": "generic_rank_n_cubic",
+      "priority": 0,
+      "when": ["ranks.X == ranks.Y", "ranks.X >= 1", "numel(shapes.Y) > 0", "(attrs.antialias != 1)", "attrs.mode == \"cubic\"", "(attrs.coordinate_transformation_mode == \"half_pixel\" or attrs.coordinate_transformation_mode == \"pytorch_half_pixel\" or attrs.coordinate_transformation_mode == \"asymmetric\" or attrs.coordinate_transformation_mode == \"align_corners\")", "(ranks.X != 4 or dim(shapes.X, 0) != dim(shapes.Y, 0) or dim(shapes.X, 1) != dim(shapes.Y, 1) or not spatialSpecializedScales)", "f16Ok(dtypes.T)", "portableResources"],
+      "constants": { "usesF16": "dtypes.T == \"f16\"", "outputElement": "dtypes.T" },
+      "passes": [
+        {
+          "id": "main",
+          "name": "Resize.GenericCubic",
+          "source": {
+            "shader": "resize-generic.wgsl.jinja",
+            "inputs": {
+              "xShape": "shapes.X",
+              "yShape": "shapes.Y",
+              "mode": "attrs.mode",
+              "coordinateMode": "attrs.coordinate_transformation_mode",
+              "nearestMode": "attrs.nearest_mode",
+              "coeffA": "attrs.cubic_coeff_a",
+              "roi": "attrs.roi",
+              "scales": "attrs.scales",
+              "extrapolationValue": "attrs.extrapolation_value",
+              "excludeOutside": "attrs.exclude_outside if attrs.exclude_outside else 0",
+              "axes": "attrs.axes if has(attrs, \"axes\") else []"
+            }
+          },
+          "bindings": "static",
+          "dispatch": { "gridStride": "numel(shapes.Y)", "workgroupSize": "workgroupSize" }
+        }
+      ]
+    }
+  ]
+}

build/webgpu/metadata.json ADDED Viewed

	@@ -0,0 +1,25 @@

+{
+  "name": "ai.onnx.Resize",
+  "id": "_ai_onnx_resize_webgpu_0155293",
+  "version": 1,
+  "license": "Apache-2.0",
+  "backend": { "type": "webgpu" },
+  "digest": {
+    "algorithm": "sha256",
+    "files": {
+      "bench.json": "gBoDCJxNV/CQ0sFt2VIweuZzVQ5ZE8KiGZxw1hRRmWI=",
+      "manifest.json": "kCg0ZXiAdK80uaoitypMEHWn5/vUFkKlUSBqmaKSVGE=",
+      "resize-antialias.wgsl.jinja": "Ku4/azULjkzIO0lW2a5sh2LEAt/XGD23dEc/bKcnYKU=",
+      "resize-coord-transform-5d.wgsl.jinja": "gq3U+clM7SPPu+VzMf8uIlHm2trJED/SiOABXtgRuKI=",
+      "resize-coord-transform.wgsl.jinja": "ekD/ojBZXcHosWDo639tp/Vsi5SemF7OE8FWYNdIvMk=",
+      "resize-cubic.wgsl.jinja": "0Z/lgy1+yxfW5GYhV4HuC2biY4nqsTgToHjz/aHUBPQ=",
+      "resize-generic.wgsl.jinja": "uSTH4SpnJnVYFc0nRbNiB5fCyUvYi7u10bs+SZw5brw=",
+      "resize-linear-2x-stencil-x8.wgsl.jinja": "JkfXP+3P19pHLuYmn/vIF1ccfjjvoRdP/AoMDZWqZWM=",
+      "resize-linear-2x-stencil.wgsl.jinja": "/gGRgsSwzZ7qGar2xwj8fPpDyG07eTwLdHJGPIOpu14=",
+      "resize-nearest-integer-scale.wgsl.jinja": "fgry1tCB+VAmoiWgqHWsy3EL2G47mtvtZhVPP27Z0Fg=",
+      "test.json": "YXNNuR7ZMl9fAc3N2D1p2IeZpN3I4hpffoHROgKbOEQ="
+    }
+  },
+  "provenance": { "kernel": { "sha": "2e7068faf55e7f43df740015f6d1ee49391a41c5", "dirty": false } },
+  "webgpu": { "manifestSpec": "1.0", "specialized": true, "opPath": "ops/ai.onnx.Resize" }
+}

build/webgpu/resize-antialias.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,159 @@

+// Downsample-aware antialiased Resize. A separable filter runs over each resized
+// axis. The filter scale is max(1, downsample ratio), so downsampling widens the
+// support and averages a source window. Linear mode uses a triangle/area filter;
+// cubic mode uses a Keys kernel at distance/filter-scale. Excluding outside
+// samples zeroes out-of-bounds taps before per-window normalization.
+//
+// An explicit per-axis scale drives both coordinate transformation and filter
+// scale. Because out = floor(in*scale), it may differ from the output/input
+// shape ratio. The window start is dynamic, while its maximum size is baked.
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize %}
+{%- set xs = source.xShape %}
+{% set ys = source.yShape %}
+{% set r = xs | length %}
+{% set FILTER = source.filter if source.filter is defined else "linear" %}
+{% set supmul = 2 if FILTER == "cubic" else 1 %}
+{% set resolvedScales = namespace(values = []) %}
+{% for a in range(r) %}
+{% set axisScale = namespace(value = 0) %}
+{% if source.scales is defined and source.scales %}
+{% if source.axes is defined and source.axes %}
+{% for j in range(source.axes | length) %}
+{% set scaleAxis = source.axes[j] if source.axes[j] >= 0 else source.axes[j] + r %}
+{% if scaleAxis == a %}{% set axisScale.value = source.scales[j] %}{% endif %}
+{% endfor %}
+{% else %}
+{% set axisScale.value = source.scales[a] %}
+{% endif %}
+{% endif %}
+{% set resolvedScales.values = resolvedScales.values + [axisScale.value] %}
+{% endfor %}
+{% set sc = resolvedScales.values %}
+{% set ocount = namespace(v = 1) %}
+{% for a in range(r) %}{% set ocount.v = ocount.v * ys[a] %}{% endfor %}
+{% set resized = namespace(list = []) %}
+{% for a in range(r) %}
+{% if xs[a] != ys[a] or (sc[a] > 0 and sc[a] != 1) %}{% set resized.list = resized.list + [a] %}{% endif %}
+{% endfor %}
+{% set k = resized.list | length %}
+const WG: u32 = {{ wg }}u;
+{% if FILTER == "cubic" %}
+// Keys cubic convolution kernel with coefficient coeffA.
+fn cubic_weight(s_in: f32) -> f32 {
+  let a = f32({{ source.coeffA }});
+  let s = abs(s_in);
+  let s2 = s * s;
+  let s3 = s2 * s;
+  if (s <= 1.0) { return (a + 2.0) * s3 - (a + 3.0) * s2 + 1.0; }
+  if (s < 2.0) { return a * s3 - 5.0 * a * s2 + 8.0 * a * s - 4.0 * a; }
+  return 0.0;
+}
+{% endif %}
+{% macro istride(a) %}
+{% set s = namespace(v = 1) %}
+{% for j in range(a + 1, r) %}{% set s.v = s.v * xs[j] %}{% endfor %}
+{{ s.v }}
+{%- endmacro %}{% macro center(a, oc) %}
+{% set inS = xs[a] %}
+{% set outS = ys[a] %}
+{% set axsc = sc[a] if ((sc | length) > a and sc[a] and sc[a] > 0) else 0 %}
+{% set inv = (1.0 / axsc) if axsc > 0 else (inS / outS) %}
+{% if source.coordinateMode == "align_corners" %}
+  {% if outS == 1 %}0.0{% else %}(f32({{ oc }}) * {{ inS - 1 }}.0 / {{ outS - 1 }}.0){% endif %}
+{% elif source.coordinateMode == "asymmetric" -%}
+  (f32({{ oc }}) * {{ inv }})
+{%- elif source.coordinateMode == "pytorch_half_pixel" %}
+  {% if outS > 1 %}((f32({{ oc }}) + 0.5) * {{ inv }} - 0.5){% else %}0.0{% endif %}
+{% else -%}
+  ((f32({{ oc }}) + 0.5) * {{ inv }} - 0.5)
+{%- endif %}
+{% endmacro %}
+@compute @workgroup_size({{ wg }})
+fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) nwg: vec3<u32>) {
+  let stride = nwg.x * WG;
+  for (var i = gid.x; i < {{ ocount.v }}u; i += stride) {
+    var rem = i;
+{% for a in range(r) %}
+{% set os = namespace(v = 1) %}
+{% for j in range(a + 1, r) %}{% set os.v = os.v * ys[j] %}{% endfor %}
+{% set constantZeroCenter = a in resized.list and ys[a] == 1 and source.coordinateMode in ["align_corners", "pytorch_half_pixel"] %}
+{% if not constantZeroCenter %}
+    let oc{{ a }} = rem / {{ os.v }}u;
+    rem = rem % {{ os.v }}u;
+{% endif %}
+{% endfor %}
+{% for ridx in range(k) %}
+{% set a = resized.list[ridx] %}
+{% set inS = xs[a] %}
+{% set outS = ys[a] %}
+{% set axsc = sc[a] if ((sc | length) > a and sc[a] and sc[a] > 0) else 0 %}
+{% set dsr = (1.0 / axsc) if axsc > 0 else (inS / outS) %}
+{% set fscale = dsr if dsr > 1 else 1.0 %}
+{% set support = fscale * supmul %}
+{% set win = (2 * ceil(support)) + 1 %}
+    // axis {{ a }}: filterscale={{ fscale }}, support={{ support }}, window<={{ win }}
+    let center{{ a }} = {{ center(a, "oc" ~ a) }};
+    let start{{ a }} = i32(floor(center{{ a }} - {{ support }} + 0.5));
+    var wsum{{ a }} = 0.0;
+    var w{{ a }}: array<f32, {{ win }}>;
+{% for t in range(win) %}
+    {
+      let xx = start{{ a }} + {{ t }};
+{% if FILTER == "cubic" %}
+      var ww = cubic_weight((f32(xx) - center{{ a }}) / {{ fscale }});
+{% else %}
+      var ww = 1.0 - abs((f32(xx) - center{{ a }}) / {{ fscale }});
+      ww = max(0.0, ww);
+{% endif %}
+{% if source.excludeOutside %}
+      if (xx < 0 || xx > {{ inS - 1 }}) { ww = 0.0; }
+{% endif %}
+      w{{ a }}[{{ t }}] = ww;
+      wsum{{ a }} = wsum{{ a }} + ww;
+    }
+{% endfor %}
+{% endfor %}
+    var acc = 0.0;{% set total = namespace(v = 1) %}
+{% for ridx in range(k) %}
+{% set a = resized.list[ridx] %}
+{% set inS = xs[a] %}{% set outS = ys[a] %}
+{% set axsc = sc[a] if ((sc | length) > a and sc[a] and sc[a] > 0) else 0 %}
+{% set dsr = (1.0 / axsc) if axsc > 0 else (inS / outS) %}
+{% set fscale = dsr if dsr > 1 else 1.0 %}
+{% set win = (2 * ceil(fscale * supmul)) + 1 %}
+{% set total.v = total.v * win %}
+{% endfor %}
+{% for combo in range(total.v) %}
+    {
+      var cw = 1.0;
+{% set divns = namespace(d = 1) %}
+{% for ridx in range(k) %}
+{% set a = resized.list[ridx] %}
+{% set inS = xs[a] %}{% set outS = ys[a] %}
+{% set axsc = sc[a] if ((sc | length) > a and sc[a] and sc[a] > 0) else 0 %}
+{% set dsr = (1.0 / axsc) if axsc > 0 else (inS / outS) %}
+{% set fscale = dsr if dsr > 1 else 1.0 %}
+{% set win = (2 * ceil(fscale * supmul)) + 1 %}
+{% set t = ((combo / divns.d) | int) % win %}
+{% set divns.d = divns.d * win %}
+      let ci{{ a }} = u32(clamp(start{{ a }} + {{ t }}, 0, {{ inS - 1 }}));
+      cw = cw * w{{ a }}[{{ t }}];
+{% endfor %}
+      let off = 0u{% for a in range(r) %}{% if a in resized.list %} + ci{{ a }} * {{ istride(a) }}u{% else %} + oc{{ a }} * {{ istride(a) }}u{% endif %}{% endfor %};
+      acc = acc + cw * f32(x[off]);
+    }
+{% endfor %}
+    let norm = 1.0{% for ridx in range(k) %}{% set a = resized.list[ridx] %} * wsum{{ a }}{% endfor %};
+    y[i] = {{ scalar }}(acc / norm);
+  }
+}

build/webgpu/resize-coord-transform-5d.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,224 @@

+// Generic NCDHW (rank-5) Resize with full coordinate-transformation math.
+// The batch N and channel C axes are unchanged; the three trailing axes D/H/W
+// are resized. This mirrors the rank-specialized coordinate transform and
+// clamping, so half_pixel, pytorch_half_pixel, asymmetric, and align_corners
+// stay bit-for-bit consistent with the rank-4 path.
+{% set alignCorners = source.coordinateMode == "align_corners" %}
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize %}
+{% if source.mode != "nearest" or not alignCorners %}
+fn source_coord(out_coord: u32, in_size: u32, out_size: u32{% if not alignCorners %}, explicit_scale: f32{% endif %}) -> f32 {
+{% if not alignCorners %}
+  let inferred_scale = f32(out_size) / f32(in_size);
+  let scale = select(inferred_scale, explicit_scale, explicit_scale > 0.0);
+{% endif %}
+  {% if alignCorners %}
+  if (out_size == 1u) { return 0.0; }
+  return f32(out_coord) * f32(in_size - 1u) / f32(out_size - 1u);
+  {% elif source.coordinateMode == "asymmetric" %}
+  return f32(out_coord) / scale;
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  return select(0.0, (f32(out_coord) + 0.5) / scale - 0.5, out_size > 1u);
+  {% elif source.coordinateMode == "half_pixel_symmetric" %}
+  let output_width = f32(in_size) * scale;
+  let adjustment = f32(out_size) / output_width;
+  let center = f32(in_size) * 0.5;
+  let offset = center * (1.0 - adjustment);
+  return offset + (f32(out_coord) + 0.5) / scale - 0.5;
+  {% else %}
+  return (f32(out_coord) + 0.5) / scale - 0.5;
+  {% endif %}
+}
+{% endif %}
+/* Backend-stable nearest-neighbor coordinate selection. Inferred align-corners,
+ * asymmetric, and half-pixel transforms use exact integer ratios. This matters
+ * at nearest-mode ties: reassociating an f32 division into a reciprocal
+ * multiply can move an exact 0.5 to either side of the boundary. */{% set ratioMode = source.coordinateMode in ["align_corners", "asymmetric"] %}
+{% set inferredHalfPixelMode = source.coordinateMode in ["pytorch_half_pixel", "half_pixel", "half_pixel_symmetric"] %}
+{% set noRoi = source.roi is not defined or (source.roi | length) == 0 %}
+{% set usesExplicitScale = source.coordinateMode not in ["align_corners", "tf_crop_and_resize"] %}
+{% if source.mode == "nearest" %}
+fn nearest_index(v: f32) -> i32 {
+  {% if source.nearestMode == "floor" %}
+  return i32(floor(v));
+  {% elif source.nearestMode == "ceil" %}
+  return i32(ceil(v));
+  {% elif source.nearestMode == "round_prefer_ceil" %}
+  // round half toward +inf. WGSL round() is round-half-to-even and therefore
+  // cannot express ONNX's preferred direction. The lower-side epsilon absorbs
+  // backend division error that lands a mathematical half-tie just below .5
+  // (mirror of the round_prefer_floor epsilon below).
+  let tie_epsilon = 0.0000003;
+  let f = floor(v);
+  let frac = v - f;
+  return i32(select(f, f + 1.0, frac >= 0.5 - tie_epsilon));
+  {% else %}
+  // Explicit scales still require f32 coordinate math. Keep a narrow epsilon
+  // for their backend rounding while inferred scales take the exact path below.
+  let tie_epsilon = 0.0000003;
+  let f = floor(v);
+  let frac = v - f;
+  return i32(select(f, f + 1.0, frac > 0.5 + tie_epsilon));
+  {% endif %}
+}
+{% if noRoi and (ratioMode or inferredHalfPixelMode) %}
+fn rational_value_nearest_index(numerator: u32, denominator: u32) -> i32 {
+  if (numerator == 0u || denominator == 0u) {
+    return 0;
+  }
+  let lower = numerator / denominator;
+  {% if source.nearestMode != "floor" %}
+  let remainder = numerator - lower * denominator;
+  {% endif %}
+  {% if source.nearestMode == "floor" %}
+  return i32(lower);
+  {% elif source.nearestMode == "ceil" %}
+  return i32(lower + select(0u, 1u, remainder != 0u));
+  {% elif source.nearestMode == "round_prefer_ceil" %}
+  return i32(lower + select(0u, 1u, remainder >= denominator - remainder));
+  {% else %}
+  return i32(lower + select(0u, 1u, remainder > denominator - remainder));
+  {% endif %}
+}
+{% endif %}
+{% if noRoi and ratioMode %}
+fn rational_nearest_index(coord: u32, numerator: u32, denominator: u32) -> i32 {
+  if (coord == 0u || numerator == 0u || denominator == 0u) {
+    return 0;
+  }
+  // Use 0xfffffffe rather than UINT_MAX for the overflow guard: some shader
+  // compilers reject division with a UINT_MAX constant dividend. The smaller
+  // bound is conservative and sends at most one extra coordinate to the f32 path.
+  if (coord > 0xfffffffeu / numerator) {
+    return nearest_index(f32(coord) * f32(numerator) / f32(denominator));
+  }
+  return rational_value_nearest_index(coord * numerator, denominator);
+}
+{% endif %}
+{% if noRoi and inferredHalfPixelMode %}
+fn inferred_half_pixel_nearest_index(
+  coord: u32,
+  in_size: u32,
+  out_size: u32,
+  subtract_half: bool
+) -> i32 {
+  // (coord + 1/2) * in/out [- 1/2]
+  //   = ((2*coord + 1)*in [- out]) / (2*out)
+  // Use the f32 definition only when the u32 intermediates would overflow.
+  if (in_size == 0u || out_size == 0u || out_size > 0x7fffffffu ||
+      coord > (0xffffffffu - 1u) / 2u) {
+    return nearest_index(source_coord(coord, in_size, out_size, 0.0));
+  }
+  let odd_coord = coord * 2u + 1u;
+  // 0xfffffffe, not 0xffffffff — see rational_nearest_index (NVVM crash).
+  if (odd_coord > 0xfffffffeu / in_size) {
+    return nearest_index(source_coord(coord, in_size, out_size, 0.0));
+  }
+  let scaled = odd_coord * in_size;
+  let shift = select(0u, out_size, subtract_half);
+  // A negative half-pixel coordinate is in [-0.5, 0). Every nearest mode may
+  // choose -1 or 0 there, but Resize clamps both to source index zero.
+  if (scaled <= shift) {
+    return 0;
+  }
+  return rational_value_nearest_index(scaled - shift, out_size * 2u);
+}
+{% endif %}
+fn nearest_coord_index(
+  out_coord: u32,
+  in_size: u32,
+  out_size: u32{% if usesExplicitScale %},
+  explicit_scale: f32
+  {% endif %}
+) -> i32 {
+  {% if source.coordinateMode == "align_corners" %}
+  if (out_size <= 1u || in_size <= 1u) {
+    return 0;
+  }
+  return rational_nearest_index(out_coord, in_size - 1u, out_size - 1u);
+  {% else %}
+  {% if source.coordinateMode == "asymmetric" %}
+  if (explicit_scale <= 0.0) {
+    return rational_nearest_index(out_coord, in_size, out_size);
+  }
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  if (out_size <= 1u) {
+    return 0;
+  }
+  if (explicit_scale <= 0.0) {
+    return inferred_half_pixel_nearest_index(out_coord, in_size, out_size, true);
+  }
+  {% elif source.coordinateMode == "tf_crop_and_resize" %}
+  {% else %}
+  if (explicit_scale <= 0.0) {
+    return inferred_half_pixel_nearest_index(out_coord, in_size, out_size, true);
+  }
+  {% endif %}
+  return nearest_index(source_coord(out_coord, in_size, out_size{% if usesExplicitScale %}, explicit_scale{% endif %}));
+  {% endif %}
+}
+{% else %}
+{% endif -%}
+fn input_at(base: u32, d: i32, h: i32, w: i32) -> f32 {
+  let dd = u32(clamp(d, 0, i32(params.inD) - 1));
+  let hh = u32(clamp(h, 0, i32(params.inH) - 1));
+  let ww = u32(clamp(w, 0, i32(params.inW) - 1));
+  return f32(x[base + (dd * params.inH + hh) * params.inW + ww]);
+}
+@compute @workgroup_size({{ wg }})
+fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) nwg: vec3<u32>) {
+  let i = gid.x + gid.y * nwg.x * {{ wg }}u;
+  if (i >= params.count) { return; }
+  let ow = i % params.outW;
+  let oh = (i / params.outW) % params.outH;
+  let od = (i / (params.outW * params.outH)) % params.outD;
+  let c = (i / (params.outW * params.outH * params.outD)) % params.C;
+  let n = i / (params.outW * params.outH * params.outD * params.C);
+  let base = (n * params.C + c) * params.inD * params.inH * params.inW;
+{% if source.mode != "nearest" %}
+  let sd = source_coord(od, params.inD, params.outD{% if not alignCorners %}, params.scaleD{% endif %});
+  let sy = source_coord(oh, params.inH, params.outH{% if not alignCorners %}, params.scaleH{% endif %});
+  let sx = source_coord(ow, params.inW, params.outW{% if not alignCorners %}, params.scaleW{% endif %});
+{% endif %}
+  {% if source.mode == "nearest" %}
+  let id = nearest_coord_index(od, params.inD, params.outD{% if not alignCorners %}, params.scaleD{% endif %});
+  let ih = nearest_coord_index(oh, params.inH, params.outH{% if not alignCorners %}, params.scaleH{% endif %});
+  let iw = nearest_coord_index(ow, params.inW, params.outW{% if not alignCorners %}, params.scaleW{% endif %});
+  let result = input_at(base, id, ih, iw);
+  {% else %}
+  let z0 = i32(floor(sd));
+  let y0 = i32(floor(sy));
+  let x0 = i32(floor(sx));
+  let z1 = z0 + 1;
+  let y1 = y0 + 1;
+  let x1 = x0 + 1;
+  let wz = sd - f32(z0);
+  let wy = sy - f32(y0);
+  let wx = sx - f32(x0);
+  let c000 = input_at(base, z0, y0, x0);
+  let c001 = input_at(base, z0, y0, x1);
+  let c010 = input_at(base, z0, y1, x0);
+  let c011 = input_at(base, z0, y1, x1);
+  let c100 = input_at(base, z1, y0, x0);
+  let c101 = input_at(base, z1, y0, x1);
+  let c110 = input_at(base, z1, y1, x0);
+  let c111 = input_at(base, z1, y1, x1);
+  let front = (1.0 - wy) * ((1.0 - wx) * c000 + wx * c001) + wy * ((1.0 - wx) * c010 + wx * c011);
+  let back = (1.0 - wy) * ((1.0 - wx) * c100 + wx * c101) + wy * ((1.0 - wx) * c110 + wx * c111);
+  let result = (1.0 - wz) * front + wz * back;
+  {% endif %}
+  y[i] = {{ scalar }}(result);
+}

build/webgpu/resize-coord-transform.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,313 @@

+// Generic NCHW Resize/Upsample with full coordinate-transformation math.
+// Explicit scales of zero are inferred from the output/input shape ratio.
+// Nearest-index rounding is load-bearing for ONNX compatibility:
+// round_prefer_ceil ties toward positive infinity, while round_prefer_floor
+// uses its specified epsilon.
+{% set alignCorners = source.coordinateMode == "align_corners" %}
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize if workgroupSize is defined else tunables.WORKGROUP_SIZE %}
+{% if source.mode != "nearest" or not alignCorners %}fn source_coord(out_coord: u32, in_size: u32, out_size: u32{% if not alignCorners %}, explicit_scale: f32{% endif %}) -> f32 {
+{% if not alignCorners %}
+{% if source.coordinateMode != "asymmetric" %}
+  let inferred_scale = f32(out_size) / f32(in_size);
+  let scale = select(inferred_scale, explicit_scale, explicit_scale > 0.0);
+{% endif %}
+{% endif %}
+  {% if alignCorners %}
+  if (out_size == 1u) { return 0.0; }
+  return f32(out_coord) * f32(in_size - 1u) / f32(out_size - 1u);
+  {% elif source.coordinateMode == "asymmetric" %}
+  // With an inferred scale, divide by sizes (out_coord*in/out) rather than by
+  // the precomputed reciprocal out/in: the single division keeps exact ties
+  // (e.g. a 7->2 downsample at out col 1 == 3.5) exact instead of landing at
+  // 3.4999998 after double rounding. An explicit scale uses coord/scale.
+  return select(f32(out_coord) * f32(in_size) / f32(out_size), f32(out_coord) / explicit_scale, explicit_scale > 0.0);
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  return select(0.0, (f32(out_coord) + 0.5) / scale - 0.5, out_size > 1u);
+  {% elif source.coordinateMode == "half_pixel_symmetric" %}
+  let output_width = f32(in_size) * scale;
+  let adjustment = f32(out_size) / output_width;
+  let center = f32(in_size) * 0.5;
+  let offset = center * (1.0 - adjustment);
+  return offset + (f32(out_coord) + 0.5) / scale - 0.5;
+  {% else %}
+  return (f32(out_coord) + 0.5) / scale - 0.5;
+  {% endif %}
+}{% endif %}
+/* Backend-stable nearest-neighbor coordinate selection. Inferred align-corners,
+ * asymmetric, and half-pixel transforms use exact integer ratios. This matters
+ * at nearest-mode ties: reassociating an f32 division into a reciprocal
+ * multiply can move an exact 0.5 to either side of the boundary. */{% set ratioMode = source.coordinateMode in ["align_corners", "asymmetric"] %}
+{% set inferredHalfPixelMode = source.coordinateMode in ["pytorch_half_pixel", "half_pixel", "half_pixel_symmetric"] %}
+{% set noRoi = source.roi is not defined or (source.roi | length) == 0 %}
+{% set usesExplicitScale = source.coordinateMode not in ["align_corners", "tf_crop_and_resize"] %}
+{% if source.mode == "nearest" %}
+fn nearest_index(v: f32) -> i32 {
+  {% if source.nearestMode == "floor" %}
+  return i32(floor(v));
+  {% elif source.nearestMode == "ceil" %}
+  return i32(ceil(v));
+  {% elif source.nearestMode == "round_prefer_ceil" %}
+  // round half toward +inf. WGSL round() is round-half-to-even and therefore
+  // cannot express ONNX's preferred direction. The lower-side epsilon absorbs
+  // backend division error that lands a mathematical half-tie just below .5
+  // (mirror of the round_prefer_floor epsilon below).
+  let tie_epsilon = 0.0000003;
+  let f = floor(v);
+  let frac = v - f;
+  return i32(select(f, f + 1.0, frac >= 0.5 - tie_epsilon));
+  {% else %}
+  // Explicit scales still require f32 coordinate math. Keep a narrow epsilon
+  // for their backend rounding while inferred scales take the exact path below.
+  let tie_epsilon = 0.0000003;
+  let f = floor(v);
+  let frac = v - f;
+  return i32(select(f, f + 1.0, frac > 0.5 + tie_epsilon));
+  {% endif %}
+}
+{% if noRoi and (ratioMode or inferredHalfPixelMode) %}
+fn rational_value_nearest_index(numerator: u32, denominator: u32) -> i32 {
+  if (numerator == 0u || denominator == 0u) {
+    return 0;
+  }
+  let lower = numerator / denominator;
+  {% if source.nearestMode != "floor" %}
+  let remainder = numerator - lower * denominator;
+  {% endif %}
+  {% if source.nearestMode == "floor" %}
+  return i32(lower);
+  {% elif source.nearestMode == "ceil" %}
+  return i32(lower + select(0u, 1u, remainder != 0u));
+  {% elif source.nearestMode == "round_prefer_ceil" %}
+  return i32(lower + select(0u, 1u, remainder >= denominator - remainder));
+  {% else %}
+  return i32(lower + select(0u, 1u, remainder > denominator - remainder));
+  {% endif %}
+}
+{% endif %}
+{% if noRoi and ratioMode %}
+fn rational_nearest_index(coord: u32, numerator: u32, denominator: u32) -> i32 {
+  if (coord == 0u || numerator == 0u || denominator == 0u) {
+    return 0;
+  }
+  // Use 0xfffffffe rather than UINT_MAX for the overflow guard: some shader
+  // compilers reject division with a UINT_MAX constant dividend. The smaller
+  // bound is conservative and sends at most one extra coordinate to the f32 path.
+  if (coord > 0xfffffffeu / numerator) {
+    return nearest_index(f32(coord) * f32(numerator) / f32(denominator));
+  }
+  return rational_value_nearest_index(coord * numerator, denominator);
+}
+{% endif %}
+{% if noRoi and inferredHalfPixelMode %}
+fn inferred_half_pixel_nearest_index(
+  coord: u32,
+  in_size: u32,
+  out_size: u32,
+  subtract_half: bool
+) -> i32 {
+  // (coord + 1/2) * in/out [- 1/2]
+  //   = ((2*coord + 1)*in [- out]) / (2*out)
+  // Use the f32 definition only when the u32 intermediates would overflow.
+  if (in_size == 0u || out_size == 0u || out_size > 0x7fffffffu ||
+      coord > (0xffffffffu - 1u) / 2u) {
+    return nearest_index(source_coord(coord, in_size, out_size, 0.0));
+  }
+  let odd_coord = coord * 2u + 1u;
+  // 0xfffffffe, not 0xffffffff — see rational_nearest_index (NVVM crash).
+  if (odd_coord > 0xfffffffeu / in_size) {
+    return nearest_index(source_coord(coord, in_size, out_size, 0.0));
+  }
+  let scaled = odd_coord * in_size;
+  let shift = select(0u, out_size, subtract_half);
+  // A negative half-pixel coordinate is in [-0.5, 0). Every nearest mode may
+  // choose -1 or 0 there, but Resize clamps both to source index zero.
+  if (scaled <= shift) {
+    return 0;
+  }
+  return rational_value_nearest_index(scaled - shift, out_size * 2u);
+}
+{% endif %}
+fn nearest_coord_index(
+  out_coord: u32,
+  in_size: u32,
+  out_size: u32{% if usesExplicitScale %},
+  explicit_scale: f32
+  {% endif %}
+) -> i32 {
+  {% if source.coordinateMode == "align_corners" %}
+  if (out_size <= 1u || in_size <= 1u) {
+    return 0;
+  }
+  return rational_nearest_index(out_coord, in_size - 1u, out_size - 1u);
+  {% else %}
+  {% if source.coordinateMode == "asymmetric" %}
+  if (explicit_scale <= 0.0) {
+    return rational_nearest_index(out_coord, in_size, out_size);
+  }
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  if (out_size <= 1u) {
+    return 0;
+  }
+  if (explicit_scale <= 0.0) {
+    return inferred_half_pixel_nearest_index(out_coord, in_size, out_size, true);
+  }
+  {% elif source.coordinateMode == "tf_crop_and_resize" %}
+  {% else %}
+  if (explicit_scale <= 0.0) {
+    return inferred_half_pixel_nearest_index(out_coord, in_size, out_size, true);
+  }
+  {% endif %}
+  return nearest_index(source_coord(out_coord, in_size, out_size{% if usesExplicitScale %}, explicit_scale{% endif %}));
+  {% endif %}
+}
+{% else %}
+{% endif -%}
+fn input_at(base: u32, h: i32, w: i32) -> f32 {
+  let hh = u32(clamp(h, 0, i32(params.inH) - 1));
+  let ww = u32(clamp(w, 0, i32(params.inW) - 1));
+  return f32(x[base + hh * params.inW + ww]);
+}
+{% if source.mode == "linear" %}
+// Clamp before choosing neighbors. At an edge both neighbors coincide and
+// receive half weight; the four-term order is observable for integer outputs.
+fn bilinear_sample(base: u32, source_y: f32, source_x: f32) -> f32 {
+  let sy = clamp(source_y, 0.0, f32(params.inH - 1u));
+  let sx = clamp(source_x, 0.0, f32(params.inW - 1u));
+  let y0 = i32(floor(sy));
+  let x0 = i32(floor(sx));
+  let y1 = min(y0 + 1, i32(params.inH) - 1);
+  let x1 = min(x0 + 1, i32(params.inW) - 1);
+  let same_y = y0 == y1;
+  let same_x = x0 == x1;
+  let wy0 = select(abs(sy - f32(y1)), 0.5, same_y);
+  let wy1 = select(abs(sy - f32(y0)), 0.5, same_y);
+  let wx0 = select(abs(sx - f32(x1)), 0.5, same_x);
+  let wx1 = select(abs(sx - f32(x0)), 0.5, same_x);
+  let v00 = input_at(base, y0, x0);
+  let v01 = input_at(base, y0, x1);
+  let v10 = input_at(base, y1, x0);
+  let v11 = input_at(base, y1, x1);
+  return wx0 * wy0 * v00 + wx1 * wy0 * v01 + wx0 * wy1 * v10 + wx1 * wy1 * v11;
+}
+{% endif %}
+@compute @workgroup_size({{ wg }})
+fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) nwg: vec3<u32>) {
+  // 2D-folded flat index: gid.y carries the high bits past the
+  // maxComputeWorkgroupsPerDimension limit.
+  let flat = gid.x + gid.y * nwg.x * {{ wg }}u;
+{% if not alignCorners %}
+  let scaleH_val = params.scaleH;
+  let scaleW_val = params.scaleW;
+{% endif %}
+{% if source.vec4 %}
+  // One thread owns 4 contiguous output columns (outW % 4 == 0, so a 4-group
+  // never crosses a row): all 4 lanes share oh/c/n and the source row coord sy;
+  // only sx differs per lane. One 128-bit vec4 store. Bit-identical to scalar.
+  let count4 = params.count / 4u;
+  if (flat >= count4) { return; }
+  let i = flat * 4u;
+  let ow0 = i % params.outW;
+  let row = i / params.outW;
+  let oh = row % params.outH;
+  let c = (row / params.outH) % params.C;
+  let n = row / (params.outH * params.C);
+  let base = (n * params.C + c) * params.inH * params.inW;
+{% if source.mode != "nearest" %}
+  let sy = source_coord(oh, params.inH, params.outH{% if not alignCorners %}, scaleH_val{% endif %});
+  let sx0 = source_coord(ow0, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let sx1 = source_coord(ow0 + 1u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let sx2 = source_coord(ow0 + 2u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let sx3 = source_coord(ow0 + 3u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+{% endif %}
+  {% if source.mode == "nearest" %}
+  let ih = nearest_coord_index(oh, params.inH, params.outH{% if not alignCorners %}, scaleH_val{% endif %});
+  let r = vec4<f32>(
+    input_at(base, ih, nearest_coord_index(ow0, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})),
+    input_at(base, ih, nearest_coord_index(ow0 + 1u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})),
+    input_at(base, ih, nearest_coord_index(ow0 + 2u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})),
+    input_at(base, ih, nearest_coord_index(ow0 + 3u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})));
+  {% else %}
+  let r = vec4<f32>(
+    bilinear_sample(base, sy, sx0),
+    bilinear_sample(base, sy, sx1),
+    bilinear_sample(base, sy, sx2),
+    bilinear_sample(base, sy, sx3));
+  {% endif %}
+  y[flat] = {{ source.vecType }}(r);
+{% elif source.scalarX4 %}
+  // Four columns per thread without a vec4 storage binding. Unlike the packed
+  // route this remains valid for odd outW: group indexing is row-local and the
+  // final 1--3 lanes are guarded scalar stores.
+  let groups_per_row = (params.outW + 3u) / 4u;
+  let group_count = (params.count / params.outW) * groups_per_row;
+  if (flat >= group_count) { return; }
+  let group_in_row = flat % groups_per_row;
+  let row = flat / groups_per_row;
+  let ow0 = group_in_row * 4u;
+  let oh = row % params.outH;
+  let c = (row / params.outH) % params.C;
+  let n = row / (params.outH * params.C);
+  let base = (n * params.C + c) * params.inH * params.inW;
+{% if source.mode != "nearest" %}
+  let sy = source_coord(oh, params.inH, params.outH{% if not alignCorners %}, scaleH_val{% endif %});
+  let sx0 = source_coord(ow0, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let sx1 = source_coord(ow0 + 1u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let sx2 = source_coord(ow0 + 2u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let sx3 = source_coord(ow0 + 3u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+{% endif %}
+  {% if source.mode == "nearest" %}
+  let ih = nearest_coord_index(oh, params.inH, params.outH{% if not alignCorners %}, scaleH_val{% endif %});
+  let r = vec4<f32>(
+    input_at(base, ih, nearest_coord_index(ow0, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})),
+    input_at(base, ih, nearest_coord_index(ow0 + 1u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})),
+    input_at(base, ih, nearest_coord_index(ow0 + 2u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})),
+    input_at(base, ih, nearest_coord_index(ow0 + 3u, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %})));
+  {% else %}
+  let r = vec4<f32>(
+    bilinear_sample(base, sy, sx0),
+    bilinear_sample(base, sy, sx1),
+    bilinear_sample(base, sy, sx2),
+    bilinear_sample(base, sy, sx3));
+  {% endif %}
+  let i = row * params.outW + ow0;
+  y[i] = {{ scalar }}(r.x);
+  if (ow0 + 1u < params.outW) { y[i + 1u] = {{ scalar }}(r.y); }
+  if (ow0 + 2u < params.outW) { y[i + 2u] = {{ scalar }}(r.z); }
+  if (ow0 + 3u < params.outW) { y[i + 3u] = {{ scalar }}(r.w); }
+{% else %}
+  let i = flat;
+  if (i >= params.count) { return; }
+  let ow = i % params.outW;
+  let oh = (i / params.outW) % params.outH;
+  let c = (i / (params.outW * params.outH)) % params.C;
+  let n = i / (params.outW * params.outH * params.C);
+  let base = (n * params.C + c) * params.inH * params.inW;
+{% if source.mode != "nearest" %}
+  let sy = source_coord(oh, params.inH, params.outH{% if not alignCorners %}, scaleH_val{% endif %});
+  let sx = source_coord(ow, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+{% endif %}
+  {% if source.mode == "nearest" %}
+  let ih = nearest_coord_index(oh, params.inH, params.outH{% if not alignCorners %}, scaleH_val{% endif %});
+  let iw = nearest_coord_index(ow, params.inW, params.outW{% if not alignCorners %}, scaleW_val{% endif %});
+  let result = input_at(base, ih, iw);
+  {% else %}
+  let result = bilinear_sample(base, sy, sx);
+  {% endif %}
+  y[i] = {{ scalar }}(result);
+{% endif %}
+}

build/webgpu/resize-cubic.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,118 @@

+// Generic NCHW Resize with separable Keys cubic interpolation. Each output
+// coordinate maps to input space and samples the four taps around floor(src)
+// at offsets {-1, 0, 1, 2}. The rows-then-columns pass uses 16 taps in 2D.
+// Sample coordinates clamp to [0, dim - 1] when exclude_outside is disabled.
+// The coefficient `a` is cubic_coeff_a (default -0.75), and half_pixel,
+// pytorch_half_pixel, asymmetric, and align_corners follow the same coordinate
+// rules as the other Resize kernels.
+{% set EXCL = source.excludeOutside is defined and source.excludeOutside == 1 %}
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize %}
+fn source_coord(out_coord: u32, in_size: u32, out_size: u32{% if source.coordinateMode != "align_corners" %}, explicit_scale: f32{% endif %}) -> f32 {
+{% if source.coordinateMode != "align_corners" %}
+  let inferred_scale = f32(out_size) / f32(in_size);
+  let scale = select(inferred_scale, explicit_scale, explicit_scale > 0.0);
+{% endif %}
+  {% if source.coordinateMode == "align_corners" %}
+  if (out_size == 1u) { return 0.0; }
+  return f32(out_coord) * f32(in_size - 1u) / f32(out_size - 1u);
+  {% elif source.coordinateMode == "asymmetric" %}
+  return f32(out_coord) / scale;
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  return select(0.0, (f32(out_coord) + 0.5) / scale - 0.5, out_size > 1u);
+  {% else %}
+  return (f32(out_coord) + 0.5) / scale - 0.5;
+  {% endif %}
+}
+// Keys cubic convolution kernel with coefficient params.coeffA.
+fn cubic_weight(s_in: f32) -> f32 {
+  let a = params.coeffA;
+  let s = abs(s_in);
+  let s2 = s * s;
+  let s3 = s2 * s;
+  if (s <= 1.0) {
+    return (a + 2.0) * s3 - (a + 3.0) * s2 + 1.0;
+  }
+  if (s < 2.0) {
+    return a * s3 - 5.0 * a * s2 + 8.0 * a * s - 4.0 * a;
+  }
+  return 0.0;
+}
+fn input_at(base: u32, h: i32, w: i32) -> f32 {
+  let hh = u32(clamp(h, 0, i32(params.inH) - 1));
+  let ww = u32(clamp(w, 0, i32(params.inW) - 1));
+  return f32(x[base + hh * params.inW + ww]);
+}
+// Cubic interpolation along the W axis for a fixed input row `h`, at source
+// column `sx`. Four taps at floor(sx)-1 .. floor(sx)+2.
+fn cubic_x(base: u32, h: i32, sx: f32) -> f32 {
+  let x0 = i32(floor(sx));
+  let t = sx - f32(x0);
+  var w0 = cubic_weight(1.0 + t);
+  var w1 = cubic_weight(t);
+  var w2 = cubic_weight(1.0 - t);
+  var w3 = cubic_weight(2.0 - t);
+{% if EXCL %}
+  // exclude_outside: zero taps outside the input range, renormalize the rest.
+  let wlim = i32(params.inW);
+  if (x0 - 1 < 0 || x0 - 1 >= wlim) { w0 = 0.0; }
+  if (x0 < 0 || x0 >= wlim) { w1 = 0.0; }
+  if (x0 + 1 < 0 || x0 + 1 >= wlim) { w2 = 0.0; }
+  if (x0 + 2 < 0 || x0 + 2 >= wlim) { w3 = 0.0; }
+  let wsum = w0 + w1 + w2 + w3;
+  w0 = w0 / wsum;
+  w1 = w1 / wsum;
+  w2 = w2 / wsum;
+  w3 = w3 / wsum;
+{% endif %}
+  return w0 * input_at(base, h, x0 - 1)
+       + w1 * input_at(base, h, x0)
+       + w2 * input_at(base, h, x0 + 1)
+       + w3 * input_at(base, h, x0 + 2);
+}
+@compute @workgroup_size({{ wg }})
+fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) nwg: vec3<u32>) {
+  // 2D-folded flat index: gid.y carries the high bits past the
+  // maxComputeWorkgroupsPerDimension limit.
+  let i = gid.x + gid.y * nwg.x * {{ wg }}u;
+  if (i >= params.count) { return; }
+  let ow = i % params.outW;
+  let oh = (i / params.outW) % params.outH;
+  let c = (i / (params.outW * params.outH)) % params.C;
+  let n = i / (params.outW * params.outH * params.C);
+  let base = (n * params.C + c) * params.inH * params.inW;
+  let sy = source_coord(oh, params.inH, params.outH{% if source.coordinateMode != "align_corners" %}, params.scaleH{% endif %});
+  let sx = source_coord(ow, params.inW, params.outW{% if source.coordinateMode != "align_corners" %}, params.scaleW{% endif %});
+  // Separable: cubic along W for each of the 4 source rows, then cubic along H.
+  let y0 = i32(floor(sy));
+  let t = sy - f32(y0);
+  var wy0 = cubic_weight(1.0 + t);
+  var wy1 = cubic_weight(t);
+  var wy2 = cubic_weight(1.0 - t);
+  var wy3 = cubic_weight(2.0 - t);
+{% if EXCL %}
+  let hlim = i32(params.inH);
+  if (y0 - 1 < 0 || y0 - 1 >= hlim) { wy0 = 0.0; }
+  if (y0 < 0 || y0 >= hlim) { wy1 = 0.0; }
+  if (y0 + 1 < 0 || y0 + 1 >= hlim) { wy2 = 0.0; }
+  if (y0 + 2 < 0 || y0 + 2 >= hlim) { wy3 = 0.0; }
+  let wysum = wy0 + wy1 + wy2 + wy3;
+  wy0 = wy0 / wysum;
+  wy1 = wy1 / wysum;
+  wy2 = wy2 / wysum;
+  wy3 = wy3 / wysum;
+{% endif %}
+  let result = wy0 * cubic_x(base, y0 - 1, sx)
+             + wy1 * cubic_x(base, y0, sx)
+             + wy2 * cubic_x(base, y0 + 1, sx)
+             + wy3 * cubic_x(base, y0 + 2, sx);
+  y[i] = {{ scalar }}(result);
+}

build/webgpu/resize-generic.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,409 @@

+// Rank-generic Resize for arbitrary ranks and resized axes, including
+// tf_crop_and_resize with an ROI and extrapolation value. The per-axis
+// coordinate transform follows the rank-specialized paths so half_pixel,
+// pytorch_half_pixel, asymmetric, and align_corners stay
+// consistent. Linear interpolation runs only over resized axes; passthrough
+// axes contribute one tap.
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize if workgroupSize is defined else tunables.WORKGROUP_SIZE %}
+{%- set xs = source.xShape %}
+{% set ys = source.yShape %}
+{% set r = xs | length -%}
+{% set usesExplicitScale = source.coordinateMode not in ["align_corners", "tf_crop_and_resize"] %}
+{% set resolvedScales = namespace(values = []) %}
+{% for a in range(r) %}
+{% set axisScale = namespace(value = 0) %}
+{% if source.scales is defined and source.scales %}
+{% if source.axes is defined and source.axes %}
+{% for j in range(source.axes | length) %}
+{% set scaleAxis = source.axes[j] if source.axes[j] >= 0 else source.axes[j] + r %}
+{% if scaleAxis == a %}{% set axisScale.value = source.scales[j] %}{% endif %}
+{% endfor %}
+{% else %}
+{% set axisScale.value = source.scales[a] %}
+{% endif %}
+{% endif %}
+{% set resolvedScales.values = resolvedScales.values + [axisScale.value] %}
+{% endfor %}
+{% set staticScales = resolvedScales.values %}
+{% set roiStarts = namespace(values = []) %}
+{% set roiEnds = namespace(values = []) %}
+{% for a in range(r) %}
+{% set bounds = namespace(start = 0, end = 1) %}
+{% if source.roi is defined and source.roi %}
+{% if source.axes is defined and source.axes %}
+{% for j in range(source.axes | length) %}
+{% set roiAxis = source.axes[j] if source.axes[j] >= 0 else source.axes[j] + r %}
+{% if roiAxis == a %}
+{% set bounds.start = source.roi[j] %}
+{% set bounds.end = source.roi[j + (source.axes | length)] %}
+{% endif %}
+{% endfor %}
+{% else %}
+{% set bounds.start = source.roi[a] %}
+{% set bounds.end = source.roi[a + r] %}
+{% endif %}
+{% endif %}
+{% set roiStarts.values = roiStarts.values + [bounds.start] %}
+{% set roiEnds.values = roiEnds.values + [bounds.end] %}
+{% endfor %}
+{% set staticRoi = roiStarts.values + roiEnds.values %}{% set ocount = namespace(v = 1) %}
+{% for a in range(r) %}{% set ocount.v = ocount.v * ys[a] %}{% endfor %}{% set resized = namespace(list = []) %}
+{% for a in range(r) %}
+{% if xs[a] != ys[a] or (source.scalesBuffer | default(false)) or (staticScales[a] > 0 and staticScales[a] != 1) or ((source.roi is defined and source.roi) and (staticRoi[a] != 0 or staticRoi[a + r] != 1)) %}
+{% set resized.list = resized.list + [a] %}
+{% endif %}
+{% endfor %}
+{% set k = resized.list | length %}
+const WG: u32 = {{ wg }}u;
+// Runtime form used by the shared exact-nearest helper. The generic kernel's
+// interpolation paths keep their baked expressions below; nearest uses this
+// function only when an exact inferred-ratio path is unavailable.
+{% if source.mode == "nearest" and k > 0 and (source.roi is not defined or (source.roi | length) == 0) and source.coordinateMode != "align_corners" %}
+fn source_coord(out_coord: u32, in_size: u32, out_size: u32{% if usesExplicitScale %}, explicit_scale: f32{% endif %}) -> f32 {
+{% if source.coordinateMode not in ["asymmetric", "tf_crop_and_resize"] %}
+  let inferred_scale = f32(out_size) / f32(in_size);
+  let scale = select(inferred_scale, explicit_scale, explicit_scale > 0.0);
+{% endif %}
+  {% if source.coordinateMode == "asymmetric" %}
+  return select(f32(out_coord) * f32(in_size) / f32(out_size), f32(out_coord) / explicit_scale, explicit_scale > 0.0);
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  return select(0.0, (f32(out_coord) + 0.5) / scale - 0.5, out_size > 1u);
+  {% elif source.coordinateMode == "tf_crop_and_resize" %}
+  let input_span = f32(in_size) - 1.0;
+  if (out_size <= 1u) { return 0.5 * input_span; }
+  return f32(out_coord) * input_span / (f32(out_size) - 1.0);
+  {% elif source.coordinateMode == "half_pixel_symmetric" %}
+  let output_width = f32(in_size) * scale;
+  let adjustment = f32(out_size) / output_width;
+  let center = f32(in_size) * 0.5;
+  let offset = center * (1.0 - adjustment);
+  return offset + (f32(out_coord) + 0.5) / scale - 0.5;
+  {% else %}
+  return (f32(out_coord) + 0.5) / scale - 0.5;
+  {% endif %}
+}
+{%- endif %}
+{% macro istride(a) %}
+{% set s = namespace(v = 1) %}
+{% for j in range(a + 1, r) %}{% set s.v = s.v * xs[j] %}{% endfor %}
+{{ s.v }}
+{%- endmacro %}
+{% macro out_coord(a) -%}
+{% if ys[a] == 1 -%}0u{% else -%}oc{{ a }}{% endif -%}
+{% endmacro %}{% macro src_coord(a, oc) %}
+{% set inS = xs[a] %}
+{% set outS = ys[a] %}
+{% if source.roi is defined and source.roi %}
+  {% set start = staticRoi[a] %}
+  {% set end = staticRoi[a + r] %}
+  {% if outS > 1 -%}
+    ({{ start }} * {{ inS - 1 }}.0 + f32({{ oc }}) * (({{ end }}) - ({{ start }})) * {{ inS - 1 }}.0 / {{ outS - 1 }}.0)
+  {%- else -%}
+    (0.5 * (({{ start }}) + ({{ end }})) * {{ inS - 1 }}.0)
+  {%- endif %}
+{% elif source.coordinateMode == "tf_crop_and_resize" %}
+  select(
+    (0.5 * {{ inS - 1 }}.0),
+    (f32({{ oc }}) * {{ inS - 1 }}.0 / f32(max({{ outS }}u - 1u, 1u))),
+    {{ outS }}u > 1u)
+{% elif staticScales[a] > 0 %}
+  {% set scale = staticScales[a] %}
+  {% if source.coordinateMode == "asymmetric" -%}
+    (f32({{ oc }}) / {{ scale }})
+  {%- elif source.coordinateMode == "pytorch_half_pixel" %}
+    {% if outS > 1 %}((f32({{ oc }}) + 0.5) / {{ scale }} - 0.5){% else %}0.0{% endif %}
+  {%- elif source.coordinateMode == "align_corners" %}
+    {% if outS == 1 %}0.0{% else %}(f32({{ oc }}) * {{ inS - 1 }}.0 / {{ outS - 1 }}.0){% endif %}
+  {% elif source.coordinateMode == "half_pixel_symmetric" %}
+    {% set adjustment = outS / (inS * scale) %}
+    {% set offset = inS * 0.5 * (1.0 - adjustment) %}
+    ({{ offset }} + (f32({{ oc }}) + 0.5) / {{ scale }} - 0.5)
+  {% else -%}
+    ((f32({{ oc }}) + 0.5) / {{ scale }} - 0.5)
+  {%- endif %}
+{% else %}
+  {% if source.coordinateMode == "align_corners" %}
+    {% if outS == 1 %}0.0{% else %}(f32({{ oc }}) * {{ inS - 1 }}.0 / {{ outS - 1 }}.0){% endif %}
+  {% elif source.coordinateMode == "asymmetric" -%}
+    (f32({{ oc }}) * {{ inS }}.0 / {{ outS }}.0)
+  {%- elif source.coordinateMode == "pytorch_half_pixel" %}
+    {% if outS > 1 %}((f32({{ oc }}) + 0.5) * {{ inS }}.0 / {{ outS }}.0 - 0.5){% else %}0.0{% endif %}
+  {%- else -%}
+    ((f32({{ oc }}) + 0.5) * {{ inS }}.0 / {{ outS }}.0 - 0.5)
+  {%- endif %}
+{% endif %}
+{% endmacro %}
+{% set EXCL = source.excludeOutside is defined and source.excludeOutside == 1 %}
+{% if source.mode == "cubic" %}
+// Keys cubic convolution kernel with coefficient coeffA.
+fn cubic_weight(s_in: f32) -> f32 {
+  let a = f32({{ source.coeffA }});
+  let s = abs(s_in);
+  let s2 = s * s;
+  let s3 = s2 * s;
+  if (s <= 1.0) { return (a + 2.0) * s3 - (a + 3.0) * s2 + 1.0; }
+  if (s < 2.0) { return a * s3 - 5.0 * a * s2 + 8.0 * a * s - 4.0 * a; }
+  return 0.0;
+}
+{% endif %}
+{% if source.mode == "nearest" and k > 0 %}
+/* Backend-stable nearest-neighbor coordinate selection. Inferred align-corners,
+ * asymmetric, and half-pixel transforms use exact integer ratios. This matters
+ * at nearest-mode ties: reassociating an f32 division into a reciprocal
+ * multiply can move an exact 0.5 to either side of the boundary. */{% set ratioMode = source.coordinateMode in ["align_corners", "asymmetric"] %}
+{% set inferredHalfPixelMode = source.coordinateMode in ["pytorch_half_pixel", "half_pixel", "half_pixel_symmetric"] %}
+{% set noRoi = source.roi is not defined or (source.roi | length) == 0 %}
+{% set usesExplicitScale = source.coordinateMode not in ["align_corners", "tf_crop_and_resize"] %}
+{% if source.mode == "nearest" %}
+fn nearest_index(v: f32) -> i32 {
+  {% if source.nearestMode == "floor" %}
+  return i32(floor(v));
+  {% elif source.nearestMode == "ceil" %}
+  return i32(ceil(v));
+  {% elif source.nearestMode == "round_prefer_ceil" %}
+  // round half toward +inf. WGSL round() is round-half-to-even and therefore
+  // cannot express ONNX's preferred direction. The lower-side epsilon absorbs
+  // backend division error that lands a mathematical half-tie just below .5
+  // (mirror of the round_prefer_floor epsilon below).
+  let tie_epsilon = 0.0000003;
+  let f = floor(v);
+  let frac = v - f;
+  return i32(select(f, f + 1.0, frac >= 0.5 - tie_epsilon));
+  {% else %}
+  // Explicit scales still require f32 coordinate math. Keep a narrow epsilon
+  // for their backend rounding while inferred scales take the exact path below.
+  let tie_epsilon = 0.0000003;
+  let f = floor(v);
+  let frac = v - f;
+  return i32(select(f, f + 1.0, frac > 0.5 + tie_epsilon));
+  {% endif %}
+}
+{% if noRoi and (ratioMode or inferredHalfPixelMode) %}
+fn rational_value_nearest_index(numerator: u32, denominator: u32) -> i32 {
+  if (numerator == 0u || denominator == 0u) {
+    return 0;
+  }
+  let lower = numerator / denominator;
+  {% if source.nearestMode != "floor" %}
+  let remainder = numerator - lower * denominator;
+  {% endif %}
+  {% if source.nearestMode == "floor" %}
+  return i32(lower);
+  {% elif source.nearestMode == "ceil" %}
+  return i32(lower + select(0u, 1u, remainder != 0u));
+  {% elif source.nearestMode == "round_prefer_ceil" %}
+  return i32(lower + select(0u, 1u, remainder >= denominator - remainder));
+  {% else %}
+  return i32(lower + select(0u, 1u, remainder > denominator - remainder));
+  {% endif %}
+}
+{% endif %}
+{% if noRoi and ratioMode %}
+fn rational_nearest_index(coord: u32, numerator: u32, denominator: u32) -> i32 {
+  if (coord == 0u || numerator == 0u || denominator == 0u) {
+    return 0;
+  }
+  // Use 0xfffffffe rather than UINT_MAX for the overflow guard: some shader
+  // compilers reject division with a UINT_MAX constant dividend. The smaller
+  // bound is conservative and sends at most one extra coordinate to the f32 path.
+  if (coord > 0xfffffffeu / numerator) {
+    return nearest_index(f32(coord) * f32(numerator) / f32(denominator));
+  }
+  return rational_value_nearest_index(coord * numerator, denominator);
+}
+{% endif %}
+{% if noRoi and inferredHalfPixelMode %}
+fn inferred_half_pixel_nearest_index(
+  coord: u32,
+  in_size: u32,
+  out_size: u32,
+  subtract_half: bool
+) -> i32 {
+  // (coord + 1/2) * in/out [- 1/2]
+  //   = ((2*coord + 1)*in [- out]) / (2*out)
+  // Use the f32 definition only when the u32 intermediates would overflow.
+  if (in_size == 0u || out_size == 0u || out_size > 0x7fffffffu ||
+      coord > (0xffffffffu - 1u) / 2u) {
+    return nearest_index(source_coord(coord, in_size, out_size, 0.0));
+  }
+  let odd_coord = coord * 2u + 1u;
+  // 0xfffffffe, not 0xffffffff — see rational_nearest_index (NVVM crash).
+  if (odd_coord > 0xfffffffeu / in_size) {
+    return nearest_index(source_coord(coord, in_size, out_size, 0.0));
+  }
+  let scaled = odd_coord * in_size;
+  let shift = select(0u, out_size, subtract_half);
+  // A negative half-pixel coordinate is in [-0.5, 0). Every nearest mode may
+  // choose -1 or 0 there, but Resize clamps both to source index zero.
+  if (scaled <= shift) {
+    return 0;
+  }
+  return rational_value_nearest_index(scaled - shift, out_size * 2u);
+}
+{% endif %}
+{% if noRoi %}
+fn nearest_coord_index(
+  out_coord: u32,
+  in_size: u32,
+  out_size: u32{% if usesExplicitScale %},
+  explicit_scale: f32
+  {% endif %}
+) -> i32 {
+  {% if source.coordinateMode == "align_corners" %}
+  if (out_size <= 1u || in_size <= 1u) {
+    return 0;
+  }
+  return rational_nearest_index(out_coord, in_size - 1u, out_size - 1u);
+  {% else %}
+  {% if source.coordinateMode == "asymmetric" %}
+  if (explicit_scale <= 0.0) {
+    return rational_nearest_index(out_coord, in_size, out_size);
+  }
+  {% elif source.coordinateMode == "pytorch_half_pixel" %}
+  if (out_size <= 1u) {
+    return 0;
+  }
+  if (explicit_scale <= 0.0) {
+    return inferred_half_pixel_nearest_index(out_coord, in_size, out_size, true);
+  }
+  {% elif source.coordinateMode == "tf_crop_and_resize" %}
+  {% else %}
+  if (explicit_scale <= 0.0) {
+    return inferred_half_pixel_nearest_index(out_coord, in_size, out_size, true);
+  }
+  {% endif %}
+  return nearest_index(source_coord(out_coord, in_size, out_size{% if usesExplicitScale %}, explicit_scale{% endif %}));
+  {% endif %}
+}
+{% endif %}
+{% else %}
+{% endif -%}
+{% endif %}
+@compute @workgroup_size({{ wg }})
+fn main(@builtin(global_invocation_id) gid: vec3<u32>, @builtin(num_workgroups) nwg: vec3<u32>) {
+  let stride = nwg.x * WG;
+  for (var i = gid.x; i < {{ ocount.v }}u; i += stride) {
+    // Decompose flat output index into per-axis output coords.
+{% if ocount.v != 1 %}
+    var rem = i;
+{% endif %}
+{% for a in range(r) %}
+{% set os = namespace(v = 1) %}
+{% for j in range(a + 1, r) %}{% set os.v = os.v * ys[j] %}{% endfor %}
+{% if ys[a] != 1 %}
+    let oc{{ a }} = rem / {{ os.v }}u;
+    rem = rem % {{ os.v }}u;
+{% endif %}
+{% endfor %}
+    // Per-axis source coordinates.
+{% for a in range(r) %}
+{% if a in resized.list and (source.mode != "nearest" or (source.roi is defined and source.roi)) %}
+    let s{{ a }} = {{ src_coord(a, out_coord(a)) }};
+{% endif %}
+{% endfor %}
+{% if source.roi is defined and source.roi %}
+    // tf_crop_and_resize extrapolation: any resized axis out of [0, in-1].
+    var oob = false;
+{% for a in resized.list %}
+    if (s{{ a }} < 0.0 || s{{ a }} > {{ xs[a] - 1 }}.0) { oob = true; }
+{% endfor %}
+    if (oob) { y[i] = {{ scalar }}(f32({{ source.extrapolationValue }})); continue; }
+{% endif %}
+{% if source.mode == "nearest" %}
+{% for a in range(r) %}
+{% if a in resized.list %}
+{% if source.roi is defined and source.roi %}
+    let idx{{ a }} = u32(clamp(nearest_index(s{{ a }}), 0, {{ xs[a] - 1 }}));
+{% else %}
+{% if staticScales[a] > 0 %}
+{% set explicitScale = staticScales[a] %}
+{% else %}
+{% set explicitScale = "0.0" %}
+{% endif %}
+    let idx{{ a }} = u32(clamp(nearest_coord_index({{ out_coord(a) }}, {{ xs[a] }}u, {{ ys[a] }}u{% if usesExplicitScale %}, {{ explicitScale }}{% endif %}), 0, {{ xs[a] - 1 }}));
+{% endif %}
+{% else %}
+    let idx{{ a }} = {{ out_coord(a) }};
+{% endif %}
+{% endfor %}
+    y[i] = {{ scalar }}(f32(x[0u{% for a in range(r) %} + idx{{ a }} * {{ istride(a) }}u{% endfor %}]));
+{% elif source.mode == "cubic" %}
+    // Separable Keys cubic: 4 taps per resized axis (offsets -1..2), passthrough
+    // axes contribute a single tap. 4^k taps total.
+{% for a in resized.list %}
+    let lo{{ a }} = i32(floor(s{{ a }}));
+    let t{{ a }} = s{{ a }} - f32(lo{{ a }});
+    var cwv{{ a }} = array<f32, 4>(cubic_weight(1.0 + t{{ a }}), cubic_weight(t{{ a }}), cubic_weight(1.0 - t{{ a }}), cubic_weight(2.0 - t{{ a }}));
+{% if EXCL %}
+    // exclude_outside: zero taps outside the input range, renormalize per axis.
+    for (var q = 0; q < 4; q++) {
+      if (lo{{ a }} + q - 1 < 0 || lo{{ a }} + q - 1 > {{ xs[a] - 1 }}) { cwv{{ a }}[q] = 0.0; }
+    }
+    let cws{{ a }} = cwv{{ a }}[0] + cwv{{ a }}[1] + cwv{{ a }}[2] + cwv{{ a }}[3];
+    for (var q = 0; q < 4; q++) { cwv{{ a }}[q] = cwv{{ a }}[q] / cws{{ a }}; }
+{% endif %}
+{% endfor %}
+    var acc = 0.0;
+{% for combo in range(pow(4, k)) %}
+    {
+      var cw = 1.0;
+{% for ridx in range(k) %}
+{% set a = resized.list[ridx] %}
+{% set tap = ((combo / pow(4, ridx)) | int) % 4 %}
+      let ci{{ a }} = clamp(lo{{ a }} + {{ tap - 1 }}, 0, {{ xs[a] - 1 }});
+      cw = cw * cwv{{ a }}[{{ tap }}];
+{% endfor %}
+      let off = 0u{% for a in range(r) %}{% if a in resized.list %} + u32(ci{{ a }}) * {{ istride(a) }}u{% else %} + {{ out_coord(a) }} * {{ istride(a) }}u{% endif %}{% endfor %};
+      acc = acc + cw * f32(x[off]);
+    }
+{% endfor %}
+    y[i] = {{ scalar }}(acc);
+{% else %}
+    // Linear: interpolate over the resized axes (2^k corners); passthrough axes
+    // contribute their fixed index with weight 1.
+{% for a in resized.list %}
+    let lo{{ a }} = i32(floor(s{{ a }}));
+    let w{{ a }} = s{{ a }} - f32(lo{{ a }});
+{% endfor %}
+    var acc = 0.0;
+{% for corner in range(pow(2, k)) %}
+    {
+      var cw = 1.0;
+{% for ridx in range(k) %}
+{% set a = resized.list[ridx] %}
+{% if ((corner / pow(2, ridx)) | int) % 2 == 1 %}
+      let ci{{ a }} = clamp(lo{{ a }} + 1, 0, {{ xs[a] - 1 }});
+      cw = cw * w{{ a }};
+{% else %}
+      let ci{{ a }} = clamp(lo{{ a }}, 0, {{ xs[a] - 1 }});
+      cw = cw * (1.0 - w{{ a }});
+{% endif %}
+{% endfor %}
+      let off = 0u{% for a in range(r) %}{% if a in resized.list %} + u32(ci{{ a }}) * {{ istride(a) }}u{% else %} + {{ out_coord(a) }} * {{ istride(a) }}u{% endif %}{% endfor %};
+      acc = acc + cw * f32(x[off]);
+    }
+{% endfor %}
+    y[i] = {{ scalar }}(acc);
+{% endif %}
+  }
+}

build/webgpu/resize-linear-2x-stencil-x8.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,81 @@

+enable f16;
+{{ env.wgsl.resourceDeclarations }}
+// Exact-2x f16 bilinear resize with two adjacent vec4 outputs per invocation.
+// Neighboring output quads overlap by two source columns, so an x8 tile needs
+// only six horizontal taps per source row instead of two independent x4
+// stencils' eight. Coordinate/parity work and thread count are also halved.
+const WG: u32 = {{ workgroupSize }}u;
+const IN_H: u32 = {{ source.xShape[2] }}u;
+const IN_W: u32 = {{ source.xShape[3] }}u;
+const IN_HW: u32 = {{ source.xShape[2] * source.xShape[3] }}u;
+const OUT_H: u32 = {{ source.yShape[2] }}u;
+const OUT_W: u32 = {{ source.yShape[3] }}u;
+const COUNT: u32 = {{ source.yShape[0] * source.yShape[1] * source.yShape[2] * source.yShape[3] }}u;
+fn input_at(base: u32, h: i32, w: i32) -> f32 {
+  let hh = u32(clamp(h, 0, i32(IN_H) - 1));
+  let ww = u32(clamp(w, 0, i32(IN_W) - 1));
+  return f32(x[base + hh * IN_W + ww]);
+}
+@compute @workgroup_size(WG, 1, 1)
+fn main(
+  @builtin(global_invocation_id) gid: vec3<u32>,
+  @builtin(num_workgroups) workgroup_count: vec3<u32>
+) {
+  let stride = workgroup_count.x * WG;
+  let groups_per_row = OUT_W / 8u;
+  let group_count = COUNT / 8u;
+  for (var group = gid.x; group < group_count; group = group + stride) {
+    let group_in_row = group % groups_per_row;
+    let row = group / groups_per_row;
+    let oh = row % OUT_H;
+    let nc = row / OUT_H;
+    let base = nc * IN_HW;
+    let qx = i32(group_in_row * 4u);
+{% if source.coordinateMode == "asymmetric" %}
+    let y0 = i32(oh / 2u);
+    let wy = select(0.0, 0.5, (oh & 1u) == 1u);
+    let a0 = input_at(base, y0, qx + 0);
+    let b0 = input_at(base, y0, qx + 1);
+    let c0 = input_at(base, y0, qx + 2);
+    let d0 = input_at(base, y0, qx + 3);
+    let e0 = input_at(base, y0, qx + 4);
+    let y1 = y0 + 1;
+    let a1 = input_at(base, y1, qx + 0);
+    let b1 = input_at(base, y1, qx + 1);
+    let c1 = input_at(base, y1, qx + 2);
+    let d1 = input_at(base, y1, qx + 3);
+    let e1 = input_at(base, y1, qx + 4);
+    let top0 = vec4<f32>(a0, 0.5 * a0 + 0.5 * b0, b0, 0.5 * b0 + 0.5 * c0);
+    let top1 = vec4<f32>(c0, 0.5 * c0 + 0.5 * d0, d0, 0.5 * d0 + 0.5 * e0);
+    let bottom0 = vec4<f32>(a1, 0.5 * a1 + 0.5 * b1, b1, 0.5 * b1 + 0.5 * c1);
+    let bottom1 = vec4<f32>(c1, 0.5 * c1 + 0.5 * d1, d1, 0.5 * d1 + 0.5 * e1);
+{% else %}
+    let y0 = i32(oh / 2u) - 1 + i32(oh & 1u);
+    let wy = select(0.75, 0.25, (oh & 1u) == 1u);
+    let a0 = input_at(base, y0, qx - 1);
+    let b0 = input_at(base, y0, qx + 0);
+    let c0 = input_at(base, y0, qx + 1);
+    let d0 = input_at(base, y0, qx + 2);
+    let e0 = input_at(base, y0, qx + 3);
+    let f0 = input_at(base, y0, qx + 4);
+    let y1 = y0 + 1;
+    let a1 = input_at(base, y1, qx - 1);
+    let b1 = input_at(base, y1, qx + 0);
+    let c1 = input_at(base, y1, qx + 1);
+    let d1 = input_at(base, y1, qx + 2);
+    let e1 = input_at(base, y1, qx + 3);
+    let f1 = input_at(base, y1, qx + 4);
+    let top0 = vec4<f32>(0.25 * a0 + 0.75 * b0, 0.75 * b0 + 0.25 * c0, 0.25 * b0 + 0.75 * c0, 0.75 * c0 + 0.25 * d0);
+    let top1 = vec4<f32>(0.25 * c0 + 0.75 * d0, 0.75 * d0 + 0.25 * e0, 0.25 * d0 + 0.75 * e0, 0.75 * e0 + 0.25 * f0);
+    let bottom0 = vec4<f32>(0.25 * a1 + 0.75 * b1, 0.75 * b1 + 0.25 * c1, 0.25 * b1 + 0.75 * c1, 0.75 * c1 + 0.25 * d1);
+    let bottom1 = vec4<f32>(0.25 * c1 + 0.75 * d1, 0.75 * d1 + 0.25 * e1, 0.25 * d1 + 0.75 * e1, 0.75 * e1 + 0.25 * f1);
+{% endif %}
+    let output0 = vec4<f32>(1.0 - wy) * top0 + vec4<f32>(wy) * bottom0;
+    let output1 = vec4<f32>(1.0 - wy) * top1 + vec4<f32>(wy) * bottom1;
+    y[group * 2u] = vec4<f16>(output0);
+    y[group * 2u + 1u] = vec4<f16>(output1);
+  }
+}

build/webgpu/resize-linear-2x-stencil.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,124 @@

+// NCHW bilinear Resize with an exact 2x upscale on both spatial axes. The
+// interpolation weights collapse to fixed per-parity stencils, replacing
+// per-element floating-point coordinate divisions with integer parity tests
+// and constants.
+//
+// For half_pixel and pytorch_half_pixel, src = o / 2 - 0.25: even outputs use
+// floor q - 1 with fraction 0.75, and odd outputs use floor q with fraction
+// 0.25. For asymmetric mode, src = o / 2: even outputs use fraction 0.0 and odd
+// outputs use 0.5. align_corners remains on the generic fallback because its
+// position-dependent scale does not reduce to fixed stencils.
+//
+// Input coordinates clamp at the edges, including the q - 1 and q + 1 border
+// taps. The f32 weight construction is bit-identical to the generic fallback.
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize if workgroupSize is defined else tunables.WORKGROUP_SIZE %}
+const WG: u32 = {{ wg }}u;
+const IN_H: u32 = {{ source.xShape[2] }}u;
+const IN_W: u32 = {{ source.xShape[3] }}u;
+const IN_HW: u32 = {{ source.xShape[2] * source.xShape[3] }}u;
+const OUT_H: u32 = {{ source.yShape[2] }}u;
+const OUT_W: u32 = {{ source.yShape[3] }}u;
+const COUNT: u32 = {{ source.yShape[0] * source.yShape[1] * source.yShape[2] * source.yShape[3] }}u;
+fn input_at(base: u32, h: i32, w: i32) -> f32 {
+  let hh = u32(clamp(h, 0, i32(IN_H) - 1));
+  let ww = u32(clamp(w, 0, i32(IN_W) - 1));
+  return f32(x[base + hh * IN_W + ww]);
+}
+@compute @workgroup_size({{ wg }})
+fn main(
+  @builtin(global_invocation_id) gid: vec3<u32>,
+  @builtin(num_workgroups) nwg: vec3<u32>
+) {
+  let stride = nwg.x * WG;
+{% if source.vec4 %}
+  // Vec4 path: one thread owns 4 contiguous output columns (OUT_W % 4 == 0, so
+  // a 4-group never crosses a row). All 4 lanes share the same oh -> same source
+  // rows (y0,y1) and the same 4-column source window (qx0-1 .. qx0+2); load that
+  // window once, compute the 4 bilinear results with the baked per-lane parity
+  // weights, and emit a single 128-bit vec4 store. Bit-identical to the scalar
+  // path (same input_at, same (1-w) split, same f32 operation order).
+  let OUT_W4 = OUT_W / 4u;
+  let COUNT4 = COUNT / 4u;
+  for (var v = gid.x; v < COUNT4; v += stride) {
+    let ow4 = v % OUT_W4;
+    let tt = v / OUT_W4;
+    let oh = tt % OUT_H;
+    let nc = tt / OUT_H;
+    let base = nc * IN_HW;
+    let ow0 = ow4 * 4u;
+    let qx0 = i32(ow0 / 2u);
+{% if source.coordinateMode == "asymmetric" %}
+    let y0 = i32(oh / 2u);
+    let wy = select(0.0, 0.5, (oh & 1u) == 1u);
+{% else %}
+    let y0 = i32(oh / 2u) - 1 + i32(oh & 1u);
+    let wy = select(0.75, 0.25, (oh & 1u) == 1u);
+{% endif %}
+    let y1 = y0 + 1;
+{% if source.coordinateMode != "asymmetric" %}
+    // The q-1 left tap is only weighted by the half-pixel stencils; the
+    // asymmetric stencils (weights 0.0/0.5) never read it.
+    let a0 = input_at(base, y0, qx0 - 1);
+    let a1 = input_at(base, y1, qx0 - 1);
+{% endif %}
+    let b0 = input_at(base, y0, qx0);
+    let c0 = input_at(base, y0, qx0 + 1);
+    let d0 = input_at(base, y0, qx0 + 2);
+    let b1 = input_at(base, y1, qx0);
+    let c1 = input_at(base, y1, qx0 + 1);
+    let d1 = input_at(base, y1, qx0 + 2);
+{% if source.coordinateMode == "asymmetric" %}
+    // lanes (ow0..ow0+3): wx 0.0,0.5,0.0,0.5 ; (v00,v01) cols (b,c),(b,c),(c,d),(c,d)
+    let o0 = (1.0 - wy) * (1.0 * b0 + 0.0 * c0) + wy * (1.0 * b1 + 0.0 * c1);
+    let o1 = (1.0 - wy) * (0.5 * b0 + 0.5 * c0) + wy * (0.5 * b1 + 0.5 * c1);
+    let o2 = (1.0 - wy) * (1.0 * c0 + 0.0 * d0) + wy * (1.0 * c1 + 0.0 * d1);
+    let o3 = (1.0 - wy) * (0.5 * c0 + 0.5 * d0) + wy * (0.5 * c1 + 0.5 * d1);
+{% else %}
+    // lanes (ow0..ow0+3): wx 0.75,0.25,0.75,0.25 ; (v00,v01) cols (a,b),(b,c),(b,c),(c,d)
+    let o0 = (1.0 - wy) * (0.25 * a0 + 0.75 * b0) + wy * (0.25 * a1 + 0.75 * b1);
+    let o1 = (1.0 - wy) * (0.75 * b0 + 0.25 * c0) + wy * (0.75 * b1 + 0.25 * c1);
+    let o2 = (1.0 - wy) * (0.25 * b0 + 0.75 * c0) + wy * (0.25 * b1 + 0.75 * c1);
+    let o3 = (1.0 - wy) * (0.75 * c0 + 0.25 * d0) + wy * (0.75 * c1 + 0.25 * d1);
+{% endif %}
+    y[v] = vec4<{{ scalar }}>(vec4<f32>(o0, o1, o2, o3));
+  }
+{% else %}
+  for (var i = gid.x; i < COUNT; i += stride) {
+    let ow = i % OUT_W;
+    let t = i / OUT_W;
+    let oh = t % OUT_H;
+    let nc = t / OUT_H;
+    let base = nc * IN_HW;
+    let qy = i32(oh / 2u);
+    let qx = i32(ow / 2u);
+    let oddY = (oh & 1u) == 1u;
+    let oddX = (ow & 1u) == 1u;
+{% if source.coordinateMode == "asymmetric" %}
+    let y0 = qy;
+    let x0 = qx;
+    let wy = select(0.0, 0.5, oddY);
+    let wx = select(0.0, 0.5, oddX);
+{% else %}
+    let y0 = qy - 1 + i32(oh & 1u);
+    let x0 = qx - 1 + i32(ow & 1u);
+    let wy = select(0.75, 0.25, oddY);
+    let wx = select(0.75, 0.25, oddX);
+{% endif %}
+    let y1 = y0 + 1;
+    let x1 = x0 + 1;
+    let v00 = input_at(base, y0, x0);
+    let v01 = input_at(base, y0, x1);
+    let v10 = input_at(base, y1, x0);
+    let v11 = input_at(base, y1, x1);
+    let result = (1.0 - wy) * ((1.0 - wx) * v00 + wx * v01) + wy * ((1.0 - wx) * v10 + wx * v11);
+    y[i] = {{ scalar }}(result);
+  }
+{% endif %}
+}

build/webgpu/resize-nearest-integer-scale.wgsl.jinja ADDED Viewed

	@@ -0,0 +1,73 @@

+// NCHW nearest-neighbor resize with compile-time integer upscale factors. The
+// source index is exactly out_coord / scale using u32 division, with no floating
+// point coordinate calculation.
+//
+// This is valid for asymmetric + floor because floor(ow / s) is u32 division.
+// It is also valid for half_pixel with either round-prefer rule: writing
+// ow = q*s + r gives an offset whose magnitude is strictly below one half, so
+// ties cannot occur and every nearest rounding rule returns q. Downsampling and
+// other coordinate-mode combinations require the generic coordinate transform.
+{% if usesF16 %}
+enable f16;
+{% endif %}
+{{ env.wgsl.resourceDeclarations }}
+{% set wg = workgroupSize if workgroupSize is defined else tunables.WORKGROUP_SIZE %}
+{%- set inH = source.xShape[2] %}
+{% set inW = source.xShape[3] %}
+{% set outH = source.yShape[2] %}
+{% set outW = source.yShape[3] %}
+{% set scaleW = ((outW / inW) | int) %}
+{% set rows = source.yShape[0] * source.yShape[1] * outH %}
+const WG: u32 = {{ wg }}u;
+const IN_W: u32 = {{ inW }}u;
+const IN_HW: u32 = {{ inH * inW }}u;
+const OUT_H: u32 = {{ outH }}u;
+const SCALE_H: u32 = {{ ((outH / inH) | int) }}u;
+{% if not source.vec4 or scaleW == 3 %}const SCALE_W: u32 = {{ scaleW }}u;
+{% endif %}
+{% if source.vec4 %}
+const OUT_W_VECS: u32 = {{ ((outW / 4) | int) }}u;
+const COUNT: u32 = {{ (((rows * outW) / 4) | int) }}u;
+{% else %}
+const OUT_W: u32 = {{ outW }}u;
+const COUNT: u32 = {{ rows * outW }}u;
+{% endif %}
+@compute @workgroup_size({{ wg }})
+fn main(
+  @builtin(global_invocation_id) gid: vec3<u32>,
+  @builtin(num_workgroups) nwg: vec3<u32>
+) {
+  let stride = nwg.x * WG;
+{% if source.vec4 %}
+  for (var v = gid.x; v < COUNT; v += stride) {
+    let ow0 = (v % OUT_W_VECS) * 4u;
+    let t = v / OUT_W_VECS;
+    let oh = t % OUT_H;
+    let nc = t / OUT_H;
+    let rowBase = nc * IN_HW + (oh / SCALE_H) * IN_W;
+{% if scaleW == 4 %}
+    y[v] = {{ vectorScalar }}(x[rowBase + ow0 / 4u]);
+{% elif scaleW == 2 %}
+    let a = x[rowBase + ow0 / 2u];
+    let b = x[rowBase + ow0 / 2u + 1u];
+    y[v] = {{ vectorScalar }}(a, a, b, b);
+{% else %}
+    y[v] = {{ vectorScalar }}(
+      x[rowBase + ow0 / SCALE_W],
+      x[rowBase + (ow0 + 1u) / SCALE_W],
+      x[rowBase + (ow0 + 2u) / SCALE_W],
+      x[rowBase + (ow0 + 3u) / SCALE_W]
+    );
+{% endif %}
+  }
+{% else %}
+  for (var i = gid.x; i < COUNT; i += stride) {
+    let ow = i % OUT_W;
+    let t = i / OUT_W;
+    let oh = t % OUT_H;
+    let nc = t / OUT_H;
+    y[i] = x[nc * IN_HW + (oh / SCALE_H) * IN_W + ow / SCALE_W];
+  }
+{% endif %}
+}

build/webgpu/test.json ADDED Viewed

The diff for this file is too large to render. See raw diff