Add rtmdet model files

README.md

@@ -0,0 +1,182 @@
+---
+license: apache-2.0
+tags:
+- vision
+- image-detection
+datasets:
+- COCO
+---
+
+<div align="center">
+
+# RTMDet for TI EdgeAI
+
+### Real-Time Object Detector with a CSPNeXt Backbone
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
+[![Framework](https://img.shields.io/badge/Framework-ONNX-orange?style=for-the-badge)](https://onnx.ai/)
+[![Task](https://img.shields.io/badge/Task-Object%20Detection-green?style=for-the-badge)](https://github.com/TexasInstruments/edgeai)
+[![Dataset](https://img.shields.io/badge/Dataset-COCO-blueviolet?style=for-the-badge)](https://cocodataset.org/)
+
+</div>
+
+---
+
+## Overview
+
+**RTMDet** is a high-performance real-time object detector from OpenMMLab with a CSPNeXt backbone and an efficient anchor-free detection head. It achieves excellent accuracy-speed trade-offs across five model sizes (tiny, s, m, l, x), making it suitable for a wide range of deployment scenarios from resource-constrained edge devices to high-throughput server deployments.
+
+This RTMDet model is optimized for **Texas Instruments MPU (Microprocessor Unit) devices**, enabling high-performance computer vision applications at the edge. Whether you're building industrial automation systems, smart cameras, robotics, or IoT vision solutions, this model provides production-ready object detection with minimal setup.
+
+---
+
+## Model Variants
+
+| Model | Input Size | mAP[.5:.95]% | Validated Devices | Config |
+|-------|-----------|--------------|--------------------|--------|
+| `rtmdet_tiny` | 640x640 | 40.9 | TDA4VH | [rtmdet_tiny_config.yaml](rtmdet_tiny_config.yaml) |
+| `rtmdet_s` | 640x640 | 44.5 | TDA4VH | [rtmdet_s_config.yaml](rtmdet_s_config.yaml) |
+| `rtmdet_m` | 640x640 | 49.3 | TDA4VH | [rtmdet_m_config.yaml](rtmdet_m_config.yaml) |
+| `rtmdet_l` | 640x640 | 51.4 | TDA4VH | [rtmdet_l_config.yaml](rtmdet_l_config.yaml) |
+| `rtmdet_x` | 640x640 | 52.8 | TDA4VH | [rtmdet_x_config.yaml](rtmdet_x_config.yaml) |
+
+**Recommended for edge deployment:** `rtmdet_tiny` (smallest, best accuracy/compute trade-off)
+
+---
+
+## Quick Start
+
+### Prerequisites
+
+```bash
+pip install onnx>=1.22.0
+pip install onnxruntime>=1.23.2
+pip install onnxsim  # For model simplification
+```
+
+### Export the Model
+
+```bash
+# Export all variants (default)
+python prepare_model.py
+
+# Export specific variants
+python prepare_model.py --models tiny
+python prepare_model.py --models tiny s m
+
+# Export without ONNX simplification
+python prepare_model.py --models tiny --no-simplify
+
+# Force regeneration of .link files
+python prepare_model.py --generate-links
+```
+
+The script automatically:
+- Installs `mmcv-lite` and `mmdet` (and other required dependencies)
+- Downloads the PyTorch checkpoint referenced by each variant's `.onnx.link` file from OpenMMLab
+- Downloads the matching mmdetection config files (pinned to tag `v3.3.0`)
+- Builds the model with `mmdet.apis.init_detector` and wraps it to emit decoded `boxes` (xyxy) and per-class sigmoid `scores` (NMS is left for on-device post-processing)
+- Exports to ONNX (opset 13), fixes the batch dimension to 1, and re-runs shape inference
+- Optionally simplifies the model using `onnx-simplifier`
+
+### Compile and Infer uing edgeai-tidlrunner
+
+> **Note:** Run the commands below from inside the `tidlrunner` directory (the cloned [edgeai-tidlrunner](https://github.com/TexasInstruments/edgeai-tidlrunner) repository), with `--config_path` pointing to this model's config file.
+
+**Compile using edgeai-tidlrunner - on PC**
+
+```bash
+cd /path/to/edgeai-tidlrunner
+tidlrunner-cli compile --target_device J784S4 \
+  --config_path /path/to/rtmdet_tiny_config.yaml
+```
+
+**Run Inference Benchmark - on device**
+
+```bash
+cd /path/to/edgeai-tidlrunner
+tidlrunner-cli infer --target_device J784S4 \
+  --config_path /path/to/rtmdet_tiny_config.yaml
+```
+
+### Compile and Infer using edgeai-tidl-tools (Advanced):
+
+Follow the instructions at https://github.com/TexasInstruments/edgeai-tidl-tools
+
+### Deploy using edgeai-tidl-tools:
+
+Deplyment can be done using **[edgeai-tidl-tools](https://github.com/TexasInstruments/edgeai-tidl-tools)**. For ONNX models, onnxruntime-tidl with TIDL acceleration can be used. Consult the documentation of edgeai-tidl-tools for more details.
+
+---
+
+## Citation
+
+If you use RTMDet in your research, please cite:
+
+```bibtex
+@article{lyu2022rtmdet,
+  title={RTMDet: An Empirical Study of Designing Real-Time Object Detectors},
+  author={Lyu, Chengqi and Zhang, Wenwei and Huang, Haian and Zhou, Yue and Wang, Yudong and Liu, Yanyi and Zhang, Shilong and Chen, Kai},
+  journal={arXiv preprint arXiv:2212.07784},
+  year={2022}
+}
+```
+
+---
+
+## 🔗 Resources
+
+| Resource | Link |
+|----------|------|
+| **Paper** | [arXiv:2212.07784](https://arxiv.org/abs/2212.07784) |
+| **Source Code** | [open-mmlab/mmdetection (rtmdet configs)](https://github.com/open-mmlab/mmdetection/tree/main/configs/rtmdet) |
+| **edgeai-tidl-tools** | [GitHub](https://github.com/TexasInstruments/edgeai-tidl-tools) |
+| **edgeai-tidlrunner** | [GitHub](https://github.com/TexasInstruments/edgeai-tidlrunner) |
+| **EdgeAI SDK** | [Documentation](https://github.com/TexasInstruments/edgeai/blob/main/edgeai-mpu/readme_sdk.md) |
+| **EdgeAI Ecosystem** | [GitHub](https://github.com/TexasInstruments/edgeai) |
+
+---
+
+## Related Models
+
+<table>
+<tr>
+<td align="center">
+
+**YOLOX**
+Anchor-free CNN detector
+Similar single-stage design
+
+</td>
+<td align="center">
+
+**YOLOv8**
+CNN-based real-time detector
+Comparable accuracy/speed range
+
+</td>
+<td align="center">
+
+**YOLO11**
+Latest Ultralytics YOLO
+Improved efficiency
+
+</td>
+<td align="center">
+
+**RT-DETRv2**
+Real-time transformer detector
+NMS-free alternative
+
+</td>
+</tr>
+</table>
+
+---
+
+<div align="center">
+
+**Maintained by:** Texas Instruments EdgeAI Team  
+**Last Updated:** August 2026
+
+</div>

prepare_model.py

@@ -0,0 +1,722 @@
+#!/usr/bin/env python3
+"""
+Script to download RTMDet models (from .link files) and convert them to ONNX.
+Also capable of generating .link files for multiple variants.
+Includes ONNX shape inference, simplification, and batch size fixing (like YOLOX script).
+"""
+
+import os
+import sys
+import subprocess
+import re
+import importlib
+
+
+def pip_install(packages: list[str], label: str = "") -> None:
+    """
+    Run pip install for the given list of package specs.
+    Prints captured output only on failure so the user can diagnose.
+
+    Args:
+        packages : List of pip install specs (e.g. ['mmcv-lite<2.2.0', 'torch']).
+        label    : Human-readable description for log messages.
+    """
+    tag = f"[{label}]" if label else "[DEP]"
+    print(f"{tag} Installing: {', '.join(packages)} …")
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", *packages],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    if result.returncode != 0:
+        print(f"{tag} ERROR: pip install failed (exit code {result.returncode}).")
+        print(f"{tag} --- pip output ---")
+        print(result.stdout)
+        print(f"{tag} --- end pip output ---")
+        sys.exit(1)
+    print(f"{tag} Done.\n")
+
+
+def ensure_mmcv() -> None:
+    """
+    Ensure mmcv-lite<2.2.0 is installed.
+    mmdet requires mmcv>=2.0.0rc4,<2.2.0. We use mmcv-lite (pure-Python wheel,
+    no C++ compilation) which satisfies this requirement.
+
+    If an incompatible version (>=2.2.0) is already installed, it is removed first.
+    This must be called BEFORE mmdet is installed so mmdet doesn't pull in 2.2.0.
+    """
+    try:
+        import mmcv
+        version = mmcv.__version__
+        major, minor = map(int, version.split('.')[:2])
+        if major > 2 or (major == 2 and minor >= 2):
+            print(f"[DEP] mmcv {version} is incompatible (need <2.2.0) – removing …")
+            subprocess.run(
+                [sys.executable, "-m", "pip", "uninstall", "-y", "mmcv", "mmcv-lite", "mmcv-full"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+            raise ImportError  # fall through to install
+        print(f"[DEP]  ✔  mmcv {version} is compatible.")
+    except ImportError:
+        pip_install(["mmcv-lite<2.2.0"], label="DEP")
+
+
+def check_dependencies(packages: dict[str, str]) -> None:
+    """
+    Check that every package in *packages* can be imported.
+    Any package that is missing is installed automatically via pip.
+
+    Args:
+        packages : Mapping of { import_name: pip_install_name }.
+    """
+    missing: list[str] = []
+
+    for import_name, pip_name in packages.items():
+        try:
+            importlib.import_module(import_name)
+            print(f"[DEP]  ✔  {import_name} is already installed.")
+        except ImportError:
+            print(f"[DEP]  ✘  {import_name} not found – will install '{pip_name}'.")
+            missing.append(pip_name)
+
+    if not missing:
+        print("[DEP] All dependencies satisfied.\n")
+        return
+
+    pip_install(missing)
+
+
+def download_file(url: str, save_path: str, label: str = "file") -> bool:
+    """
+    Download a single file from *url* to *save_path*.
+
+    Returns True on success, False on failure (does NOT call sys.exit so the
+    caller can decide whether to fall back to an alternative).
+
+    Args:
+        url       : HTTP/HTTPS URL of the file to download.
+        save_path : Destination path (directories are created automatically).
+        label     : Human-readable name used in log messages.
+    """
+    # Create the destination directory if it does not already exist
+    os.makedirs(os.path.dirname(save_path) or ".", exist_ok=True)
+
+    # Skip download if the file already exists
+    if os.path.exists(save_path):
+        print(f"[INFO] {label} already exists at: {save_path}")
+        return True
+
+    print(f"[INFO] Downloading {label} …")
+    print(f"       URL  : {url}")
+    print(f"       Dest : {save_path}")
+    print()
+
+    try:
+        import requests
+        from tqdm import tqdm
+        resp = requests.get(url, stream=True)
+        resp.raise_for_status()
+        total = int(resp.headers.get('content-length', 0))
+        with open(save_path, 'wb') as file, tqdm(
+            desc=save_path,
+            total=total,
+            unit='iB',
+            unit_scale=True,
+            unit_divisor=1024,
+        ) as bar:
+            for data in resp.iter_content(chunk_size=1024):
+                size = len(data)
+                file.write(data)
+                bar.update(size)
+        print(f"[SUCCESS] {label} saved to: {save_path}\n")
+        return True
+    except Exception as exc:
+        # Remove any partial file so it is not mistaken for a complete download
+        if os.path.exists(save_path):
+            os.remove(save_path)
+        print(f"\n[WARN] Could not download {label}: {exc}")
+        return False
+
+
+# mmdetection GitHub tag from which configs are downloaded
+_MMDET_TAG = "v3.3.0"
+_GITHUB_BASE = f"https://raw.githubusercontent.com/open-mmlab/mmdetection/{_MMDET_TAG}/configs"
+
+# All config files required to load any RTMDet variant, with their relative
+# paths inside a local "configs/" directory mirroring the GitHub layout.
+_CONFIG_FILES = {
+    "rtmdet/rtmdet_l_8xb32-300e_coco.py":    f"{_GITHUB_BASE}/rtmdet/rtmdet_l_8xb32-300e_coco.py",
+    "rtmdet/rtmdet_m_8xb32-300e_coco.py":    f"{_GITHUB_BASE}/rtmdet/rtmdet_m_8xb32-300e_coco.py",
+    "rtmdet/rtmdet_s_8xb32-300e_coco.py":    f"{_GITHUB_BASE}/rtmdet/rtmdet_s_8xb32-300e_coco.py",
+    "rtmdet/rtmdet_tiny_8xb32-300e_coco.py": f"{_GITHUB_BASE}/rtmdet/rtmdet_tiny_8xb32-300e_coco.py",
+    "rtmdet/rtmdet_x_8xb32-300e_coco.py":    f"{_GITHUB_BASE}/rtmdet/rtmdet_x_8xb32-300e_coco.py",
+    "rtmdet/rtmdet_tta.py":                   f"{_GITHUB_BASE}/rtmdet/rtmdet_tta.py",
+    "_base_/default_runtime.py":              f"{_GITHUB_BASE}/_base_/default_runtime.py",
+    "_base_/schedules/schedule_1x.py":        f"{_GITHUB_BASE}/_base_/schedules/schedule_1x.py",
+    "_base_/datasets/coco_detection.py":      f"{_GITHUB_BASE}/_base_/datasets/coco_detection.py",
+}
+
+# Config path (relative to configs/) for each variant
+_VARIANT_CONFIG = {
+    "tiny": "rtmdet/rtmdet_tiny_8xb32-300e_coco.py",
+    "s":    "rtmdet/rtmdet_s_8xb32-300e_coco.py",
+    "m":    "rtmdet/rtmdet_m_8xb32-300e_coco.py",
+    "l":    "rtmdet/rtmdet_l_8xb32-300e_coco.py",
+    "x":    "rtmdet/rtmdet_x_8xb32-300e_coco.py",
+}
+
+CONFIGS_DIR = "configs"
+
+
+def setup_configs() -> None:
+    """
+    Download all mmdetection config files needed to load RTMDet variants.
+
+    Files are stored under ./configs/ mirroring the GitHub layout so that
+    _base_ relative-path references resolve correctly:
+        configs/
+          _base_/
+            default_runtime.py
+            schedules/schedule_1x.py
+            datasets/coco_detection.py
+          rtmdet/
+            rtmdet_l_8xb32-300e_coco.py   ← _base_ = ../_base_/...
+            rtmdet_s_8xb32-300e_coco.py   ← _base_ = ./rtmdet_l...
+            rtmdet_m_8xb32-300e_coco.py
+            rtmdet_tiny_8xb32-300e_coco.py
+            rtmdet_tta.py
+    """
+    print("[CONFIG] Downloading mmdetection config files …")
+    for rel_path, url in _CONFIG_FILES.items():
+        dest = os.path.join(CONFIGS_DIR, rel_path)
+        download_file(url, dest, label=rel_path)
+    print("[CONFIG] All config files ready.\n")
+
+
+def get_config_path(variant: str) -> str:
+    """Return the local filesystem path to the config file for *variant*."""
+    rel = _VARIANT_CONFIG[variant]
+    return os.path.join(CONFIGS_DIR, rel)
+
+
+def get_input_shape_from_config(config_path: str) -> tuple[int, int]:
+    """
+    Extract input shape from config file.
+    Looks for img_scale or similar parameters.
+    Returns (height, width) to match PyTorch NCHW convention.
+    Defaults to (640, 640) if not found.
+    """
+    try:
+        with open(config_path, 'r') as f:
+            content = f.read()
+
+        # Look for common patterns - most configs specify (width, height)
+        patterns = [
+            r'img_scale\s*=\s*\((\d+),\s*(\d+)\)',
+            r'width\s*=\s*(\d+).*?height\s*=\s*(\d+)',
+            r'input_size\s*=\s*\((\d+),\s*(\d+)\)',
+            r'img_scale\s*=\s*\[(\d+),\s*(\d+)\]',
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, content)
+            if match:
+                first, second = map(int, match.groups())
+                # Most configs use (width, height), convert to (height, width) for PyTorch
+                return (second, first)
+    except Exception as e:
+        print(f"Warning: Could not read config file {config_path}: {e}")
+
+    # Default input shape for RTMDet (height, width)
+    return (640, 640)
+
+
+def fix_onnx_batch_size(onnx_path: str, batch_size: int = 1) -> None:
+    """
+    Post-process an ONNX model to hard-code the batch dimension to *batch_size*.
+
+    Some exporters (including torch.onnx.export) may leave the first dimension
+    of inputs/outputs as a symbolic string (e.g. 'batch') even when
+    dynamic_axes is not specified.  This function:
+
+      1. Loads the ONNX protobuf from *onnx_path*.
+      2. Iterates over every input and output in the graph.
+      3. Replaces the first dimension with the integer *batch_size*.
+      4. Re-runs ONNX shape inference so downstream tools see correct shapes.
+      5. Overwrites *onnx_path* with the fixed model.
+
+    Args:
+        onnx_path  : Path to the ONNX file to fix (modified in-place).
+        batch_size : Integer value to set for the batch dimension (default 1).
+    """
+    import onnx                          # noqa: PLC0415
+    import onnx.shape_inference          # noqa: PLC0415
+
+    print(f"[POST] Fixing batch dimension to {batch_size} in: {onnx_path}")
+
+    # Load the model from disk
+    model_proto = onnx.load(onnx_path)
+    graph = model_proto.graph
+
+    # ── Fix inputs ─────────────────���───────────────────────────────────────
+    for tensor in graph.input:
+        shape = tensor.type.tensor_type.shape
+        if shape.dim:
+            dim = shape.dim[0]
+            # Clear any symbolic name (e.g. "batch") and set the integer value
+            dim.ClearField("dim_param")
+            dim.dim_value = batch_size
+
+    # ── Fix outputs ────────────────────────────────────────────────────────
+    for tensor in graph.output:
+        shape = tensor.type.tensor_type.shape
+        if shape.dim:
+            dim = shape.dim[0]
+            dim.ClearField("dim_param")
+            dim.dim_value = batch_size
+
+    # Re-run shape inference so the rest of the graph reflects the fixed shape
+    model_proto = onnx.shape_inference.infer_shapes(model_proto)
+
+    # Overwrite the original file with the fixed model
+    onnx.save(model_proto, onnx_path)
+    print(f"[POST] Batch dimension fixed → shape now starts with {batch_size}.\n")
+
+
+def _stub_mmcv_ext() -> None:
+    """
+    Stub out mmcv._ext so mmdet can be imported when only mmcv-lite is installed.
+
+    mmcv-lite is the pure-Python variant of mmcv and does not ship the compiled
+    C++ extension (_ext).  mmdet's import chain pulls in mmcv.ops, which eagerly
+    loads _ext even though the ops themselves are not needed for a forward-pass /
+    ONNX export.  Installing the full mmcv requires nvcc, which may not be
+    present.
+
+    The stub raises a clear RuntimeError only if one of the missing ops is
+    *actually called* at runtime, so normal ONNX tracing is unaffected.
+    """
+    import sys, types
+
+    if 'mmcv._ext' in sys.modules:
+        return  # already present (real or stubbed)
+
+    import importlib.machinery
+
+    def _make_stub_op(name):
+        def _op(*a, **kw):
+            raise RuntimeError(
+                f"mmcv._ext.{name} was called but mmcv-lite is installed "
+                "(no C++ extensions). Install full mmcv if this op is required."
+            )
+        _op.__name__ = name
+        return _op
+
+    # Build the stub module with a valid (non-None) __spec__ so that
+    # pkgutil.find_loader('mmcv._ext') succeeds and returns None (loader=None),
+    # causing mmengine.mmcv_full_available() to correctly return False.
+    stub = types.ModuleType('mmcv._ext')
+    stub.__file__ = '<mmcv._ext stub>'
+    stub.__package__ = 'mmcv'
+    stub.__path__ = []
+    stub.__loader__ = None
+    stub.__spec__ = importlib.machinery.ModuleSpec(
+        'mmcv._ext', loader=None, origin='<mmcv._ext stub>'
+    )
+
+    stub.__class__ = type(
+        '_StubExtModule',
+        (types.ModuleType,),
+        {'__getattr__': lambda self, name: _make_stub_op(name)},
+    )
+    sys.modules['mmcv._ext'] = stub
+
+
+def convert_to_onnx(pth_path: str, config_path: str, onnx_path: str, input_shape: tuple[int, int] = (640, 640), simplify: bool = False) -> bool:
+    """
+    Convert PyTorch model to ONNX using MMDetection tools.
+    Includes shape inference, batch size fixing, and optional simplification.
+
+    Args:
+        input_shape: (height, width) tuple for input dimensions
+    """
+    # Stub mmcv._ext before importing mmdet so the import chain succeeds
+    # even when only mmcv-lite (no compiled C++ extensions) is installed.
+    _stub_mmcv_ext()
+
+    try:
+        from mmdet.apis import init_detector
+        import torch
+    except ImportError as e:
+        print(f"Error importing MMDetection: {e}")
+        print("Please ensure mmdet and mmcv are installed.")
+        return False
+
+    # PyTorch >=2.6 defaults torch.load to weights_only=True, which blocks
+    # several legacy objects (HistoryBuffer, numpy arrays) embedded in mmengine
+    # checkpoints. We patch torch.load to use weights_only=False for the
+    # duration of init_detector. The checkpoint is from a trusted source
+    # (download.openmmlab.com), so this is safe.
+    import warnings
+    import io
+    import contextlib
+
+    _orig_torch_load = torch.load
+    torch.load = lambda *a, **kw: _orig_torch_load(*a, **{**kw, 'weights_only': False})
+
+    # Suppress two known harmless messages from init_detector:
+    #  1. FutureWarning: torch.cuda.amp.autocast deprecated — issued via
+    #     typing_extensions @deprecated on __init__, needs a persistent filter
+    #     (not catch_warnings) because stacklevel points into mmdet modules.
+    #  2. "Loads checkpoint / unexpected key" — MMLogger writes to stdout;
+    #     redirect_stdout captures it cleanly.
+    warnings.filterwarnings('ignore', category=FutureWarning)
+
+    try:
+        _captured = io.StringIO()
+        with contextlib.redirect_stdout(_captured):
+            model = init_detector(config_path, pth_path, device='cpu')
+        model.eval()
+
+        # Create dummy input - PyTorch uses (B, C, H, W) format
+        height, width = input_shape
+        dummy_input = torch.randn(1, 3, height, width)
+
+        # Build an export wrapper that includes the full post-processing decode:
+        #   1. Backbone + neck + head  (mode='tensor' — raw logits + ltrb distances)
+        #   2. Sigmoid on cls scores
+        #   3. distance2bbox decode using pre-computed anchor center points (priors)
+        #
+        # NMS is intentionally omitted — it requires dynamic output shapes that are
+        # not supported in ONNX without custom ops, and is best run on-device after
+        # inference.
+        #
+        # Output:
+        #   boxes  : (1, N, 4)   xyxy pixel coordinates (unclipped)
+        #   scores : (1, N, C)   per-class sigmoid probabilities
+        # where N = sum(H_i * W_i) over FPN levels = 8400 for a 640×640 input.
+        class _RTMDetDecodeWrapper(torch.nn.Module):
+            def __init__(self, m, input_h: int, input_w: int):
+                super().__init__()
+                self.m = m
+                # Pre-compute anchor center points for all FPN levels.
+                # Strides come from the prior generator; default RTMDet uses [8, 16, 32].
+                strides = [s[0] for s in m.bbox_head.prior_generator.strides]
+                priors_list = []
+                for stride in strides:
+                    feat_h = input_h // stride
+                    feat_w = input_w // stride
+                    shift_x = (torch.arange(feat_w, dtype=torch.float32) + 0.5) * stride
+                    shift_y = (torch.arange(feat_h, dtype=torch.float32) + 0.5) * stride
+                    yy, xx = torch.meshgrid(shift_y, shift_x, indexing='ij')
+                    priors_list.append(
+                        torch.stack([xx.reshape(-1), yy.reshape(-1)], dim=-1)
+                    )
+                # priors: (N_total, 2) — constant for a fixed input size
+                self.register_buffer('priors', torch.cat(priors_list, dim=0))
+
+            def forward(self, img):
+                feats = self.m.extract_feat(img)
+                cls_scores, bbox_preds = self.m.bbox_head(feats)
+
+                all_scores, all_dists = [], []
+                for cls_score, bbox_pred in zip(cls_scores, bbox_preds):
+                    B = cls_score.shape[0]
+                    # (B, C, H, W) -> (B, H*W, C)
+                    all_scores.append(
+                        cls_score.permute(0, 2, 3, 1).reshape(B, -1, cls_score.shape[1])
+                    )
+                    # (B, 4, H, W) -> (B, H*W, 4)
+                    all_dists.append(
+                        bbox_pred.permute(0, 2, 3, 1).reshape(B, -1, 4)
+                    )
+
+                scores = torch.cat(all_scores, dim=1).sigmoid()  # (B, N, C)
+                dists  = torch.cat(all_dists,  dim=1)            # (B, N, 4)
+
+                # distance2bbox: (cx - dl, cy - dt, cx + dr, cy + db)
+                priors = self.priors.unsqueeze(0)                # (1, N, 2)
+                x1 = priors[..., 0] - dists[..., 0]
+                y1 = priors[..., 1] - dists[..., 1]
+                x2 = priors[..., 0] + dists[..., 2]
+                y2 = priors[..., 1] + dists[..., 3]
+                boxes = torch.stack([x1, y1, x2, y2], dim=-1)   # (B, N, 4)
+
+                return boxes, scores
+
+        export_model = _RTMDetDecodeWrapper(model, height, width)
+        export_model.eval()
+
+        # Dry run to confirm output shapes.
+        with torch.no_grad():
+            boxes_out, scores_out = export_model(dummy_input)
+        print(f"[CONV] boxes : {list(boxes_out.shape)}")   # (1, 8400, 4)
+        print(f"[CONV] scores: {list(scores_out.shape)}")  # (1, 8400, 80)
+
+        # Export to ONNX — two named outputs: boxes (xyxy) and scores (per-class sigmoid)
+        torch.onnx.export(
+            export_model,
+            dummy_input,
+            onnx_path,
+            export_params=True,
+            opset_version=13,
+            do_constant_folding=True,
+            input_names=['input'],
+            output_names=['boxes', 'scores'],
+        )
+        print(f"[CONV] Raw ONNX written to: {onnx_path}")
+        
+        # Fix batch size to 1 (explicitly)
+        fix_onnx_batch_size(onnx_path, batch_size=1)
+        
+        # Run shape inference
+        try:
+            import onnx
+            import onnx.shape_inference
+            print("[POST] Running ONNX shape inference …")
+            model_proto = onnx.load(onnx_path)
+            model_proto = onnx.shape_inference.infer_shapes(model_proto)
+            onnx.save(model_proto, onnx_path)
+            print("[POST] Shape inference complete – model saved.\n")
+        except ImportError:
+            print("[POST] WARNING: 'onnx' package not found – skipping shape inference.\n")
+        except Exception as exc:
+            print(f"[POST] WARNING: shape inference failed ({exc}) – model unchanged.\n")
+        
+        # Optional ONNX simplification
+        if simplify:
+            try:
+                import onnx
+                import onnxsim
+                print("[SIMPLIFY] Simplifying model …")
+                model = onnx.load(onnx_path)
+                model_simplified, check = onnxsim.simplify(
+                    model,
+                    check_n=3,
+                    perform_optimization=True,
+                    skip_fuse_bn=False,
+                )
+                if not check:
+                    print("[SIMPLIFY] Warning: Simplification validation failed")
+                else:
+                    print("[SIMPLIFY] Simplification successful and validated")
+                onnx.save(model_simplified, onnx_path)
+                print(f"[SIMPLIFY] Simplified model saved to: {onnx_path}\n")
+            except ImportError:
+                print("[SIMPLIFY] WARNING: 'onnx-simplifier' package not found – skipping simplification.\n")
+            except Exception as exc:
+                print(f"[SIMPLIFY] WARNING: simplification failed ({exc}) – using original model.\n")
+        
+        print(f"[SUCCESS] ONNX model saved to: {onnx_path}")
+        return True
+    except Exception as e:
+        print(f"Error during ONNX conversion: {e}")
+        return False
+    finally:
+        torch.load = _orig_torch_load  # always restore, even on exception
+
+
+def process_link_file(link_file_path: str, simplify: bool = False) -> bool:
+    """
+    Process a single .link file: download PTH and convert to ONNX.
+
+    Expected .link format (single line):
+        <pth_url> -o <onnx_filename>
+    """
+    with open(link_file_path, 'r') as f:
+        lines = [line.strip() for line in f.readlines() if line.strip()]
+
+    if not lines:
+        print(f"Warning: {link_file_path} is empty.")
+        return False
+
+    parts = lines[0].split()
+    if len(parts) < 3 or parts[-2] != '-o':
+        print(f"Warning: Unexpected format in {link_file_path}: {lines[0]}")
+        return False
+
+    pth_url = parts[0]
+    onnx_filename = parts[-1]
+
+    # Derive variant from filename: "rtmdet_tiny.onnx" → "tiny"
+    model_name = os.path.splitext(onnx_filename)[0]   # rtmdet_tiny
+    variant = model_name.split('_')[1]                 # tiny
+    pth_filename = model_name + '.pth'
+
+    if variant not in _VARIANT_CONFIG:
+        print(f"[WARN] Cannot determine variant from filename '{onnx_filename}'. Skipping.")
+        return False
+
+    # Download checkpoint
+    if not os.path.exists(pth_filename):
+        if not download_file(pth_url, pth_filename, label=f"RTMDet-{variant} checkpoint"):
+            print(f"Failed to download checkpoint. Skipping conversion.")
+            return False
+    else:
+        print(f"[INFO] Checkpoint already exists: {pth_filename}")
+
+    # Resolve config path (downloaded by setup_configs)
+    config_path = get_config_path(variant)
+    if not os.path.exists(config_path):
+        print(f"[ERROR] Config not found: {config_path}. Run setup_configs() first.")
+        return False
+
+    input_shape = get_input_shape_from_config(config_path)
+    print(f"[INFO] Input shape: {input_shape}")
+
+    success = convert_to_onnx(pth_filename, config_path, onnx_filename, input_shape, simplify=simplify)
+    if success:
+        print(f"[SUCCESS] Conversion complete: {onnx_filename}")
+    else:
+        print(f"[ERROR] Conversion failed for {onnx_filename}")
+
+    return success
+
+
+def generate_link_files(variants=None, force=False):
+    """
+    Generate .link files for RTMDet variants with correct model URLs.
+
+    Args:
+        variants: List of variant names. If None, uses default list.
+        force: If True, overwrite existing .link files.
+    """
+    if variants is None:
+        variants = ['tiny', 's', 'm', 'l']
+
+    base_url = "https://download.openmmlab.com/mmdetection/v3.0/rtmdet"
+
+    # Actual model URLs with correct hashes (verified from OpenMMLab)
+    # Format: variant -> (model_dir, checkpoint_filename)
+    model_info = {
+        'tiny': ('rtmdet_tiny_8xb32-300e_coco', 'rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth'),
+        's':    ('rtmdet_s_8xb32-300e_coco',    'rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth'),
+        'm':    ('rtmdet_m_8xb32-300e_coco',    'rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth'),
+        'l':    ('rtmdet_l_8xb32-300e_coco',    'rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth'),
+        'x':    ('rtmdet_x_8xb32-300e_coco',    'rtmdet_x_8xb32-300e_coco_20220715_230555-cc79b9ae.pth'),
+    }
+
+    for variant in variants:
+        if variant not in model_info:
+            print(f"[WARN] Unknown variant '{variant}' - skipping")
+            continue
+
+        model_dir, pth_filename = model_info[variant]
+        pth_url = f"{base_url}/{model_dir}/{pth_filename}"
+        onnx_filename = f"rtmdet_{variant}.onnx"
+        link_content = f"{pth_url} -o {onnx_filename}\n"
+
+        link_file = f"rtmdet_{variant}.onnx.link"
+
+        # Skip if file exists and force=False
+        if os.path.exists(link_file) and not force:
+            print(f"[INFO] {link_file} already exists (use --generate-links to regenerate)")
+            continue
+
+        with open(link_file, 'w') as f:
+            f.write(link_content)
+        print(f"[INFO] Generated {link_file}")
+
+
+KNOWN_VARIANTS = ['tiny', 's', 'm', 'l', 'x']
+
+
+def main():
+    """Main function."""
+    import argparse
+    parser = argparse.ArgumentParser(
+        description="Download RTMDet models and convert them to ONNX.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        epilog=(
+            "Examples:\n"
+            "  %(prog)s                        # download all models\n"
+            "  %(prog)s --models tiny s        # download only tiny and s\n"
+            "  %(prog)s --models l --simplify\n"
+        ),
+    )
+    parser.add_argument(
+        "--models",
+        nargs="+",
+        metavar="MODEL",
+        choices=KNOWN_VARIANTS,
+        default=None,
+        help=(
+            f"One or more model variants to download and convert. "
+            f"Choices: {KNOWN_VARIANTS}. "
+            f"Defaults to all variants if omitted."
+        ),
+    )
+    parser.add_argument(
+        "--simplify",
+        action="store_true",
+        default=True,
+        help="Simplify the ONNX model using onnx-simplifier after conversion.",
+    )
+    parser.add_argument(
+        "--no-simplify",
+        dest="simplify",
+        action="store_false",
+        help="Do not simplify the ONNX model.",
+    )
+    parser.add_argument(
+        "--generate-links",
+        action="store_true",
+        help="Force regeneration of .link files even if they already exist.",
+    )
+    args = parser.parse_args()
+
+    variants = args.models if args.models else KNOWN_VARIANTS
+    print(f"Models selected: {variants}\n")
+
+    print("Checking dependencies...")
+
+    # Stub mmcv._ext early so that importing mmdet during the dependency check
+    # does not fail with "No module named 'mmcv._ext'" when mmcv-lite is installed.
+    _stub_mmcv_ext()
+
+    # mmcv must be installed before mmdet to prevent mmdet pulling in mmcv>=2.2.0
+    ensure_mmcv()
+
+    check_dependencies({
+        'torch': 'torch',
+        'mmdet': 'mmdet',
+        'requests': 'requests',
+        'tqdm': 'tqdm',
+        'onnx': 'onnx',
+        'onnxsim': 'onnxsim',
+        'onnxscript': 'onnxscript',
+    })
+
+    # Generate link files only for the selected models
+    print("\nSetting up link files for selected models...")
+    generate_link_files(variants, force=args.generate_links)
+
+    # Download all mmdetection config files (shared across all variants)
+    setup_configs()
+
+    # Process link files for the selected models only
+    print("\nProcessing .link files...")
+    link_files = sorted([
+        f"rtmdet_{v}.onnx.link"
+        for v in variants
+        if os.path.exists(f"rtmdet_{v}.onnx.link")
+    ])
+    if not link_files:
+        print("No .link files found.")
+        return
+
+    for link_file in link_files:
+        print(f"\n{'='*60}")
+        print(f"Processing {link_file}")
+        print('='*60)
+        process_link_file(link_file, simplify=args.simplify)
+
+    print("\n" + "="*60)
+    print(f"Done! Converted {len(link_files)} model(s): {', '.join(v for v in variants)}")
+    print("="*60)
+
+
+if __name__ == "__main__":
+    main()

rtmdet_l.onnx.link

@@ -0,0 +1 @@
+https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_l_8xb32-300e_coco/rtmdet_l_8xb32-300e_coco_20220719_112030-5a0be7c4.pth -o rtmdet_l.onnx

rtmdet_l_config.yaml

@@ -0,0 +1,148 @@
+task_type: detection
+dataloader:
+  name: coco_detection_dataloader
+  path: ./data/datasets/coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - corner
+  name: image_preprocess
+  pad_color:
+  - 114
+  - 114
+  - 114
+session:
+  session_name: onnxrt
+  target_device: null
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 103.53
+  - 116.28
+  - 123.675
+  input_scale:
+  - 0.017429
+  - 0.017507
+  - 0.017125
+  model_path: rtmdet_l.onnx
+  model_id: od-mh8023
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  reshape_list: null
+  formatter:
+    name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - corner
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  concat_details:
+    axis: 2
+    end_index: 2
+  logits_bbox_to_bbox_ls:
+    score_fn: null
+    bbox_index: [0,4]
+    scores_index: [4,-1]
+  keypoint: false
+  object6dpose: false
+  name: detection_postprocess
+metric:
+  label_offset_pred:
+    0: 1
+    1: 2
+    2: 3
+    3: 4
+    4: 5
+    5: 6
+    6: 7
+    7: 8
+    8: 9
+    9: 10
+    10: 11
+    11: 13
+    12: 14
+    13: 15
+    14: 16
+    15: 17
+    16: 18
+    17: 19
+    18: 20
+    19: 21
+    20: 22
+    21: 23
+    22: 24
+    23: 25
+    24: 27
+    25: 28
+    26: 31
+    27: 32
+    28: 33
+    29: 34
+    30: 35
+    31: 36
+    32: 37
+    33: 38
+    34: 39
+    35: 40
+    36: 41
+    37: 42
+    38: 43
+    39: 44
+    40: 46
+    41: 47
+    42: 48
+    43: 49
+    44: 50
+    45: 51
+    46: 52
+    47: 53
+    48: 54
+    49: 55
+    50: 56
+    51: 57
+    52: 58
+    53: 59
+    54: 60
+    55: 61
+    56: 62
+    57: 63
+    58: 64
+    59: 65
+    60: 67
+    61: 70
+    62: 72
+    63: 73
+    64: 74
+    65: 75
+    66: 76
+    67: 77
+    68: 78
+    69: 79
+    70: 80
+    71: 81
+    72: 82
+    73: 84
+    74: 85
+    75: 86
+    76: 87
+    77: 88
+    78: 89
+    79: 90
+    80: 91
+model_info:
+  metric_reference:
+    accuracy_ap[.5:.95]%: 51.4
+  compact_name: rtmdet-l
+  shortlisted: true
+  recommended: false

rtmdet_m.onnx.link

@@ -0,0 +1 @@
+https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_m_8xb32-300e_coco/rtmdet_m_8xb32-300e_coco_20220719_112220-229f527c.pth -o rtmdet_m.onnx

rtmdet_m_config.yaml

@@ -0,0 +1,148 @@
+task_type: detection
+dataloader:
+  name: coco_detection_dataloader
+  path: ./data/datasets/coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - corner
+  name: image_preprocess
+  pad_color:
+  - 114
+  - 114
+  - 114
+session:
+  session_name: onnxrt
+  target_device: null
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 103.53
+  - 116.28
+  - 123.675
+  input_scale:
+  - 0.017429
+  - 0.017507
+  - 0.017125
+  model_path: rtmdet_m.onnx
+  model_id: od-mh8022
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  reshape_list: null
+  formatter:
+    name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - corner
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  concat_details:
+    axis: 2
+    end_index: 2
+  logits_bbox_to_bbox_ls:
+    score_fn: null
+    bbox_index: [0,4]
+    scores_index: [4,-1]
+  keypoint: false
+  object6dpose: false
+  name: detection_postprocess
+metric:
+  label_offset_pred:
+    0: 1
+    1: 2
+    2: 3
+    3: 4
+    4: 5
+    5: 6
+    6: 7
+    7: 8
+    8: 9
+    9: 10
+    10: 11
+    11: 13
+    12: 14
+    13: 15
+    14: 16
+    15: 17
+    16: 18
+    17: 19
+    18: 20
+    19: 21
+    20: 22
+    21: 23
+    22: 24
+    23: 25
+    24: 27
+    25: 28
+    26: 31
+    27: 32
+    28: 33
+    29: 34
+    30: 35
+    31: 36
+    32: 37
+    33: 38
+    34: 39
+    35: 40
+    36: 41
+    37: 42
+    38: 43
+    39: 44
+    40: 46
+    41: 47
+    42: 48
+    43: 49
+    44: 50
+    45: 51
+    46: 52
+    47: 53
+    48: 54
+    49: 55
+    50: 56
+    51: 57
+    52: 58
+    53: 59
+    54: 60
+    55: 61
+    56: 62
+    57: 63
+    58: 64
+    59: 65
+    60: 67
+    61: 70
+    62: 72
+    63: 73
+    64: 74
+    65: 75
+    66: 76
+    67: 77
+    68: 78
+    69: 79
+    70: 80
+    71: 81
+    72: 82
+    73: 84
+    74: 85
+    75: 86
+    76: 87
+    77: 88
+    78: 89
+    79: 90
+    80: 91
+model_info:
+  metric_reference:
+    accuracy_ap[.5:.95]%: 49.3
+  compact_name: rtmdet-m
+  shortlisted: true
+  recommended: false

rtmdet_s.onnx.link

@@ -0,0 +1 @@
+https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_s_8xb32-300e_coco/rtmdet_s_8xb32-300e_coco_20220905_161602-387a891e.pth -o rtmdet_s.onnx

rtmdet_s_config.yaml

@@ -0,0 +1,148 @@
+task_type: detection
+dataloader:
+  name: coco_detection_dataloader
+  path: ./data/datasets/coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - corner
+  name: image_preprocess
+  pad_color:
+  - 114
+  - 114
+  - 114
+session:
+  session_name: onnxrt
+  target_device: null
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 103.53
+  - 116.28
+  - 123.675
+  input_scale:
+  - 0.017429
+  - 0.017507
+  - 0.017125
+  model_path: rtmdet_s.onnx
+  model_id: od-mh8021
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  reshape_list: null
+  formatter:
+    name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - corner
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  concat_details:
+    axis: 2
+    end_index: 2
+  logits_bbox_to_bbox_ls:
+    score_fn: null
+    bbox_index: [0,4]
+    scores_index: [4,-1]
+  keypoint: false
+  object6dpose: false
+  name: detection_postprocess
+metric:
+  label_offset_pred:
+    0: 1
+    1: 2
+    2: 3
+    3: 4
+    4: 5
+    5: 6
+    6: 7
+    7: 8
+    8: 9
+    9: 10
+    10: 11
+    11: 13
+    12: 14
+    13: 15
+    14: 16
+    15: 17
+    16: 18
+    17: 19
+    18: 20
+    19: 21
+    20: 22
+    21: 23
+    22: 24
+    23: 25
+    24: 27
+    25: 28
+    26: 31
+    27: 32
+    28: 33
+    29: 34
+    30: 35
+    31: 36
+    32: 37
+    33: 38
+    34: 39
+    35: 40
+    36: 41
+    37: 42
+    38: 43
+    39: 44
+    40: 46
+    41: 47
+    42: 48
+    43: 49
+    44: 50
+    45: 51
+    46: 52
+    47: 53
+    48: 54
+    49: 55
+    50: 56
+    51: 57
+    52: 58
+    53: 59
+    54: 60
+    55: 61
+    56: 62
+    57: 63
+    58: 64
+    59: 65
+    60: 67
+    61: 70
+    62: 72
+    63: 73
+    64: 74
+    65: 75
+    66: 76
+    67: 77
+    68: 78
+    69: 79
+    70: 80
+    71: 81
+    72: 82
+    73: 84
+    74: 85
+    75: 86
+    76: 87
+    77: 88
+    78: 89
+    79: 90
+    80: 91
+model_info:
+  metric_reference:
+    accuracy_ap[.5:.95]%: 44.5
+  compact_name: rtmdet-s
+  shortlisted: true
+  recommended: false

rtmdet_tiny.onnx.link

@@ -0,0 +1 @@
+https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_tiny_8xb32-300e_coco/rtmdet_tiny_8xb32-300e_coco_20220902_112414-78e30dcc.pth -o rtmdet_tiny.onnx

rtmdet_tiny_config.yaml

@@ -0,0 +1,148 @@
+task_type: detection
+dataloader:
+  name: coco_detection_dataloader
+  path: ./data/datasets/coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - corner
+  name: image_preprocess
+  pad_color:
+  - 114
+  - 114
+  - 114
+session:
+  session_name: onnxrt
+  target_device: null
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 103.53
+  - 116.28
+  - 123.675
+  input_scale:
+  - 0.017429
+  - 0.017507
+  - 0.017125
+  model_path: rtmdet_tiny.onnx
+  model_id: od-mh8020
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  reshape_list: null
+  formatter:
+    name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - corner
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  concat_details:
+    axis: 2
+    end_index: 2
+  logits_bbox_to_bbox_ls:
+    score_fn: null
+    bbox_index: [0,4]
+    scores_index: [4,-1]
+  keypoint: false
+  object6dpose: false
+  name: detection_postprocess
+metric:
+  label_offset_pred:
+    0: 1
+    1: 2
+    2: 3
+    3: 4
+    4: 5
+    5: 6
+    6: 7
+    7: 8
+    8: 9
+    9: 10
+    10: 11
+    11: 13
+    12: 14
+    13: 15
+    14: 16
+    15: 17
+    16: 18
+    17: 19
+    18: 20
+    19: 21
+    20: 22
+    21: 23
+    22: 24
+    23: 25
+    24: 27
+    25: 28
+    26: 31
+    27: 32
+    28: 33
+    29: 34
+    30: 35
+    31: 36
+    32: 37
+    33: 38
+    34: 39
+    35: 40
+    36: 41
+    37: 42
+    38: 43
+    39: 44
+    40: 46
+    41: 47
+    42: 48
+    43: 49
+    44: 50
+    45: 51
+    46: 52
+    47: 53
+    48: 54
+    49: 55
+    50: 56
+    51: 57
+    52: 58
+    53: 59
+    54: 60
+    55: 61
+    56: 62
+    57: 63
+    58: 64
+    59: 65
+    60: 67
+    61: 70
+    62: 72
+    63: 73
+    64: 74
+    65: 75
+    66: 76
+    67: 77
+    68: 78
+    69: 79
+    70: 80
+    71: 81
+    72: 82
+    73: 84
+    74: 85
+    75: 86
+    76: 87
+    77: 88
+    78: 89
+    79: 90
+    80: 91
+model_info:
+  metric_reference:
+    accuracy_ap[.5:.95]%: 40.9
+  compact_name: rtmdet-tiny
+  shortlisted: true
+  recommended: true

rtmdet_x.onnx.link

@@ -0,0 +1 @@
+https://download.openmmlab.com/mmdetection/v3.0/rtmdet/rtmdet_x_8xb32-300e_coco/rtmdet_x_8xb32-300e_coco_20220715_230555-cc79b9ae.pth -o rtmdet_x.onnx

rtmdet_x_config.yaml

@@ -0,0 +1,148 @@
+task_type: detection
+dataloader:
+  name: coco_detection_dataloader
+  path: ./data/datasets/coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - corner
+  name: image_preprocess
+  pad_color:
+  - 114
+  - 114
+  - 114
+session:
+  session_name: onnxrt
+  target_device: null
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 103.53
+  - 116.28
+  - 123.675
+  input_scale:
+  - 0.017429
+  - 0.017507
+  - 0.017125
+  model_path: rtmdet_x.onnx
+  model_id: od-mh8024
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  reshape_list: null
+  formatter:
+    name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - corner
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  concat_details:
+    axis: 2
+    end_index: 2
+  logits_bbox_to_bbox_ls:
+    score_fn: null
+    bbox_index: [0,4]
+    scores_index: [4,-1]
+  keypoint: false
+  object6dpose: false
+  name: detection_postprocess
+metric:
+  label_offset_pred:
+    0: 1
+    1: 2
+    2: 3
+    3: 4
+    4: 5
+    5: 6
+    6: 7
+    7: 8
+    8: 9
+    9: 10
+    10: 11
+    11: 13
+    12: 14
+    13: 15
+    14: 16
+    15: 17
+    16: 18
+    17: 19
+    18: 20
+    19: 21
+    20: 22
+    21: 23
+    22: 24
+    23: 25
+    24: 27
+    25: 28
+    26: 31
+    27: 32
+    28: 33
+    29: 34
+    30: 35
+    31: 36
+    32: 37
+    33: 38
+    34: 39
+    35: 40
+    36: 41
+    37: 42
+    38: 43
+    39: 44
+    40: 46
+    41: 47
+    42: 48
+    43: 49
+    44: 50
+    45: 51
+    46: 52
+    47: 53
+    48: 54
+    49: 55
+    50: 56
+    51: 57
+    52: 58
+    53: 59
+    54: 60
+    55: 61
+    56: 62
+    57: 63
+    58: 64
+    59: 65
+    60: 67
+    61: 70
+    62: 72
+    63: 73
+    64: 74
+    65: 75
+    66: 76
+    67: 77
+    68: 78
+    69: 79
+    70: 80
+    71: 81
+    72: 82
+    73: 84
+    74: 85
+    75: 86
+    76: 87
+    77: 88
+    78: 89
+    79: 90
+    80: 91
+model_info:
+  metric_reference:
+    accuracy_ap[.5:.95]%: 52.8
+  compact_name: rtmdet-x
+  shortlisted: true
+  recommended: false