Upload 43 files

.gitattributes

@@ -44,3 +44,5 @@ axcl_aarch64/axcl_yolov8 filter=lfs diff=lfs merge=lfs -text
 axcl_x86_64/axcl_yolov8 filter=lfs diff=lfs merge=lfs -text
 yolov8_axcl_out.jpg filter=lfs diff=lfs merge=lfs -text
 *.axmodel filter=lfs diff=lfs merge=lfs -text
+bus.jpg filter=lfs diff=lfs merge=lfs -text
+result_yolov8_det.jpg filter=lfs diff=lfs merge=lfs -text

AX615/yolov8m_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:318f485b377273c2d9107ff5869f58b0c01fe6343afee56afd9ae792d856c335
+size 28682377

AX615/yolov8m_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7b70f750bd5d9dcda95c7ad28f5176d8f7752ce2384c1c7d0b0ba0200b02f2eb
+size 26630729

AX615/yolov8n_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34f90d2d742214630ee1034a487cd4d4fdd61be31cda3fbddf818b86d4113be7
+size 3670985

AX615/yolov8n_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d71eae7f16a7358c6b2f182f0d1c695c5a2cf1f48eae9b1a8dee3c322621299d
+size 3397645

AX615/yolov8s_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8158f466b2cb8e8aebdc35cf27ceb55792b2d32c4d2f25a72568c7805a760ab
+size 12468873

AX615/yolov8s_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:794c436981a263431461f5b4c969ed613fea06c584f2977c7f5d4d984abd3640
+size 11503501

AX620E/yolov8l_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31a202c34e0f9feb6e9c5395d10115271a59944507465d42a46fdd4abbb30b59
+size 50315789

AX620E/yolov8l_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:985cd993878a0786b9b9625972f109273e0557bbd4d02e14eac4903d54c13678
+size 44955325

AX620E/yolov8m_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87ef023288128267d9de1ab0f685d475a54e801e213ef2400d2b3f315f7f3120
+size 29841021

AX620E/yolov8m_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d55dcf21bdcfbfc5571afb10894484cfbd2b1142fe97432b1ea23d9966468a89
+size 26738901

AX620E/yolov8n_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87d1d0029203056c9372bca4da68a396e2bf71914263ae8a3712668e1ef03d60
+size 3810681

AX620E/yolov8n_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb40333377b7f3444ce53fd9382d7d1d3a3e36bd87536614378bd2101a5218c5
+size 3424381

AX620E/yolov8s_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf2c4a73878be48aafb01316029b32043844b71408afc36329cf6d36e67c63c6
+size 12639153

AX620E/yolov8s_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56ff92fb5c14d73c58e9d2f0573c04bf1c5e47cfe5b11ac316c3412aae19dfe8
+size 11529925

AX620E/yolov8x_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:664668e09033507a78d4185ef7a1de670959bca9e17dbfd6aa21aa730d33ffb4
+size 80537453

AX620E/yolov8x_640x640_npu2.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7a9ef5096de6fa6a8acc3fcb7fe10c7872ae58aadcafb73da7f9c2f03f2a45e
+size 70628301

AX637/yolov8l_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1bdff37d0c432d3b73215a7da9777742bfb25e24eeb7cffc0ea1a6eeb7b8883
+size 44417625

AX637/yolov8m_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf9e5ce79d61fbf4586f77794132be4dff296d2410348f337b0569ba2dd9fa9d
+size 26311565

AX637/yolov8n_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3829468bd86c4f5bcf1595df7e1ebdf827ff5a824962745dccbd64a41237329e
+size 3629097

AX637/yolov8s_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c818a96de1f8f921fe98388949dd4b5cdac559fd0e588aa43c87fa960bd78ed0
+size 11394521

AX637/yolov8x_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:120d6e1ba59ab9b7eb835ada8e2f6c658cd3b133a591098f1201d653d8da0dff
+size 69938665

AX650/yolov8l_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:077fd62f40e710c680e5dfaf3865ee32196818695a5b1d39d764b2f79b2df366
+size 45101257

AX650/yolov8l_640x640_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd19e855fffc6237d1e99e06cabd98b64448131ae0b6fa502ffee9f424d31e2c
+size 45526493

AX650/yolov8m_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23583617c0c630a248feb7f27fd0b219c41ae373e2bb2d3b5ba06b022492c128
+size 26735549

AX650/yolov8m_640x640_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da0ba156916b0ac626ab588f5de845f7c13692cbd5c6f5df8bf2d45bdfac2101
+size 27064817

AX650/yolov8n_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d1be0d0b0fcdbf6b0c6b097b124b51653c2c8347129beab519c59586cf42a87
+size 3443549

AX650/yolov8n_640x640_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5563cc868a98e9ee051cb9941844be934c55cd5a37264d10bff534dd613e86b
+size 3700265

AX650/yolov8s_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aab82f706f0dec0a6e4244813ab1883d2b1291e348800437a488f1de23c2a905
+size 11616925

AX650/yolov8s_640x640_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f112959508faa56c2d7b9a17e7ba48b9a0967bc95fb499cfc47993ce099fb0ce
+size 11860681

AX650/yolov8x_640x640_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c13a043ea5ab6cd939841ce4aba4c071120df0b703ab5b185da34cfc398a7beb
+size 70652329

AX650/yolov8x_640x640_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c951cd2f7406c8f175010f64dbecdfafe3cc07d97065d026414622458a9fe7c
+size 71141277

ax_infer.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# Usage: python ax_infer.py --model-path yolov8n_640x640.axmodel --test-img bus.jpg --img-save-path result_yolov8_det.jpg --score-thres 0.25 --nms-thres 0.7 --providers AxEngineExecutionProvider
+import os
+import cv2
+import numpy as np
+from time import time
+import argparse
+import logging
+import axengine as ort
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='[%(name)s] [%(asctime)s.%(msecs)03d] [%(levelname)s] %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger("YOLOv8-Det")
+
+
+def infer_hw_layout(shape):
+    """Infer input height, width and layout from model input shape."""
+    shape = list(shape)
+    if len(shape) == 4 and shape[-1] == 3:
+        h = int(shape[1] or 640)
+        w = int(shape[2] or 640)
+        return h, w, "NHWC"
+    if len(shape) == 4 and shape[1] == 3:
+        h = int(shape[2] or 640)
+        w = int(shape[3] or 640)
+        return h, w, "NCHW"
+    return 640, 640, "NCHW"
+
+
+def softmax(x, axis=-1):
+    """Compute softmax along axis."""
+    e_x = np.exp(x - np.max(x, axis=axis, keepdims=True))
+    return e_x / np.sum(e_x, axis=axis, keepdims=True)
+
+
+def dfl_decode(box_pred, reg_max=16):
+    """Decode DFL (Distribution Focal Loss) box predictions to ltrb distances."""
+    N = box_pred.shape[0]
+    box_pred = box_pred.reshape(N, 4, reg_max)
+    box_pred = softmax(box_pred, axis=-1)
+    proj = np.arange(reg_max, dtype=np.float32)
+    return np.sum(box_pred * proj, axis=-1)  # (N, 4)
+
+
+def main():
+    ap = argparse.ArgumentParser(description='YOLOv8-Det Inference (AXERARuntime)')
+    ap.add_argument('--model-path', type=str, default='yolov8n_640x640.axmodel')
+    ap.add_argument('--test-img', type=str, default='bus.jpg')
+    ap.add_argument('--img-save-path', type=str, default='result_yolov8_det.jpg')
+    ap.add_argument('--score-thres', type=float, default=0.25)
+    ap.add_argument('--nms-thres', type=float, default=0.7)
+    ap.add_argument('--providers', type=str, default='AxEngineExecutionProvider')
+    opt = ap.parse_args()
+
+    if not os.path.exists(opt.model_path):
+        logger.error(f"Model not found: {opt.model_path}")
+        return
+
+    t0 = time()
+    providers = [p.strip() for p in opt.providers.split(",") if p.strip()] or None
+    sess = ort.InferenceSession(opt.model_path, providers=providers)
+    logger.debug(f"\033[1;31mLoad model time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    inp = sess.get_inputs()[0]
+    input_name = inp.name
+    m_h, m_w, layout = infer_hw_layout(inp.shape)
+
+    img = cv2.imread(opt.test_img)
+    if img is None:
+        logger.error(f"Image not found or unreadable: {opt.test_img}")
+        return
+
+    # Preprocess
+    t0 = time()
+    orig_h, orig_w = img.shape[:2]
+    scale = min(m_h / orig_h, m_w / orig_w)
+    new_w, new_h = int(orig_w * scale), int(orig_h * scale)
+
+    resized = cv2.resize(img, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+    padded = cv2.copyMakeBorder(
+        resized, 0, m_h - new_h, 0, m_w - new_w,
+        cv2.BORDER_CONSTANT, value=(127, 127, 127)
+    )
+    rgb = cv2.cvtColor(padded, cv2.COLOR_BGR2RGB)
+    input_tensor = rgb[None, ...].astype(np.uint8) if layout == "NHWC" else np.transpose(rgb, (2, 0, 1))[None, ...].astype(np.uint8)
+    logger.debug(f"\033[1;31mPre-process time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    # Inference
+    t0 = time()
+    ort_outputs = sess.run(None, {input_name: input_tensor})
+    out_metas = sess.get_outputs()
+    logger.debug(f"\033[1;31mForward time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    # Post-process
+    t0 = time()
+    strides = (8, 16, 32)
+    conf_raw = -np.log(1 / opt.score_thres - 1)
+    detections = []
+
+    output_items = []
+    for meta, data in zip(out_metas, ort_outputs):
+        shape = list(meta.shape)
+        if any(s is None or isinstance(s, str) for s in shape):
+            shape = list(data.shape)
+        output_items.append((data, shape))
+
+    # Process each scale (6 outputs: 2 outputs per scale [box, cls])
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 2
+        cls_idx = scale_idx * 2 + 1
+
+        if box_idx >= len(output_items) or cls_idx >= len(output_items):
+            continue
+
+        box_data, box_shape = output_items[box_idx]
+        cls_data, cls_shape = output_items[cls_idx]
+
+        H, W = box_shape[1], box_shape[2]
+        box_channels = box_shape[-1]
+
+        # Determine if DFL is used (YOLOv8: 4*reg_max = 64)
+        reg_max = None
+        if box_channels > 4 and box_channels % 4 == 0:
+            reg_max = box_channels // 4
+
+        box_data = box_data[0].reshape(-1, box_channels)
+        cls_data = cls_data[0].reshape(-1, cls_shape[-1])
+
+        # Get max class scores
+        cls_scores = np.max(cls_data, axis=1)
+        cls_ids = np.argmax(cls_data, axis=1)
+
+        valid_mask = cls_scores >= conf_raw
+        if not np.any(valid_mask):
+            continue
+
+        v_box = box_data[valid_mask]
+        v_score = 1 / (1 + np.exp(-cls_scores[valid_mask]))
+        v_id = cls_ids[valid_mask]
+
+        gy, gx = np.indices((H, W))
+        anchors = np.stack((gx.ravel(), gy.ravel()), axis=-1).astype(np.float32) + 0.5
+        anchors = anchors[valid_mask]
+
+        # Decode boxes (DFL -> ltrb -> xyxy)
+        if reg_max is not None:
+            v_box = dfl_decode(v_box, reg_max)
+        lt = v_box[:, :2]
+        rb = v_box[:, 2:]
+        x1y1 = anchors - lt
+        x2y2 = anchors + rb
+        boxes = np.hstack([x1y1, x2y2]) * stride
+
+        for i in range(len(boxes)):
+            detections.append([*boxes[i], v_score[i], v_id[i]])
+
+    logger.debug(f"\033[1;31mPost-process time = {(time() - t0) * 1000:.2f} ms\033[0m")
+
+    if len(detections) == 0:
+        logger.info("No detections found.")
+        cv2.imwrite(opt.img_save_path, img)
+        return
+
+    detections = np.array(detections)
+
+    # NMS
+    xywh = detections[:, :4].copy()
+    xywh[:, 2] = xywh[:, 2] - xywh[:, 0]  # w
+    xywh[:, 3] = xywh[:, 3] - xywh[:, 1]  # h
+
+    indices = cv2.dnn.NMSBoxes(xywh.tolist(), detections[:, 4].tolist(), opt.score_thres, opt.nms_thres)
+
+    if len(indices) == 0:
+        logger.info("No detections after NMS.")
+        cv2.imwrite(opt.img_save_path, img)
+        return
+
+    indices = indices.flatten()
+    final_dets = detections[indices]
+
+    # Scale to original image coordinates
+    final_dets[:, :4] = final_dets[:, :4] / scale
+    final_dets[:, [0, 2]] = np.clip(final_dets[:, [0, 2]], 0, orig_w)
+    final_dets[:, [1, 3]] = np.clip(final_dets[:, [1, 3]], 0, orig_h)
+
+    # COCO class names
+    coco_names = [
+        "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
+        "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
+        "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
+        "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
+        "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
+        "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
+        "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard",
+        "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+        "scissors", "teddy bear", "hair drier", "toothbrush"
+    ]
+
+    base_colors = [
+        (255, 42, 4), (235, 219, 11), (243, 243, 243), (183, 223, 0), (104, 31, 17),
+        (221, 111, 255), (79, 68, 255), (0, 237, 204), (68, 243, 0), (255, 0, 189),
+        (255, 180, 0), (186, 0, 221), (255, 255, 0), (0, 192, 38), (179, 255, 1),
+        (255, 36, 125), (104, 0, 123), (108, 27, 255), (47, 109, 252), (11, 255, 162),
+    ]
+
+    logger.info(f"\033[1;32mDraw Results ({len(final_dets)} objects): \033[0m")
+
+    for det in final_dets:
+        box = det[:4].astype(int)
+        conf = det[4]
+        cls_id = int(det[5])
+        color = [int(c) for c in base_colors[cls_id % len(base_colors)]]
+        cls_name = coco_names[cls_id] if cls_id < len(coco_names) else str(cls_id)
+
+        logger.info(f"({box[0]}, {box[1]}, {box[2]}, {box[3]}) -> {cls_name}: {conf:.2f}")
+
+        cv2.rectangle(img, (box[0], box[1]), (box[2], box[3]), color, 2)
+        label = f"{cls_name} {conf:.2f}"
+        cv2.putText(img, label, (box[0], box[1] - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+    cv2.imwrite(opt.img_save_path, img)
+    logger.info(f"Saved to {opt.img_save_path}")
+
+
+if __name__ == "__main__":
+    main()

coco_1000.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3e18a198658270e19ced079de7a404e3478e69c2ef94fb47c87ddf056e6a541
+size 163112960

config.json

@@ -0,0 +1,32 @@
+{
+  "model_type": "ONNX",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "images",
+        "calibration_dataset": "./coco_1000.tar",
+        "calibration_size": 32,
+        "calibration_mean": [0, 0, 0],
+        "calibration_std": [255.0, 255.0, 255.0]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "precision_analysis_method":"EndToEnd"
+  },
+  "input_processors": [
+    {
+      "tensor_name": "images",
+      "tensor_format": "BGR",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NHWC"
+    }
+  ],
+  "output_processors": [
+  ],
+  "compiler": {
+    "check": 0
+  }
+}

export_onnx.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+import torch
+from ultralytics import YOLO
+from ultralytics.nn.modules.head import Detect
+import os
+import shutil
+
+
+def npu_detect_forward(self, x):
+    """
+    YOLOv8 Detect Head Modified for NPU.
+
+    YOLOv8 Detect structure (NOT end2end):
+        - cv2: box regression layers (DFL, out channels = 4 * reg_max = 64)
+        - cv3: classification layers (out channels = nc, nc=80 for COCO)
+
+    Output:
+        List of Tensors (6 items for 3 scales), Layout: NHWC.
+        For each scale:
+          - Box_Raw (B, H, W, 4*reg_max),  <-- raw DFL box logits (decode in post-process)
+          - Cls_Raw (B, H, W, nc),         <-- class scores (raw logits), nc=80
+    """
+    if not isinstance(x, (list, tuple)):
+        x = [x]
+
+    res = []
+
+    box_layers = self.cv2
+    cls_layers = self.cv3
+
+    for i in range(self.nl):
+        # 1. Box branch (raw DFL logits) - NHWC
+        bboxes = box_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        # 2. Cls branch (raw logits) - NHWC
+        scores = cls_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        res.append(bboxes)
+        res.append(scores)
+
+    return res
+
+
+def batch_export_yolov8_det():
+    variants = ['n', 's', 'm', 'l', 'x']
+    imgsz = 640
+
+    # Execute Monkey Patch
+    Detect.forward = npu_detect_forward
+    print("Monkey patch applied for Detect: Output Layout forced to NHWC (Box, Cls for each scale).")
+
+    for v in variants:
+        model_name = f"yolov8{v}"
+        pt_path = f"{model_name}.pt"
+        onnx_final_name = f"{model_name}_640x640.onnx"
+        print(f"\n--- Processing {model_name} ---")
+        try:
+            # Load model
+            model = YOLO(pt_path)
+
+            # Reapply monkey patch
+            Detect.forward = npu_detect_forward
+
+            # Ensure the model's head also uses the new forward
+            if hasattr(model.model, 'model') and len(model.model.model) > 0:
+                head = model.model.model[-1]
+                if isinstance(head, Detect):
+                    head.forward = lambda x: npu_detect_forward(head, x)
+
+            # Execute export
+            exported_path = model.export(
+                format="onnx",
+                imgsz=imgsz,
+                dynamic=False,
+                opset=11,
+                simplify=True,
+                nms=False
+            )
+
+            # Move and rename
+            if exported_path:
+                shutil.move(exported_path, onnx_final_name)
+                print(f"Success: {onnx_final_name}")
+        except Exception as e:
+            print(f"Failed to export {model_name}: {e}")
+            import traceback
+            traceback.print_exc()
+
+
+if __name__ == "__main__":
+    batch_export_yolov8_det()

onnx_infer.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+import onnxruntime as ort
+import cv2
+import numpy as np
+import argparse
+import os
+
+
+def preprocess_image(image, input_size=(640, 640)):
+    """
+    Preprocess image with left-top aligned letterbox (same as official YOLO).
+
+    Args:
+        image: BGR image (H, W, C)
+        input_size: (height, width) target size
+
+    Returns:
+        input_tensor: (1, 3, H, W) float32 tensor normalized to [0, 1]
+        scale: scale ratio used for resizing
+        original_shape: (orig_h, orig_w) original image shape
+    """
+    orig_h, orig_w = image.shape[:2]
+    m_h, m_w = input_size
+
+    # Calculate scale (keep aspect ratio)
+    scale = min(m_h / orig_h, m_w / orig_w)
+
+    # Resize
+    new_w, new_h = int(orig_w * scale), int(orig_h * scale)
+    img_resized = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
+
+    # Pad to target size (left-top aligned)
+    input_bgr = cv2.copyMakeBorder(
+        img_resized, 0, m_h - new_h, 0, m_w - new_w,
+        cv2.BORDER_CONSTANT, value=(114, 114, 114)
+    )
+
+    # BGR -> RGB, normalize to [0, 1]
+    input_rgb = cv2.cvtColor(input_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+
+    # HWC -> CHW, add batch dimension
+    input_tensor = np.transpose(input_rgb, (2, 0, 1))[None, ...]
+
+    return input_tensor, scale, (orig_h, orig_w)
+
+
+def softmax(x, axis=-1):
+    """Compute softmax along axis."""
+    e_x = np.exp(x - np.max(x, axis=axis, keepdims=True))
+    return e_x / np.sum(e_x, axis=axis, keepdims=True)
+
+
+def dfl_decode(box_pred, reg_max=16):
+    """
+    Decode DFL (Distribution Focal Loss) box predictions.
+
+    Args:
+        box_pred: (N, 4 * reg_max) raw box predictions
+        reg_max: number of DFL bins
+
+    Returns:
+        (N, 4) decoded ltrb distances
+    """
+    N = box_pred.shape[0]
+    box_pred = box_pred.reshape(N, 4, reg_max)
+    box_pred = softmax(box_pred, axis=-1)
+    proj = np.arange(reg_max, dtype=np.float32)
+    return np.sum(box_pred * proj, axis=-1)  # (N, 4)
+
+
+def decode_bboxes(bbox_preds, anchors, stride, reg_max=None):
+    """
+    Decode bounding boxes from predictions.
+
+    Args:
+        bbox_preds: (N, 4) or (N, 4*reg_max) - distance predictions in ltrb format
+        anchors: (N, 2) - anchor points (x, y) with offset 0.5
+        stride: scalar - stride value
+        reg_max: if not None, apply DFL decoding first
+
+    Returns:
+        boxes: (N, 4) in xyxy format
+    """
+    if reg_max is not None and bbox_preds.shape[-1] == 4 * reg_max:
+        bbox_preds = dfl_decode(bbox_preds, reg_max)
+
+    # dist2bbox: ltrb to xyxy
+    lt = bbox_preds[:, :2]  # left, top
+    rb = bbox_preds[:, 2:]  # right, bottom
+
+    x1y1 = anchors - lt
+    x2y2 = anchors + rb
+
+    boxes = np.hstack([x1y1, x2y2]) * stride
+    return boxes
+
+
+def scale_boxes_lefttop(boxes, scale, orig_shape):
+    """Scale boxes from model output to original image coordinates."""
+    boxes = boxes.copy()
+    boxes[..., :4] /= scale
+    boxes[..., [0, 2]] = np.clip(boxes[..., [0, 2]], 0, orig_shape[1])
+    boxes[..., [1, 3]] = np.clip(boxes[..., [1, 3]], 0, orig_shape[0])
+    return boxes
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YOLOv8-Det ONNX Inference')
+    parser.add_argument('-m', '--model', type=str, default='yolov8n_640x640.onnx',
+                        dest='model_path', help='Path to YOLOv8 Detection *.onnx Model.')
+    parser.add_argument('-i', '--img', type=str, default='bus.jpg',
+                        dest='test_img', help='Path to Test Image.')
+    parser.add_argument('-o', '--output', type=str, default='result_yolov8_det.jpg',
+                        dest='img_save_path', help='Path to Save Result Image.')
+    parser.add_argument('--score-thres', type=float, default=0.25,
+                        help='Confidence threshold.')
+    parser.add_argument('--nms-thres', type=float, default=0.7,
+                        help='IoU threshold for NMS.')
+    opt = parser.parse_args()
+
+    if not os.path.exists(opt.model_path):
+        print(f"Error: Model not found: {opt.model_path}")
+        return
+
+    if not os.path.exists(opt.test_img):
+        print(f"Error: Image not found: {opt.test_img}")
+        return
+
+    # Load ONNX model
+    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+    try:
+        session = ort.InferenceSession(opt.model_path, providers=providers)
+    except:
+        session = ort.InferenceSession(opt.model_path, providers=['CPUExecutionProvider'])
+
+    input_name = session.get_inputs()[0].name
+    output_names = [o.name for o in session.get_outputs()]
+    input_shape = session.get_inputs()[0].shape
+    imgsz = (input_shape[2], input_shape[3])
+
+    # Load image
+    img0 = cv2.imread(opt.test_img)
+    if img0 is None:
+        print(f"Error: Cannot read image: {opt.test_img}")
+        return
+
+    # Preprocess
+    img, scale, orig_shape = preprocess_image(img0.copy(), imgsz)
+
+    # Inference
+    outputs = session.run(output_names, {input_name: img})
+
+    # Post-process
+    strides = [8, 16, 32]
+    conf_raw = -np.log(1 / opt.score_thres - 1)
+    detections = []
+
+    # Process each scale (6 outputs: 2 outputs per scale [box, cls])
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 2
+        cls_idx = scale_idx * 2 + 1
+
+        if box_idx >= len(outputs) or cls_idx >= len(outputs):
+            continue
+
+        box_data = outputs[box_idx]  # (1, H, W, C) where C = 4 or 4*reg_max
+        cls_data = outputs[cls_idx]  # (1, H, W, nc)
+
+        H, W = box_data.shape[1:3]
+        box_channels = box_data.shape[-1]
+
+        # Determine if DFL is used (YOLOv8: 4*reg_max = 64)
+        reg_max = None
+        if box_channels > 4 and box_channels % 4 == 0:
+            reg_max = box_channels // 4
+
+        # Reshape to (H*W, ...)
+        box_data = box_data[0].reshape(-1, box_channels)
+        cls_data = cls_data[0].reshape(-1, cls_data.shape[-1])
+
+        # Get max class scores
+        cls_scores = np.max(cls_data, axis=1)
+        cls_ids = np.argmax(cls_data, axis=1)
+
+        # Filter by confidence (on raw logits)
+        valid_mask = cls_scores >= conf_raw
+        if not np.any(valid_mask):
+            continue
+
+        v_box = box_data[valid_mask]
+        v_score = 1 / (1 + np.exp(-cls_scores[valid_mask]))
+        v_id = cls_ids[valid_mask]
+
+        # Generate anchors for this scale (grid indices + 0.5)
+        gy, gx = np.indices((H, W))
+        anchors = np.stack((gx.ravel(), gy.ravel()), axis=-1).astype(np.float32) + 0.5
+        anchors = anchors[valid_mask]
+
+        # Decode boxes
+        boxes = decode_bboxes(v_box, anchors, stride, reg_max)
+
+        # Store detections
+        for i in range(len(boxes)):
+            detections.append([*boxes[i], v_score[i], v_id[i]])
+
+    if len(detections) == 0:
+        print("No detections found.")
+        cv2.imwrite(opt.img_save_path, img0)
+        return
+
+    detections = np.array(detections)
+
+    # NMS
+    xywh = detections[:, :4].copy()
+    xywh[:, 2] = xywh[:, 2] - xywh[:, 0]  # w
+    xywh[:, 3] = xywh[:, 3] - xywh[:, 1]  # h
+
+    indices = cv2.dnn.NMSBoxes(xywh.tolist(), detections[:, 4].tolist(), opt.score_thres, opt.nms_thres)
+
+    if len(indices) == 0:
+        print("No detections after NMS.")
+        cv2.imwrite(opt.img_save_path, img0)
+        return
+
+    indices = indices.flatten()
+    detections = detections[indices]
+
+    # Scale to original image
+    detections[:, :4] = scale_boxes_lefttop(detections[:, :4], scale, orig_shape)
+
+    # COCO class names
+    coco_names = [
+        "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat", "traffic light",
+        "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog", "horse", "sheep", "cow",
+        "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
+        "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove", "skateboard", "surfboard",
+        "tennis racket", "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple",
+        "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
+        "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote", "keyboard",
+        "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book", "clock", "vase",
+        "scissors", "teddy bear", "hair drier", "toothbrush"
+    ]
+
+    # Official Ultralytics colors (BGR format)
+    base_colors = [
+        (255, 42, 4), (235, 219, 11), (243, 243, 243), (183, 223, 0), (104, 31, 17),
+        (221, 111, 255), (79, 68, 255), (0, 237, 204), (68, 243, 0), (255, 0, 189),
+        (255, 180, 0), (186, 0, 221), (255, 255, 0), (0, 192, 38), (179, 255, 1),
+        (255, 36, 125), (104, 0, 123), (108, 27, 255), (47, 109, 252), (11, 255, 162),
+    ]
+
+    for det in detections:
+        box = det[:4].astype(int)
+        conf = det[4]
+        cls_id = int(det[5])
+        color = [int(c) for c in base_colors[cls_id % len(base_colors)]]
+        cls_name = coco_names[cls_id] if cls_id < len(coco_names) else str(cls_id)
+
+        cv2.rectangle(img0, (box[0], box[1]), (box[2], box[3]), color, 2)
+        label = f"{cls_name} {conf:.2f}"
+        cv2.putText(img0, label, (box[0], box[1] - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+
+    cv2.imwrite(opt.img_save_path, img0)
+    print(f"Done! Found {len(detections)} objects. Result saved to {opt.img_save_path}")
+
+
+if __name__ == "__main__":
+    main()

yolov8l_640x640.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:848ed042b6aae973feef19605808fb964a60ef13e032e1010a54a772c4364332
+size 174782655

yolov8m_640x640.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61fae246d49e5a395d8ddd694a7212cdbcf2be76a2f97d1d80fc011a333e6207
+size 103631997

yolov8n_640x640.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e006d4f9b2b77b0b1846cf8104f9de620419dfa3ab63d651426ab25e50444aa
+size 12673498

yolov8s_640x640.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dcda830f3390e95453076524f56b074cd201ec0044e797a84ed2304a4fe3ec7
+size 44692292

yolov8x_640x640.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a5ef92546eabe7794d0d9f10f6cdea7f84e27a993f667b1d8e47f19810650bd
+size 272911938