feat(yolov5): add the YOLOv5 object-detection family (1275)

## Implementation

`checkpoint.py` stands the missing classes in while the archive is read.
Unpickling a module only restores attributes, so nothing in a stand-in runs; the
tensors, class names, strides and anchor boxes come out unchanged. Placeholders
deliberately keep failing dunder lookups, because `inspect` reads `__file__` off
every module handed to it and `torch.load` goes down that path.

The head is anchor based. Each level predicts three boxes per cell as an offset
and a scale relative to a stored anchor, and carries an objectness that
multiplies the class scores. The archive stores anchors already divided by their
level's stride, so they are scaled back to pixels in the head. Suppression stays
in the family runtime, as it does for YOLOv8 and YOLO11.

Three values cannot be read from the weights and are stated explicitly. Each one
still builds and still detects when set wrong, which is why each has a test:

| value | correct | what happens if wrong |
| --- | --- | --- |
| norm epsilon | `1e-3`, not the PyTorch default | same object found, plus a false detection at 0.26 the reference does not report |
| stem padding | `2`, not half its 6x6 kernel | one extra row and column; every box offset |
| neck residual | dropped; the backbone keeps it | shapes match either way, boxes plausible but wrong |

One graph note. The first draft logged 18 TensorRT errors per build
(`checkSanity`, skipped tactics). Bisected to a single shape: multiplying a
slice by another slice that broadcasts on the axis they were sliced on.
Flattening both sides before the multiply is the same arithmetic and builds
clean; the output is unchanged.

`yolov5n` goes in `excluded_profiles` rather than `entries`, because the release

Author: zhenshanx-nv

apps/benchmark/performance/release.yaml

@@ -43,6 +43,12 @@ excluded_profiles:
     reason: >-
       The pinned Diffusers reference for MiniMax-H3 has not yet been integrated
       into the release performance runner.
+  - model: yolov5n
+    reason: >-
+      Functional and reference-parity qualification is present, but the release
+      performance baseline runs Ultralytics, which cannot load a legacy YOLOv5
+      archive: those archives pickle classes from the standalone yolov5
+      repository, which is not a dependency here.
   - model: dpn92-mx-in1k
     reason: >-
       Functional and timm reference-parity qualification is present for every

families/yolov5/__init__.py

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

families/yolov5/checkpoint.py

@@ -0,0 +1,154 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Exact NumPy access to a YOLOv5 `.pt` checkpoint.
+
+YOLOv5 predates the `ultralytics` package: its archives pickle classes from the
+standalone yolov5 repository's `models` package, which is not a dependency
+here. Rather than take that repository on, the classes are stood in for while
+the archive is read. Nothing in a stand-in runs - unpickling a module only
+restores attributes - so the tensors, the class names and the anchor boxes come
+out unchanged, and the topology is taken from the stage table in `model.py`
+instead of from the restored objects.
+
+The stored tensors are half precision; they are widened to float32 here so the
+folding arithmetic downstream keeps its accuracy.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+# The modules a YOLOv5 archive names. Anything it reaches for inside these is
+# answered with a placeholder class.
+_PICKLED_MODULES = (
+    "models",
+    "models.yolo",
+    "models.common",
+    "models.experimental",
+    "utils",
+    "utils.general",
+)
+
+
+class _Placeholder:
+    """Stands in for a class the archive pickles that is not available here."""
+
+    def __setstate__(self, state: Any) -> None:
+        self.__dict__.update(state if isinstance(state, dict) else {})
+
+
+def _placeholder_for(attribute: str) -> type:
+    # Dunder lookups have to keep failing: `inspect` walks `__file__` on every
+    # module it is handed, and answering that with a class breaks it.
+    if attribute.startswith("__") and attribute.endswith("__"):
+        raise AttributeError(attribute)
+    return type(attribute, (_Placeholder,), {})
+
+
+def _install_placeholders() -> None:
+    for name in _PICKLED_MODULES:
+        if name in sys.modules:
+            continue
+        module = types.ModuleType(name)
+        module.__getattr__ = _placeholder_for  # type: ignore[attr-defined]
+        sys.modules[name] = module
+
+
+def _collect(node: Any, prefix: str, into: dict[str, Any]) -> None:
+    """Walk a restored module tree the way `state_dict` would."""
+    data = node.__dict__
+    for store in ("_parameters", "_buffers"):
+        for name, tensor in data.get(store, {}).items():
+            if tensor is not None:
+                into[f"{prefix}{name}"] = tensor
+    for name, child in data.get("_modules", {}).items():
+        if child is not None:
+            _collect(child, f"{prefix}{name}.", into)
+
+
+@dataclass(frozen=True)
+class Checkpoint:
+    tensors: dict[str, np.ndarray]
+    class_names: tuple[str, ...]
+    image_size: int
+    strides: tuple[int, ...]
+
+    # A YOLOv5 release ships every width in one repository, and a build request
+    # has no field naming which archive to use, so the family builds the width
+    # it is named for. Reading the other widths needs a way for a manifest to
+    # select a file, which does not exist today.
+    ARCHIVE = "yolov5n.pt"
+
+    @classmethod
+    def open(cls, model_dir: Path) -> "Checkpoint":
+        path = model_dir / cls.ARCHIVE
+        if not path.is_file():
+            raise FileNotFoundError(f"YOLOv5 model directory has no {cls.ARCHIVE}: {model_dir}")
+        return cls.from_archive(path)
+
+    @classmethod
+    def from_archive(cls, path: Path) -> "Checkpoint":
+        import torch
+
+        _install_placeholders()
+        # The archive pickles its own model class, so it cannot be read with
+        # weights_only. The manifest pins the revision it comes from.
+        blob = torch.load(str(path), map_location="cpu", weights_only=False)
+        model = blob.get("model") if isinstance(blob, dict) else None
+        if model is None:
+            raise ValueError(f"YOLOv5 archive has no model entry: {path}")
+
+        restored: dict[str, Any] = {}
+        _collect(model, "", restored)
+        tensors = {
+            key: value.detach().to(torch.float32).numpy()
+            for key, value in restored.items()
+            if not key.endswith("num_batches_tracked")
+        }
+        if not tensors:
+            raise ValueError(f"YOLOv5 archive has no weights: {path}")
+
+        names = model.__dict__.get("names")
+        if isinstance(names, dict) and names:
+            ordered = tuple(str(names[index]) for index in sorted(names))
+        elif isinstance(names, (list, tuple)) and names:
+            ordered = tuple(str(name) for name in names)
+        else:
+            raise ValueError(f"YOLOv5 archive has no class names: {path}")
+
+        stride = restored.get("stride")
+        if stride is None:
+            stride = model.__dict__.get("stride")
+        if stride is None:
+            raise ValueError(f"YOLOv5 archive records no detection strides: {path}")
+        strides = tuple(int(value) for value in stride.detach().reshape(-1).tolist())
+        if not strides or any(value <= 0 for value in strides):
+            raise ValueError(f"YOLOv5 archive has a non-positive stride: {path}")
+
+        # A YOLOv5 archive does not record the size it was trained at; every
+        # published release uses 640.
+        return cls(tensors, ordered, 640, strides)
+
+    @property
+    def names(self) -> frozenset[str]:
+        return frozenset(self.tensors)
+
+    def exists(self, name: str) -> bool:
+        return name in self.tensors
+
+    def tensor(self, name: str) -> np.ndarray:
+        value = self.tensors.get(name)
+        if value is None:
+            raise KeyError(f"YOLOv5 checkpoint tensor not found: {name}")
+        return value
+
+    def scalar(self, name: str) -> Any:
+        return self.tensor(name)

families/yolov5/graph.py

@@ -0,0 +1,208 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Small TensorRT graph vocabulary owned by YOLOv5."""
+
+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 YOLOv5 convolution")
+    layer.stride_nd = (stride, stride)
+    layer.padding_nd = (padding, padding)
+    layer.num_groups = groups
+    return layer.get_output(0)
+
+
+def silu(network, tensor):
+    """x * sigmoid(x), the activation every YOLOv5 convolution uses."""
+    gate = network.add_activation(tensor, trt.ActivationType.SIGMOID)
+    if gate is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 SiLU sigmoid")
+    product = network.add_elementwise(tensor, gate.get_output(0), trt.ElementWiseOperation.PROD)
+    if product is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 SiLU product")
+    return product.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 YOLOv5 add")
+    return layer.get_output(0)
+
+
+def concatenate(network, tensors, *, axis: int = 1):
+    layer = network.add_concatenation(tensors)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 concatenation")
+    layer.axis = axis
+    return layer.get_output(0)
+
+
+def slice_axis(network, tensor, *, axis: int, start: int, count: int):
+    shape = [int(value) for value in tensor.shape]
+    starts, sizes = [0] * len(shape), list(shape)
+    starts[axis], sizes[axis] = 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 YOLOv5 slice")
+    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 a YOLOv5 max pool")
+    layer.stride_nd = (stride, stride)
+    layer.padding_nd = (padding, padding)
+    return layer.get_output(0)
+
+
+def nearest_upsample(network, tensor, factor: int):
+    layer = network.add_resize(tensor)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 upsample")
+    layer.resize_mode = trt.InterpolationMode.NEAREST
+    layer.scales = [1.0, 1.0, float(factor), float(factor)]
+    return layer.get_output(0)
+
+
+def reshape(network, tensor, shape: tuple[int, ...]):
+    layer = network.add_shuffle(tensor)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 reshape")
+    layer.reshape_dims = trt.Dims(shape)
+    return layer.get_output(0)
+
+
+def permute(network, tensor, permutation: tuple[int, ...]):
+    layer = network.add_shuffle(tensor)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 permutation")
+    layer.second_transpose = trt.Permutation(permutation)
+    return layer.get_output(0)
+
+
+def matmul(network, left, right, *, transpose_left=False, transpose_right=False):
+    layer = network.add_matrix_multiply(
+        left,
+        trt.MatrixOperation.TRANSPOSE if transpose_left else trt.MatrixOperation.NONE,
+        right,
+        trt.MatrixOperation.TRANSPOSE if transpose_right else trt.MatrixOperation.NONE,
+    )
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 matmul")
+    return layer.get_output(0)
+
+
+def softmax(network, tensor, axis: int):
+    layer = network.add_softmax(tensor)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 softmax")
+    layer.axes = 1 << axis
+    return layer.get_output(0)
+
+
+def sigmoid(network, tensor):
+    layer = network.add_activation(tensor, trt.ActivationType.SIGMOID)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 sigmoid")
+    return layer.get_output(0)
+
+
+def scale(network, tensor, factor: float, *, dtype: np.dtype):
+    shape = (1,) * len(tuple(tensor.shape))
+    layer = network.add_constant(shape, trt.Weights(np.array([factor], dtype=dtype).reshape(shape)))
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 scale constant")
+    values = layer.get_output(0)
+    if values.dtype != tensor.dtype:
+        cast = network.add_cast(values, tensor.dtype)
+        if cast is None:
+            raise RuntimeError("TensorRT rejected a YOLOv5 scale cast")
+        values = cast.get_output(0)
+    product = network.add_elementwise(tensor, values, trt.ElementWiseOperation.PROD)
+    if product is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 scale product")
+    return product.get_output(0)
+
+
+def constant(network, values: np.ndarray, *, dtype: np.dtype, like=None):
+    layer = network.add_constant(
+        values.shape, trt.Weights(np.ascontiguousarray(values, dtype=dtype))
+    )
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 constant")
+    output = layer.get_output(0)
+    if like is None or output.dtype == like.dtype:
+        return output
+    cast = network.add_cast(output, like.dtype)
+    if cast is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 constant cast")
+    return cast.get_output(0)
+
+
+def subtract(network, left, right):
+    layer = network.add_elementwise(left, right, trt.ElementWiseOperation.SUB)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 subtraction")
+    return layer.get_output(0)
+
+
+def reduce_max(network, tensor, axis: int, *, keep_dims: bool):
+    layer = network.add_reduce(tensor, trt.ReduceOperation.MAX, 1 << axis, keep_dims)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 max reduction")
+    return layer.get_output(0)
+
+
+def top_k(network, tensor, *, k: int, axis: int):
+    """Largest `k` values along one axis, with their indices."""
+    layer = network.add_topk(tensor, trt.TopKOperation.MAX, k, 1 << axis)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 top-k")
+    return layer.get_output(0), layer.get_output(1)
+
+
+def gather(network, tensor, indices, *, axis: int):
+    layer = network.add_gather(tensor, indices, axis)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 gather")
+    return layer.get_output(0)
+
+
+def multiply(network, left, right):
+    """Element-wise product; TensorRT broadcasts size-one axes."""
+    layer = network.add_elementwise(left, right, trt.ElementWiseOperation.PROD)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 product")
+    return layer.get_output(0)
+
+
+def floor_divide(network, left, right):
+    layer = network.add_elementwise(left, right, trt.ElementWiseOperation.FLOOR_DIV)
+    if layer is None:
+        raise RuntimeError("TensorRT rejected a YOLOv5 floor division")
+    return layer.get_output(0)