Add yolo11 model files

README.md

@@ -0,0 +1,202 @@
+---
+license: agpl-3.0
+tags:
+- vision
+- image-detection
+datasets:
+- COCO
+---
+
+<div align="center">
+
+# YOLO11 for TI EdgeAI
+
+### Real-Time Object Detector with an Enhanced Backbone and C2PSA Attention
+
+[![License](https://img.shields.io/badge/License-AGPL%203.0-blue?style=for-the-badge)](https://opensource.org/licenses/AGPL-3.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
+
+**YOLO11** is Ultralytics' successor to YOLOv8, released in September 2024. It keeps the overall one-stage, anchor-free detection pipeline but reworks the backbone and neck for more efficient feature extraction: the `C2f` block used throughout YOLOv8 is replaced by a `C3k2` block (a faster variant of the CSP bottleneck that can switch between smaller convolution kernels for efficiency), and a `C2PSA` (Cross-Stage Partial with Spatial Attention) module is inserted after the backbone's SPPF layer to add lightweight spatial-attention refinement to the extracted features. Together with a refined training pipeline, these changes let YOLO11 reach higher COCO mAP than the equivalent YOLOv8 scale while using noticeably fewer parameters — for example, YOLO11m matches or beats YOLOv8m's accuracy with about 22% fewer parameters.
+
+YOLO11 is offered in five size variants — n, s, m, l, x — spanning a wide accuracy-speed trade-off, from resource-constrained edge devices up to high-throughput deployments. This model is optimized for **Texas Instruments MPU (Microprocessor Unit) devices**, targeting edge computer vision use cases such as industrial automation, smart cameras, robotics, and IoT vision.
+
+> See [YOLO26](../YOLO26/) for the newest Ultralytics generation, with native end-to-end (NMS-free) detection.
+
+---
+
+## Model Variants
+
+| Model | Params (M) | Input Size | mAP[.5:.95]% | Validated Devices | Config |
+|-------|------------|------------|--------------|--------------------|--------|
+| `yolo11n` | 2.6 | 640×640 | 39.5 | TDA4VH, TDA4VL | [yolo11n_model_config.yaml](yolo11n_model_config.yaml) |
+| `yolo11s` | 9.4 | 640×640 | 47.0 | TDA4VH, TDA4VL | [yolo11s_model_config.yaml](yolo11s_model_config.yaml) |
+| `yolo11m` | 20.1 | 640×640 | 51.5 | TDA4VH, TDA4VL | [yolo11m_model_config.yaml](yolo11m_model_config.yaml) |
+| `yolo11l` | 25.3 | 640×640 | 53.4 | TDA4VH, TDA4VL | [yolo11l_model_config.yaml](yolo11l_model_config.yaml) |
+| `yolo11x` | 56.9 | 640×640 | 54.7 | TDA4VH, TDA4VL | [yolo11x_model_config.yaml](yolo11x_model_config.yaml) |
+
+**Recommended for edge deployment:** `yolo11n` (best accuracy/compute trade-off, smallest footprint)
+
+---
+
+## Quick Start
+
+### Prerequisites
+
+```bash
+pip install onnx>=1.22.0
+pip install onnxruntime>=1.23.2
+pip install ultralytics
+```
+
+For TI hardware deployment, also set up **[tidlrunner](https://github.com/TexasInstruments/edgeai-tidlrunner/blob/main/README.md)**.
+
+If accessing this model from HuggingFace, clone the repository using the `hf` CLI:
+
+```bash
+hf download <REPO_ID> --local-dir <download_location>
+```
+
+### Export the Model
+
+```bash
+# Prepare the default model (yolo11n)
+python prepare_model.py
+
+# Prepare a specific model variant
+python prepare_model.py --model yolo11s
+
+# Prepare multiple variants in one run
+python prepare_model.py --model yolo11n yolo11s yolo11m
+
+# Prepare every supported variant
+python prepare_model.py --model all
+
+# List all supported variants and their local download/conversion status
+python prepare_model.py --list-models
+
+# Re-run shape fixing on an already-downloaded ONNX
+python prepare_model.py --model yolo11n --skip-download
+```
+
+The script automatically:
+- Parses the variant's `.link` file to get the HuggingFace download URL for the `.pt` checkpoint
+- Downloads the `.pt` model with `curl` if it isn't already present locally
+- Converts the `.pt` model to ONNX (opset 17) using Ultralytics' `model.export()`
+- Fixes dynamic input dimensions to a static shape (default `[1, 3, 640, 640]`)
+- Runs ONNX shape inference and optional `onnx-simplifier` optimization, then validates the result
+
+### 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/yolo11n_model_config.yaml
+```
+
+**Run Inference Benchmark - on device**
+
+```bash
+cd /path/to/edgeai-tidlrunner
+tidlrunner-cli infer --target_device J784S4 \
+  --config_path /path/to/yolo11n_model_config.yaml
+```
+
+To evaluate accuracy instead, replace `infer` with `evaluate` in the command above.
+
+### 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
+
+Ultralytics has not published a formal research paper for YOLO11 due to the rapidly evolving nature of the models. If you use the YOLO11 model or any other software from the Ultralytics repository in your work, please cite it using the following format:
+
+```bibtex
+@software{yolo11_ultralytics,
+  author = {Glenn Jocher and Jing Qiu},
+  title = {Ultralytics YOLO11},
+  version = {11.0.0},
+  year = {2024},
+  url = {https://github.com/ultralytics/ultralytics},
+  orcid = {0000-0001-5950-6979, 0000-0003-3783-7069},
+  license = {AGPL-3.0}
+}
+```
+
+---
+
+## 🔗 Resources
+
+| Resource | Link |
+|----------|------|
+| **Source Code** | [ultralytics/ultralytics](https://github.com/ultralytics/ultralytics) |
+| **Documentation** | [YOLO11 Docs](https://docs.ultralytics.com/models/yolo11/) |
+| **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 MPU Overview** | [GitHub](https://github.com/TexasInstruments/edgeai/tree/main/edgeai-mpu) |
+| **TI EdgeAI Ecosystem** | [GitHub](https://github.com/TexasInstruments/edgeai) |
+
+---
+
+## Related Models
+
+<table>
+<tr>
+<td align="center">
+
+**YOLOv8**
+Predecessor generation
+Anchor-free split head
+
+</td>
+<td align="center">
+
+**YOLO26**
+Newest Ultralytics generation
+NMS-free end-to-end detection
+
+</td>
+<td align="center">
+
+**YOLOX**
+Anchor-free YOLO variant
+Decoupled head design
+
+</td>
+<td align="center">
+
+**RTMDet**
+CNN-based alternative
+Real-time mmdetection model
+
+</td>
+</tr>
+</table>
+
+---
+
+<div align="center">
+
+**Maintained by:** Texas Instruments EdgeAI Team  
+**Last Updated:** August 2026
+
+</div>

prepare_model.py

@@ -0,0 +1,656 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2018-2026, Texas Instruments
+# All Rights Reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+Script to download YOLO11 PyTorch (.pt) model from HuggingFace and convert to ONNX
+for hardware deployment on TI edge devices.
+
+Reads .link files containing download URLs and automatically:
+ 1. Downloads the .pt model if not present
+ 2. Converts the .pt model to ONNX format using Ultralytics
+ 3. Fixes dynamic shapes to static shapes
+ 4. Validates the result
+
+Link file format:
+     <download_url> -o <output_filename>
+
+Example:
+     https://huggingface.co/Ultralytics/YOLO11/blob/main/yolo11n.pt -o yolo11n.pt
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+import argparse
+
+
+def _ensure_dependencies():
+    required = {"onnx": "onnx", "onnxsim": "onnx-simplifier", "ultralytics": "ultralytics"}
+    for module, package in required.items():
+        try:
+            __import__(module)
+        except ImportError:
+            print(f"Installing missing dependency: {package}")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+
+
+def parse_link_file(link_file_path):
+    """
+    Parse .link file to extract download URL and output filename.
+
+    Expected format: <URL> -o <filename>
+
+    Returns:
+        tuple: (download_url, output_filename) or (None, None) if parsing fails
+    """
+    try:
+        with open(link_file_path, 'r') as f:
+            content = f.read().strip()
+
+        for line in content.split('\n'):
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+
+            if '-o' in line:
+                parts = line.split('-o')
+                if len(parts) == 2:
+                    url = parts[0].strip()
+                    filename = parts[1].strip()
+
+                    # Convert HuggingFace blob URLs to resolve URLs for direct download
+                    if 'huggingface.co' in url and '/blob/' in url:
+                        url = url.replace('/blob/', '/resolve/')
+
+                    return url, filename
+
+        print(f"Error: Could not parse link file format. Expected: <URL> -o <filename>")
+        return None, None
+
+    except Exception as e:
+        print(f"Error reading link file: {e}")
+        return None, None
+
+
+def download_model(url, output_path, force=False):
+    """
+    Download model from URL using curl.
+
+    Args:
+        url: Download URL
+        output_path: Path to save downloaded model
+        force: Force re-download even if file exists
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    if output_path.exists() and not force:
+        print(f"Model already exists: {output_path}")
+        file_size = output_path.stat().st_size
+        print(f"File size: {file_size:,} bytes ({file_size / 1024 / 1024:.2f} MB)")
+        return True
+
+    print(f"\n📥 Downloading Model:")
+    print("-" * 80)
+    print(f"URL: {url}")
+    print(f"Output: {output_path}")
+    print()
+
+    try:
+        result = subprocess.run(
+            ['curl', '-L', url, '-o', str(output_path), '--progress-bar'],
+            check=True,
+            capture_output=False
+        )
+
+        if output_path.exists():
+            file_size = output_path.stat().st_size
+            print(f"\n✓ Download completed successfully!")
+            print(f"✓ File size: {file_size:,} bytes ({file_size / 1024 / 1024:.2f} MB)")
+            return True
+        else:
+            print(f"\n✗ Download failed: output file not created")
+            return False
+
+    except subprocess.CalledProcessError as e:
+        print(f"\n✗ Download failed: {e}")
+        return False
+    except FileNotFoundError:
+        print(f"\n✗ curl not found. Please install curl.")
+        return False
+
+
+def convert_pt_to_onnx(pt_path, onnx_path, height=640, width=640):
+    """
+    Convert a YOLO11 PyTorch .pt model to ONNX format using Ultralytics.
+
+    Args:
+        pt_path: Path to the input .pt model
+        onnx_path: Desired output path for the ONNX model
+        height: Input image height
+        width: Input image width
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    print(f"\n🔄 Converting .pt to ONNX:")
+    print("=" * 80)
+    print(f"Input  (.pt):   {pt_path}")
+    print(f"Output (.onnx): {onnx_path}")
+    print(f"Image size:     {height}x{width}")
+
+    try:
+        from ultralytics import YOLO
+    except ImportError:
+        print("\n✗ ultralytics not installed.")
+        print("  Install with: pip install ultralytics")
+        return False
+
+    try:
+        model = YOLO(str(pt_path))
+
+        # Export to ONNX; Ultralytics places the file next to the .pt by default
+        exported = model.export(
+            format='onnx',
+            imgsz=(height, width),
+            dynamic=False,
+            simplify=False,   # we run our own simplifier step below
+            opset=17,
+        )
+
+        exported_path = Path(exported)
+
+        # Move/rename to the desired output path if different
+        if exported_path.resolve() != onnx_path.resolve():
+            exported_path.rename(onnx_path)
+            print(f"\n✓ Moved exported model to: {onnx_path}")
+
+        if onnx_path.exists():
+            file_size = onnx_path.stat().st_size
+            print(f"✓ ONNX model size: {file_size:,} bytes ({file_size / 1024 / 1024:.2f} MB)")
+            return True
+        else:
+            print(f"\n✗ Conversion failed: output file not found at {onnx_path}")
+            return False
+
+    except Exception as e:
+        print(f"\n✗ Conversion failed: {e}")
+        return False
+
+
+def fix_model_shape(model_path, output_path, batch_size=1, channels=3, height=640, width=640, use_simplifier=True):
+    """
+    Convert dynamic ONNX model input shape to fixed shape in all layers.
+
+    Uses ONNX shape inference to propagate fixed shapes through all intermediate layers.
+    Optionally uses onnxsim for additional simplification and optimization.
+    """
+    import onnx
+    from onnx import shape_inference
+
+    print(f"\n🔧 Fixing Model Shapes:")
+    print("=" * 80)
+    print(f"Input model: {model_path}")
+    print(f"Output model: {output_path}")
+
+    # Load model
+    print(f"\nLoading model...")
+    model = onnx.load(str(model_path))
+
+    # Get the first input (skip initializers)
+    graph = model.graph
+    input_tensor = None
+    for inp in graph.input:
+        if any(init.name == inp.name for init in graph.initializer):
+            continue
+        input_tensor = inp
+        break
+
+    if input_tensor is None:
+        print("✗ Error: No input tensor found!")
+        return False
+
+    # Print original shape
+    print(f"\n📋 Original Shape:")
+    print("-" * 80)
+    print(f"Input name: {input_tensor.name}")
+    original_shape = []
+    for dim in input_tensor.type.tensor_type.shape.dim:
+        if dim.dim_value:
+            original_shape.append(str(dim.dim_value))
+        elif dim.dim_param:
+            original_shape.append(f"'{dim.dim_param}'")
+        else:
+            original_shape.append("?")
+    print(f"Shape: [{', '.join(original_shape)}]")
+
+    # Modify input shape to fixed dimensions
+    print(f"\n🔧 Setting Fixed Shape:")
+    print("-" * 80)
+    new_shape = [batch_size, channels, height, width]
+    print(f"New shape: {new_shape}")
+    print(f"Format: [batch_size, channels, height, width]")
+
+    # Clear existing dimensions and add new fixed dimensions
+    input_tensor.type.tensor_type.shape.ClearField('dim')
+    for dim_value in new_shape:
+        dim = input_tensor.type.tensor_type.shape.dim.add()
+        dim.dim_value = dim_value
+
+    # Run shape inference
+    print(f"\n🔄 Running Shape Inference:")
+    print("-" * 80)
+    try:
+        model = shape_inference.infer_shapes(model)
+        value_info_count = len(model.graph.value_info)
+        print(f"✓ Propagated shapes through {value_info_count} intermediate tensors")
+    except Exception as e:
+        print(f"⚠ Warning: Shape inference issue: {e}")
+        print("  Continuing with partial inference...")
+
+    # Validate model
+    print(f"\n✅ Validating Model:")
+    print("-" * 80)
+    try:
+        onnx.checker.check_model(model)
+        print("✓ Model validation passed")
+    except Exception as e:
+        print(f"✗ Model validation failed: {e}")
+        return False
+
+    # Optional: Use onnx-simplifier
+    if use_simplifier:
+        print(f"\n🚀 Running ONNX Simplifier:")
+        print("-" * 80)
+        try:
+            import onnxsim
+            model_simplified, check = onnxsim.simplify(
+                model,
+                check_n=3,
+                perform_optimization=True,
+                skip_fuse_bn=False,
+                overwrite_input_shapes={input_tensor.name: new_shape}
+            )
+
+            if check:
+                print("✓ Model simplified and optimized")
+                model = model_simplified
+
+                original_nodes = len(graph.node)
+                simplified_nodes = len(model.graph.node)
+                if simplified_nodes < original_nodes:
+                    print(f"✓ Reduced nodes: {original_nodes} → {simplified_nodes}")
+            else:
+                print("⚠ Simplification validation failed, using non-simplified version")
+
+        except ImportError:
+            print("⚠ onnx-simplifier not installed, skipping")
+            print("  Install with: pip install onnx-simplifier")
+        except Exception as e:
+            print(f"⚠ Simplification failed: {e}")
+            print("  Continuing with non-simplified model")
+
+    # Save the modified model
+    print(f"\n💾 Saving Fixed Model:")
+    print("-" * 80)
+    onnx.save(model, str(output_path))
+    output_size = output_path.stat().st_size
+    print(f"✓ Saved to: {output_path}")
+    print(f"✓ File size: {output_size:,} bytes ({output_size / 1024 / 1024:.2f} MB)")
+
+    # Final verification
+    print(f"\n🔍 Final Verification:")
+    print("-" * 80)
+    try:
+        verified_model = onnx.load(str(output_path))
+        onnx.checker.check_model(verified_model)
+
+        verified_graph = verified_model.graph
+        for inp in verified_graph.input:
+            if any(init.name == inp.name for init in verified_graph.initializer):
+                continue
+            shape = [dim.dim_value for dim in inp.type.tensor_type.shape.dim]
+            all_fixed = all(isinstance(s, int) and s > 0 for s in shape)
+            if all_fixed:
+                print(f"✓ Input '{inp.name}': {shape}")
+            else:
+                print(f"⚠ Input '{inp.name}' has dynamic dimensions")
+
+        if verified_graph.value_info:
+            fixed_count = sum(
+                1 for vi in verified_graph.value_info
+                if all(dim.dim_value > 0 for dim in vi.type.tensor_type.shape.dim)
+            )
+            total_count = len(verified_graph.value_info)
+            print(f"✓ Fixed shapes: {fixed_count}/{total_count} intermediate tensors")
+
+        print(f"\n✨ Success! Fixed model ready for deployment")
+        return True
+
+    except Exception as e:
+        print(f"✗ Final verification failed: {e}")
+        return False
+
+
+# Supported YOLO11 model variants
+YOLO11_VARIANTS = ['yolo11n', 'yolo11s', 'yolo11m', 'yolo11l', 'yolo11x']
+DEFAULT_MODEL = YOLO11_VARIANTS[0]
+
+
+def list_models(script_dir):
+    """
+    Print all supported YOLO11 model variants along with their local status:
+    whether a .link file is present and whether the final ONNX output exists.
+    """
+    col = 14
+    header = f"  {'Variant':<{col}}{'Link file':<12}{'ONNX output':<30}{'Status'}"
+    print("\n" + "=" * len(header))
+    print("  Available YOLO11 model variants")
+    print("=" * len(header))
+    print(header)
+    print("  " + "-" * (len(header) - 2))
+
+    for variant in YOLO11_VARIANTS:
+        link_file = script_dir / f'{variant}.onnx.link'
+
+        if not link_file.exists():
+            print(f"  {variant:<{col}}{'missing':<12}{'-':<30}{'no link file'}")
+            continue
+
+        _, onnx_filename = parse_link_file(link_file)
+        onnx_filename = onnx_filename or '?'
+        final_onnx_output = script_dir / onnx_filename
+
+        if final_onnx_output.exists():
+            file_size = final_onnx_output.stat().st_size
+            status = f"downloaded ({file_size / 1024 / 1024:.1f} MB)"
+        else:
+            status = "not downloaded"
+
+        print(f"  {variant:<{col}}{'ok':<12}{onnx_filename:<30}{status}")
+
+    print("=" * len(header) + "\n")
+
+
+def process_single_model(model_variant, script_dir, args):
+    """
+    Process a single model variant.
+    
+    Args:
+        model_variant: Name of the model variant (e.g., 'yolo11n')
+        script_dir: Directory containing the script and link files
+        args: Parsed command line arguments
+        
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    link_file_name = f'{model_variant}.onnx.link'
+    link_file = script_dir / link_file_name
+
+    if not link_file.exists():
+        print(f"Error: Link file not found: {link_file}")
+        print(f"Expected format in link file: <URL> -o <filename>")
+        return False
+
+    # Parse link file
+    print("📄 Parsing Link File:")
+    print("=" * 80)
+    print(f"Link file: {link_file}")
+
+    download_url, onnx_filename = parse_link_file(link_file)
+
+    if download_url is None or onnx_filename is None:
+        return False
+
+    print(f"Download URL: {download_url}")
+    print(f"ONNX model name (from .link file): {onnx_filename}")
+
+    # The final output uses the name from .link file
+    final_onnx_output = script_dir / onnx_filename
+
+    # Derive the .pt filename from the URL (last path segment, keeping .pt extension)
+    pt_filename = Path(download_url.split('?')[0]).name  # e.g. yolo11n.pt
+    if not pt_filename.endswith('.pt'):
+        pt_filename = Path(onnx_filename).stem + '.pt'
+    pt_path = script_dir / pt_filename
+
+    # Temporary ONNX file (before shape fixing)
+    temp_onnx_path = script_dir / f".tmp_{onnx_filename}"
+
+    print(f"PT download path:  {pt_path.name}")
+    print(f"Final ONNX output: {final_onnx_output.name}")
+    print(f"Intermediate ONNX: {temp_onnx_path.name}")
+
+    if args.skip_download:
+        # User wants to fix an existing ONNX model
+        if not final_onnx_output.exists():
+            print(f"\n✗ Error: ONNX model file not found: {final_onnx_output}")
+            print(f"   Run without --skip-download to download and convert it first.")
+            return False
+        print(f"Using existing ONNX model: {final_onnx_output.name}")
+        model_path_for_fixing = final_onnx_output
+    elif final_onnx_output.exists() and not args.force_download:
+        # Final ONNX already present — skip download and conversion entirely
+        file_size = final_onnx_output.stat().st_size
+        print(f"\n⏭  Skipping download and ONNX conversion:")
+        print(f"   {final_onnx_output.name} already exists "
+              f"({file_size:,} bytes / {file_size / 1024 / 1024:.2f} MB).")
+        print(f"   Use --force-download to re-download and re-convert.")
+        model_path_for_fixing = final_onnx_output
+    else:
+        # Step 1: Download .pt model (always kept)
+        success = download_model(download_url, pt_path, force=args.force_download)
+        if not success:
+            print("\n✗ Download failed, aborting.")
+            if pt_path.exists():
+                pt_path.unlink()
+            return False
+
+        # Step 2: Convert .pt → ONNX to temporary location
+        success = convert_pt_to_onnx(
+            pt_path,
+            temp_onnx_path,
+            height=args.height,
+            width=args.width,
+        )
+        if not success:
+            print("\n✗ ONNX conversion failed, aborting.")
+            # Clean up temporary files
+            if temp_onnx_path.exists():
+                temp_onnx_path.unlink()
+            return False
+
+        print(f"\n📦 PT model kept at: {pt_path.name}")
+        model_path_for_fixing = temp_onnx_path
+
+    # Step 3: Fix shapes on the ONNX model (output to final location)
+    success = fix_model_shape(
+        model_path_for_fixing,
+        final_onnx_output,
+        batch_size=args.batch_size,
+        channels=args.channels,
+        height=args.height,
+        width=args.width,
+        use_simplifier=not args.no_simplifier
+    )
+
+    if success:
+        # Step 4: Clean up intermediate file (unless --keep-intermediate)
+        if not args.skip_download and model_path_for_fixing != final_onnx_output:
+            if args.keep_intermediate:
+                print(f"\n📦 Keeping intermediate file: {model_path_for_fixing.name}")
+            else:
+                print(f"\n🗑️  Cleaning up intermediate file...")
+                try:
+                    model_path_for_fixing.unlink()
+                    print(f"✓ Removed: {model_path_for_fixing.name}")
+                except Exception as e:
+                    print(f"⚠ Could not remove intermediate file: {e}")
+
+        print("\n" + "=" * 80)
+        print("✅ COMPLETE!")
+        print("=" * 80)
+        print(f"Final model:    {final_onnx_output.name}")
+        print(f"Location:       {script_dir}")
+        print(f"Input shape:    [{args.batch_size}, {args.channels}, {args.height}, {args.width}]")
+        return True
+    else:
+        print("\n✗ Shape fixing failed")
+        # Clean up temporary file on failure
+        if not args.skip_download and model_path_for_fixing.exists() and model_path_for_fixing != final_onnx_output:
+            model_path_for_fixing.unlink()
+        return False
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Download YOLO11 .pt model, convert to ONNX, and fix shapes for hardware deployment',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Supported model variants: yolo11n, yolo11s, yolo11m, yolo11l, yolo11x
+
+Notes:
+  If the final ONNX file already exists, download and conversion are skipped
+  automatically and the existing file is used directly. Pass --force-download
+  to override this behaviour and re-download / re-convert.
+
+Examples:
+  # Use default .link file and settings (downloads .pt, converts to ONNX, keeps .pt)
+  %(prog)s
+
+  # Specify a model variant by name (uses <variant>.onnx.link automatically)
+  %(prog)s --model yolo11s
+  %(prog)s --model yolo11m
+  %(prog)s --model yolo11l
+  %(prog)s --model yolo11x
+
+  # Specify multiple models to process
+  %(prog)s --model yolo11n yolo11s yolo11m
+  %(prog)s --model yolo11l yolo11x
+
+  # Prepare every supported model variant
+  %(prog)s --model all
+
+  # List all supported model variants and their local status
+  %(prog)s --list-models
+
+  # Specify custom .link file explicitly
+  %(prog)s --link-file yolo11n.onnx.link
+
+  # Custom shape dimensions
+  %(prog)s --batch-size 4 --height 640 --width 640
+
+  # Force re-download and re-conversion even if ONNX already exists
+  %(prog)s --force-download
+
+  # Skip model simplification (faster)
+  %(prog)s --no-simplifier
+
+  # Skip download and conversion (fix existing ONNX model only)
+  %(prog)s --skip-download
+
+  # Keep intermediate downloaded file (the temporary ONNX before shape fixing)
+  %(prog)s --keep-intermediate
+        """
+    )
+
+    parser.add_argument('--model', nargs='+', type=str, default=[DEFAULT_MODEL],
+                        choices=YOLO11_VARIANTS + ['all'],
+                        metavar='VARIANT',
+                        help=f'YOLO11 model variant(s) to prepare. Default: {DEFAULT_MODEL}. '
+                             f'One or more of: {", ".join(YOLO11_VARIANTS)}. '
+                             f"Use 'all' to prepare every supported variant. "
+                             f'Run --list-models to see all options.')
+    parser.add_argument('--link-file', type=str, default=None,
+                        help='Link file containing download URL for the .pt model '
+                             '(default: <model>.onnx.link). Ignored if more than one '
+                             '--model variant is specified.')
+    parser.add_argument('--batch-size', type=int, default=1,
+                        help='Fixed batch size (default: 1)')
+    parser.add_argument('--channels', type=int, default=3,
+                        help='Number of channels (default: 3)')
+    parser.add_argument('--height', type=int, default=640,
+                        help='Image height (default: 640)')
+    parser.add_argument('--width', type=int, default=640,
+                        help='Image width (default: 640)')
+    parser.add_argument('--force-download', action='store_true',
+                        help='Force re-download and re-conversion even if the final ONNX already exists')
+    parser.add_argument('--skip-download', action='store_true',
+                        help='Skip download and conversion; fix existing ONNX model only')
+    parser.add_argument('--no-simplifier', action='store_true',
+                        help='Skip onnx-simplifier optimization')
+    parser.add_argument('--keep-intermediate', action='store_true',
+                        help='Keep intermediate downloaded file (the temporary ONNX before shape fixing)')
+    parser.add_argument('--list-models', action='store_true',
+                        help='Print all supported model variants and their local status, then exit.')
+
+    args = parser.parse_args()
+
+    # Resolve paths
+    script_dir = Path(__file__).parent
+
+    if args.list_models:
+        list_models(script_dir)
+        sys.exit(0)
+
+    if 'all' in args.model:
+        args.model = list(YOLO11_VARIANTS)
+
+    # Resolve which variants to process. --link-file overrides the model name
+    # only when a single model was requested (matches historical behavior).
+    if args.link_file is not None:
+        if len(args.model) > 1:
+            print("Warning: --link-file is ignored when multiple --model variants are specified")
+            models_to_process = args.model
+        else:
+            models_to_process = [args.link_file.replace('.onnx.link', '')]
+    else:
+        models_to_process = args.model
+
+    _ensure_dependencies()
+
+    print(f"🚀 Processing {len(models_to_process)} model(s): {', '.join(models_to_process)}")
+    print("=" * 80)
+
+    success_count = 0
+    for model_variant in models_to_process:
+        print(f"\n🔄 Processing model: {model_variant}")
+        print("-" * 80)
+        if process_single_model(model_variant, script_dir, args):
+            success_count += 1
+        print(f"\n✅ Completed processing for {model_variant}")
+        print("=" * 80)
+
+    print(f"\n🎯 SUMMARY: Successfully processed {success_count}/{len(models_to_process)} model(s)")
+    sys.exit(0 if success_count == len(models_to_process) else 1)
+
+
+if __name__ == "__main__":
+    main()

yolo11l.onnx.link

@@ -0,0 +1 @@
+https://huggingface.co/Ultralytics/YOLO11/blob/main/yolo11l.pt -o yolo11l.onnx

yolo11l_model_config.yaml

@@ -0,0 +1,149 @@
+task_type: detection
+input_dataset: coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - center
+  pad_color:
+  - 114
+  - 114
+  - 114
+  name: image_preprocess
+session:
+  tidl_offload: true
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 0.0
+  - 0.0
+  - 0.0
+  input_scale:
+  - 0.003922
+  - 0.003922
+  - 0.003922
+  # runtime_options:
+    # advanced_options:output_feature_16bit_names_list: ''
+    # advanced_options:params_16bit_names_list: ''
+    # object_detection:meta_arch_type: 6
+  model_path: yolo11l.onnx
+  model_id: od-mh8007
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  enable_nms: 1
+  detection_nms_threshold: 0.7
+  # detection_threshold: 0.001
+  reshape_list: null
+  formatter: 
+      name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - center
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  transpose_indices: [0,2,1]
+  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]%: 53.4
+  compact_name: yolo11l-coco-640x640
+  shortlisted: true

yolo11m.onnx.link

@@ -0,0 +1 @@
+https://huggingface.co/Ultralytics/YOLO11/blob/main/yolo11m.pt -o yolo11m.onnx

yolo11m_model_config.yaml

@@ -0,0 +1,149 @@
+task_type: detection
+input_dataset: coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - center
+  pad_color:
+  - 114
+  - 114
+  - 114
+  name: image_preprocess
+session:
+  tidl_offload: true
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 0.0
+  - 0.0
+  - 0.0
+  input_scale:
+  - 0.003922
+  - 0.003922
+  - 0.003922
+  # runtime_options:
+    # advanced_options:output_feature_16bit_names_list: ''
+    # advanced_options:params_16bit_names_list: ''
+    # object_detection:meta_arch_type: 6
+  model_path: yolo11m.onnx
+  model_id: od-mh8006
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  enable_nms: 1
+  detection_nms_threshold: 0.7
+  # detection_threshold: 0.001
+  reshape_list: null
+  formatter: 
+      name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - center
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  transpose_indices: [0,2,1]
+  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.5
+  compact_name: yolo11m-coco-640x640
+  shortlisted: true

yolo11n.onnx.link

@@ -0,0 +1 @@
+https://huggingface.co/Ultralytics/YOLO11/blob/main/yolo11n.pt -o yolo11n.onnx

yolo11n_model_config.yaml

@@ -0,0 +1,149 @@
+task_type: detection
+input_dataset: coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - center
+  pad_color:
+  - 114
+  - 114
+  - 114
+  name: image_preprocess
+session:
+  tidl_offload: true
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 0.0
+  - 0.0
+  - 0.0
+  input_scale:
+  - 0.003922
+  - 0.003922
+  - 0.003922
+  # runtime_options:
+    # advanced_options:output_feature_16bit_names_list: ''
+    # advanced_options:params_16bit_names_list: ''
+    # object_detection:meta_arch_type: 6
+  model_path: yolo11n.onnx
+  model_id: od-mh8004
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  enable_nms: 1
+  detection_nms_threshold: 0.7
+  # detection_threshold: 0.001
+  reshape_list: null
+  formatter: 
+      name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - center
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  transpose_indices: [0,2,1]
+  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]%: 37.3
+  compact_name: yolo11n-coco-640x640
+  shortlisted: true

yolo11s.onnx.link

@@ -0,0 +1 @@
+https://huggingface.co/Ultralytics/YOLO11/blob/main/yolo11s.pt -o yolo11s.onnx

yolo11s_model_config.yaml

@@ -0,0 +1,149 @@
+task_type: detection
+input_dataset: coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - center
+  pad_color:
+  - 114
+  - 114
+  - 114
+  name: image_preprocess
+session:
+  tidl_offload: true
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 0.0
+  - 0.0
+  - 0.0
+  input_scale:
+  - 0.003922
+  - 0.003922
+  - 0.003922
+  # runtime_options:
+    # advanced_options:output_feature_16bit_names_list: ''
+    # advanced_options:params_16bit_names_list: ''
+    # object_detection:meta_arch_type: 6
+  model_path: yolo11s.onnx
+  model_id: od-mh8005
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  enable_nms: 1
+  detection_nms_threshold: 0.7
+  # detection_threshold: 0.001
+  reshape_list: null
+  formatter: 
+      name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - center
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  transpose_indices: [0,2,1]
+  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]%: 47.0
+  compact_name: yolo11s-coco-640x640
+  shortlisted: true

yolo11x.onnx.link

@@ -0,0 +1 @@
+https://huggingface.co/Ultralytics/YOLO11/blob/main/yolo11x.pt -o yolo11x.onnx

yolo11x_model_config.yaml

@@ -0,0 +1,149 @@
+task_type: detection
+input_dataset: coco
+preprocess:
+  resize: 640
+  crop: 640
+  data_layout: NCHW
+  reverse_channels: false
+  backend: cv2
+  interpolation: null
+  resize_with_pad:
+  - true
+  - center
+  pad_color:
+  - 114
+  - 114
+  - 114
+  name: image_preprocess
+session:
+  tidl_offload: true
+  input_optimization: false
+  input_data_layout: NCHW
+  input_mean:
+  - 0.0
+  - 0.0
+  - 0.0
+  input_scale:
+  - 0.003922
+  - 0.003922
+  - 0.003922
+  # runtime_options:
+    # advanced_options:output_feature_16bit_names_list: ''
+    # advanced_options:params_16bit_names_list: ''
+    # object_detection:meta_arch_type: 6
+  model_path: yolo11x.onnx
+  model_id: od-mh8008
+  input_details: null
+  output_details: null
+  num_inputs: 1
+postprocess:
+  enable_nms: 1
+  detection_nms_threshold: 0.7
+  # detection_threshold: 0.001
+  reshape_list: null
+  formatter: 
+      name: DetectionXYWH2XYXYCenterXY
+  resize_with_pad:
+  - true
+  - center
+  normalized_detections: false
+  shuffle_indices: null
+  squeeze_axis: null
+  ignore_index: null
+  model_output_type: combined
+  transpose_indices: [0,2,1]
+  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]%: 54.7
+  compact_name: yolo11x-coco-640x640
+  shortlisted: true