feat(timm_res2net): add timm Res2Net image-classification family (1231)

## Implementation

Adds `families/timm_res2net/`. Res2Net replaces the single 3x3 of a ResNet
bottleneck with a chain of narrower 3x3 convolutions. The 1x1 output is split
into `scale` equal chunks; each chunk after the first is added to the running
result before its own convolution, and the last chunk bypasses the chain. The
chunks are concatenated before the final 1x1, so one block sees several
receptive field sizes at once. At the head of a stage every rung starts from its
own chunk, because the spatial size has just changed.

The layout is recovered from the checkpoint rather than tabulated:

| Property | Recovered from |
| --- | --- |
| Stage depths | the `layer<stage>.<block>` keys |
| Scale | how many `convs` entries a block has, plus one for the chunk that skips |
| Chunk width and groups | those convolutions' own weight shapes |
| Stem shape | whether `conv1` is one tensor or a sequence |
| Shortcut form | whether `downsample` starts at index 0 or 1 |

### fp32 builds now switch off TF32

TensorRT runs fp32 convolutions in TF32 by default, keeping ten mantissa bits
instead of twenty-four. Measured against timm across all nine checkpoints, that
costs roughly three orders of magnitude of accuracy, and on
`res2net50_26w_8s` it changes the predicted class:

| Checkpoint | TF32 on | TF32 off |
| --- | --- | --- |
| res2net50_26w_8s | corr 0.99931, top-1 **446 vs 490** | corr 1.00000000, top-1 match |

Author: zhenshanx-nv

apps/benchmark/performance/release.yaml

@@ -48,6 +48,13 @@ excluded_profiles:
       Functional and timm reference-parity qualification is present for every
       published DPN width, but the release-performance workload and receipt
       were collected only for dpn68b.
+  - model: res2net50d-in1k
+    reason: &res2net_performance_exclusion >-
+      Functional and timm reference-parity qualification is present for every
+      published Res2Net checkpoint, but the release-performance workload and
+      receipt were collected only for res2net50_26w_4s.
+  - model: res2next50-in1k
+    reason: *res2net_performance_exclusion
 
 entries:
   - id: albert.encode
@@ -1157,6 +1164,19 @@ entries:
       reference_backend: hf_transformers
       timing_scope: task-model-call-wall
       input_preparation_included: false
+  - id: timm_res2net.classify
+    family: timm_res2net
+    operation: classify
+    model: res2net50-26w-4s-in1k
+    workload:
+      testcase: res2net50-26w-4s-in1k
+    baseline:
+      runner: task-reference
+      adapter: hf-transformers-vision
+      mode: hf-eager
+      reference_backend: hf_transformers
+      timing_scope: task-model-call-wall
+      input_preparation_included: false
   - id: timm_repvgg.classify
     family: timm_repvgg
     operation: classify

families/timm_res2net/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""timm Res2Net image-classification family."""

families/timm_res2net/checkpoint.py

@@ -0,0 +1,62 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Exact NumPy safetensors access for timm Res2Net checkpoints."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath
+from typing import Any
+
+import numpy as np
+from safetensors import safe_open
+
+
+@dataclass(frozen=True)
+class Checkpoint:
+    readers: tuple[Any, ...]
+    tensor_map: dict[str, Any]
+
+    @classmethod
+    def open(cls, model_dir: Path) -> "Checkpoint":
+        single = model_dir / "model.safetensors"
+        if single.is_file():
+            reader = safe_open(str(single), framework="numpy")
+            return cls((reader,), {str(name): reader for name in reader.keys()})
+
+        index_path = model_dir / "model.safetensors.index.json"
+        if not index_path.is_file():
+            raise FileNotFoundError(f"Res2Net checkpoint has no model safetensors: {model_dir}")
+        payload = json.loads(index_path.read_text(encoding="utf-8"))
+        weight_map = payload.get("weight_map") if isinstance(payload, dict) else None
+        if not isinstance(weight_map, dict) or not weight_map:
+            raise ValueError("Res2Net safetensors index has no weight_map")
+        if not all(
+            isinstance(name, str) and name and isinstance(shard, str) and shard
+            for name, shard in weight_map.items()
+        ):
+            raise ValueError("Res2Net safetensors index contains invalid entries")
+        shard_names = sorted(set(weight_map.values()))
+        for name in shard_names:
+            path = PurePosixPath(name)
+            if path.is_absolute() or len(path.parts) != 1 or path.name != name:
+                raise ValueError("Res2Net safetensors shard names must be direct relative files")
+        readers = {
+            name: safe_open(str(model_dir / name), framework="numpy") for name in shard_names
+        }
+        return cls(
+            tuple(readers[name] for name in shard_names),
+            {str(tensor): readers[str(shard)] for tensor, shard in weight_map.items()},
+        )
+
+    @property
+    def names(self) -> frozenset[str]:
+        return frozenset(self.tensor_map)
+
+    def tensor(self, name: str) -> np.ndarray:
+        reader = self.tensor_map.get(name)
+        if reader is None:
+            raise KeyError(f"Res2Net checkpoint tensor not found: {name}")
+        return np.asarray(reader.get_tensor(name), dtype=np.float32)

families/timm_res2net/graph.py

@@ -0,0 +1,140 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Small TensorRT graph vocabulary owned by timm Res2Net."""
+
+from __future__ import annotations
+
+import numpy as np
+import tensorrt as trt
+
+
+def convolution(
+    network,
+    tensor,
+    weight: np.ndarray,
+    bias: np.ndarray,
+    *,
+    stride: int = 1,
+    padding: int = 0,
+    groups: int = 1,
+    dtype: np.dtype,
+):
+    layer = network.add_convolution_nd(
+        tensor,
+        num_output_maps=int(weight.shape[0]),
+        kernel_shape=(int(weight.shape[2]), int(weight.shape[3])),
+        kernel=trt.Weights(np.ascontiguousarray(weight, dtype=dtype)),
+        bias=trt.Weights(np.ascontiguousarray(bias, dtype=dtype)),
+    )
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a Res2Net convolution")
+    layer.stride_nd = (stride, stride)
+    layer.padding_nd = (padding, padding)
+    layer.num_groups = groups
+    return layer.get_output(0)
+
+
+def relu(network, tensor):
+    layer = network.add_activation(tensor, trt.ActivationType.RELU)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a Res2Net ReLU")
+    return layer.get_output(0)
+
+
+def add(network, left, right):
+    layer = network.add_elementwise(left, right, trt.ElementWiseOperation.SUM)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a Res2Net residual add")
+    return layer.get_output(0)
+
+
+def max_pool(network, tensor, *, kernel: int, stride: int, padding: int):
+    layer = network.add_pooling_nd(tensor, trt.PoolingType.MAX, (kernel, kernel))
+    if layer is None:
+        raise RuntimeError("TensorRT rejected the Res2Net stem pooling")
+    layer.stride_nd = (stride, stride)
+    layer.padding_nd = (padding, padding)
+    return layer.get_output(0)
+
+
+def global_average_pool(network, tensor, height: int, width: int):
+    layer = network.add_pooling_nd(tensor, trt.PoolingType.AVERAGE, (height, width))
+    if layer is None:
+        raise RuntimeError("TensorRT rejected Res2Net global average pooling")
+    layer.stride_nd = (1, 1)
+    return layer.get_output(0)
+
+
+def classifier(
+    network,
+    tensor,
+    weight: np.ndarray,
+    bias: np.ndarray,
+    *,
+    dtype: np.dtype,
+):
+    flattened = network.add_shuffle(tensor)
+    if flattened is None:
+        raise RuntimeError("TensorRT rejected the Res2Net classifier reshape")
+    flattened.reshape_dims = (1, int(weight.shape[1]))
+    matrix = np.ascontiguousarray(weight.T, dtype=dtype)
+    matrix_layer = network.add_constant(matrix.shape, trt.Weights(matrix))
+    if matrix_layer is None:
+        raise RuntimeError("TensorRT rejected the Res2Net classifier weights")
+    product = network.add_matrix_multiply(
+        flattened.get_output(0),
+        trt.MatrixOperation.NONE,
+        matrix_layer.get_output(0),
+        trt.MatrixOperation.NONE,
+    )
+    if product is None:
+        raise RuntimeError("TensorRT rejected the Res2Net classifier matmul")
+    values = np.ascontiguousarray(bias.reshape(1, -1), dtype=dtype)
+    bias_layer = network.add_constant(values.shape, trt.Weights(values))
+    if bias_layer is None:
+        raise RuntimeError("TensorRT rejected the Res2Net classifier bias")
+    output = network.add_elementwise(
+        product.get_output(0),
+        bias_layer.get_output(0),
+        trt.ElementWiseOperation.SUM,
+    )
+    if output is None:
+        raise RuntimeError("TensorRT rejected the Res2Net classifier output")
+    return output.get_output(0)
+
+
+def average_pool(
+    network, tensor, *, kernel: int, stride: int, padding: int, count_include_pad: bool
+):
+    """Average pooling.
+
+    TensorRT excludes padded cells from the divisor by default and PyTorch
+    includes them, so the caller states which convention the checkpoint was
+    trained with rather than inheriting either default.
+    """
+    layer = network.add_pooling_nd(tensor, trt.PoolingType.AVERAGE, (kernel, kernel))
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a Res2Net average pooling")
+    layer.stride_nd = (stride, stride)
+    layer.padding_nd = (padding, padding)
+    layer.average_count_excludes_padding = not count_include_pad
+    return layer.get_output(0)
+
+
+def channel_slice(network, tensor, start: int, count: int):
+    shape = [int(value) for value in tensor.shape]
+    starts, sizes = [0] * len(shape), list(shape)
+    starts[1], sizes[1] = start, count
+    layer = network.add_slice(tensor, trt.Dims(starts), trt.Dims(sizes), trt.Dims([1] * len(shape)))
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a Res2Net channel slice")
+    return layer.get_output(0)
+
+
+def concatenate(network, tensors):
+    layer = network.add_concatenation(list(tensors))
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a Res2Net concatenation")
+    layer.axis = 1
+    return layer.get_output(0)