Upload 47 files

.gitattributes

@@ -42,3 +42,5 @@ axcl_aarch64/axcl_yolov8_seg filter=lfs diff=lfs merge=lfs -text
 yolov8_seg_axcl_out.jpg filter=lfs diff=lfs merge=lfs -text
 axcl_x86_64/axcl_yolov8_seg 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_seg.jpg filter=lfs diff=lfs merge=lfs -text

AX615/yolov8l-seg_640x640_npu1.axmodel

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

AX615/yolov8l-seg_640x640_npu2.axmodel

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

AX615/yolov8m-seg_640x640_npu1.axmodel

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

AX615/yolov8m-seg_640x640_npu2.axmodel

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

AX615/yolov8n-seg_640x640_npu1.axmodel

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

AX615/yolov8n-seg_640x640_npu2.axmodel

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

AX615/yolov8s-seg_640x640_npu1.axmodel

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

AX615/yolov8s-seg_640x640_npu2.axmodel

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

AX615/yolov8x-seg_640x640_npu1.axmodel

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

AX615/yolov8x-seg_640x640_npu2.axmodel

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

AX620E/yolov8l-seg_640x640_npu1.axmodel

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

AX620E/yolov8l-seg_640x640_npu2.axmodel

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

AX620E/yolov8m-seg_640x640_npu1.axmodel

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

AX620E/yolov8m-seg_640x640_npu2.axmodel

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

AX620E/yolov8n-seg_640x640_npu1.axmodel

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

AX620E/yolov8n-seg_640x640_npu2.axmodel

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

AX620E/yolov8s-seg_640x640_npu1.axmodel

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

AX620E/yolov8s-seg_640x640_npu2.axmodel

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

AX620E/yolov8x-seg_640x640_npu1.axmodel

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

AX620E/yolov8x-seg_640x640_npu2.axmodel

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

AX637/yolov8l-seg_640x640_npu1.axmodel

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

AX637/yolov8m-seg_640x640_npu1.axmodel

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

AX637/yolov8n-seg_640x640_npu1.axmodel

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

AX637/yolov8s-seg_640x640_npu1.axmodel

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

AX637/yolov8x-seg_640x640_npu1.axmodel

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

AX650/yolov8l-seg_640x640_npu1.axmodel

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

AX650/yolov8l-seg_640x640_npu3.axmodel

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

AX650/yolov8m-seg_640x640_npu1.axmodel

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

AX650/yolov8m-seg_640x640_npu3.axmodel

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

AX650/yolov8n-seg_640x640_npu1.axmodel

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

AX650/yolov8n-seg_640x640_npu3.axmodel

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

AX650/yolov8s-seg_640x640_npu1.axmodel

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

AX650/yolov8s-seg_640x640_npu3.axmodel

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

AX650/yolov8x-seg_640x640_npu1.axmodel

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

AX650/yolov8x-seg_640x640_npu3.axmodel

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

ax_infer.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+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-Seg")
+
+
+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 process_mask(protos, mask_coeffs, boxes, model_shape, orig_shape, scale):
+    """
+    Process masks from prototypes and coefficients.
+
+    Args:
+        protos: (nm, proto_h, proto_w) mask prototypes
+        mask_coeffs: (N, nm) mask coefficients
+        boxes: (N, 4) boxes in model coordinates (xyxy)
+        model_shape: (h, w) model input shape
+        orig_shape: (h, w) original image shape
+        scale: preprocessing scale factor
+
+    Returns:
+        masks: (N, orig_h, orig_w) binary masks
+    """
+    nm, proto_h, proto_w = protos.shape
+    N = len(mask_coeffs)
+
+    if N == 0:
+        return np.zeros((0, orig_shape[0], orig_shape[1]), dtype=np.uint8)
+
+    masks = (mask_coeffs @ protos.reshape(nm, -1)).reshape(N, proto_h, proto_w)
+    masks = 1 / (1 + np.exp(-masks))
+
+    width_ratio = proto_w / model_shape[1]
+    height_ratio = proto_h / model_shape[0]
+    boxes_proto = boxes.copy()
+    boxes_proto[:, [0, 2]] *= width_ratio
+    boxes_proto[:, [1, 3]] *= height_ratio
+
+    for i, (x1, y1, x2, y2) in enumerate(boxes_proto.astype(int)):
+        x1, y1 = max(0, x1), max(0, y1)
+        x2, y2 = min(proto_w, x2), min(proto_h, y2)
+        masks[i, :y1, :] = 0
+        masks[i, y2:, :] = 0
+        masks[i, :, :x1] = 0
+        masks[i, :, x2:] = 0
+
+    masks_upsampled = np.zeros((N, model_shape[0], model_shape[1]), dtype=np.float32)
+    for i in range(N):
+        masks_upsampled[i] = cv2.resize(masks[i], (model_shape[1], model_shape[0]),
+                                        interpolation=cv2.INTER_LINEAR)
+
+    new_h = int(orig_shape[0] * scale)
+    new_w = int(orig_shape[1] * scale)
+    masks_cropped = masks_upsampled[:, :new_h, :new_w]
+
+    masks_final = np.zeros((N, orig_shape[0], orig_shape[1]), dtype=np.uint8)
+    for i in range(N):
+        mask_resized = cv2.resize(masks_cropped[i], (orig_shape[1], orig_shape[0]),
+                                  interpolation=cv2.INTER_LINEAR)
+        masks_final[i] = (mask_resized > 0.5).astype(np.uint8)
+
+    return masks_final
+
+
+def main():
+    ap = argparse.ArgumentParser(description='YOLOv8-Seg Inference (AXERARuntime)')
+    ap.add_argument('--model-path', type=str, default='yolov8n-seg_640x640.axmodel')
+    ap.add_argument('--test-img', type=str, default='bus.jpg')
+    ap.add_argument('--img-save-path', type=str, default='result_yolov8_seg.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 = []
+    all_mask_coeffs = []
+
+    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 (9 detection outputs + 1 proto = 10 total)
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 3
+        cls_idx = scale_idx * 3 + 1
+        mask_idx = scale_idx * 3 + 2
+
+        if box_idx >= len(output_items) or cls_idx >= len(output_items) or mask_idx >= len(output_items):
+            continue
+
+        box_data, box_shape = output_items[box_idx]
+        cls_data, cls_shape = output_items[cls_idx]
+        mask_data, mask_shape = output_items[mask_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])
+        mask_data = mask_data[0].reshape(-1, mask_shape[-1])
+
+        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]
+        v_mask = mask_data[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]])
+            all_mask_coeffs.append(v_mask[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)
+    all_mask_coeffs = np.array(all_mask_coeffs)
+
+    # NMS
+    xywh = detections[:, :4].copy()
+    xywh[:, 2] = xywh[:, 2] - xywh[:, 0]
+    xywh[:, 3] = xywh[:, 3] - xywh[:, 1]
+
+    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()
+    detections = detections[indices]
+    all_mask_coeffs = all_mask_coeffs[indices]
+
+    # Get proto output (last output)
+    proto = ort_outputs[-1][0]  # (nm, proto_h, proto_w)
+    logger.debug(f"Proto shape: {proto.shape}")
+
+    # Process masks (before scaling boxes!)
+    boxes_model = detections[:, :4].copy()
+    masks = process_mask(proto, all_mask_coeffs, boxes_model, (m_h, m_w), (orig_h, orig_w), scale)
+
+    # Scale boxes to original image coordinates
+    detections[:, :4] = detections[:, :4] / scale
+    detections[:, [0, 2]] = np.clip(detections[:, [0, 2]], 0, orig_w)
+    detections[:, [1, 3]] = np.clip(detections[:, [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(detections)} objects): \033[0m")
+
+    for i, det in enumerate(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)
+
+        logger.info(f"({box[0]}, {box[1]}, {box[2]}, {box[3]}) -> {cls_name}: {conf:.2f}")
+
+        if i < len(masks):
+            mask = masks[i]
+            mask_colored = np.zeros_like(img)
+            mask_colored[mask > 0] = color
+            img = cv2.addWeighted(img, 1.0, mask_colored, 0.5, 0)
+
+        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,111 @@
+#!/usr/bin/env python3
+import torch
+from ultralytics import YOLO
+from ultralytics.nn.modules.head import Segment
+import os
+import shutil
+
+
+def npu_segment_forward(self, x):
+    """
+    YOLOv8 Segment Head Modified for NPU.
+
+    YOLOv8 Segment structure (NOT end2end):
+        - cv2: box regression layers (DFL, out channels = 4 * reg_max = 64)
+        - cv3: classification layers (out channels = nc = 80)
+        - cv4: mask coefficient layers (out channels = nm = 32)
+        - proto: Proto module for generating mask prototypes
+
+    Output:
+        List of Tensors (10 items: 3 scales * 3 outputs + 1 proto), NHWC for detection, NCHW for proto
+        [
+          Scale1_Box_Raw (B, 80, 80, 4*reg_max),  <-- raw DFL box logits
+          Scale1_Cls_Raw (B, 80, 80, nc),         <-- class scores (raw logits), nc=80
+          Scale1_Mask_Raw (B, 80, 80, nm),        <-- mask coefficients, nm=32
+          Scale2_Box_Raw (B, 40, 40, 4*reg_max),
+          Scale2_Cls_Raw (B, 40, 40, nc),
+          Scale2_Mask_Raw (B, 40, 40, nm),
+          Scale3_Box_Raw (B, 20, 20, 4*reg_max),
+          Scale3_Cls_Raw (B, 20, 20, nc),
+          Scale3_Mask_Raw (B, 20, 20, nm),
+          Proto (B, nm, H, W),                     <-- mask prototypes (160x160 for 640 input)
+        ]
+    """
+    if not isinstance(x, (list, tuple)):
+        x = [x]
+
+    res = []
+
+    box_layers = self.cv2
+    cls_layers = self.cv3
+    mask_layers = self.cv4
+
+    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)
+
+        # 3. Mask coefficients branch - NHWC
+        masks = mask_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        res.append(bboxes)
+        res.append(scores)
+        res.append(masks)
+
+    # 4. Proto output - NCHW (keep original format for mask processing)
+    proto = self.proto(x[0])
+    res.append(proto)
+
+    return res
+
+
+def batch_export_yolov8_seg():
+    variants = ['n', 's', 'm', 'l', 'x']
+    imgsz = 640
+
+    # Execute Monkey Patch
+    Segment.forward = npu_segment_forward
+    print("Monkey patch applied for Segment: Output Layout forced to NHWC + Proto.")
+
+    for v in variants:
+        model_name = f"yolov8{v}-seg"
+        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
+            Segment.forward = npu_segment_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, Segment):
+                    head.forward = lambda x: npu_segment_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_seg()

onnx_infer.py

@@ -0,0 +1,313 @@
+#!/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).
+    """
+    orig_h, orig_w = image.shape[:2]
+    m_h, m_w = input_size
+
+    scale = min(m_h / orig_h, m_w / orig_w)
+    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)
+
+    # Left-top aligned padding
+    input_bgr = cv2.copyMakeBorder(
+        img_resized, 0, m_h - new_h, 0, m_w - new_w,
+        cv2.BORDER_CONSTANT, value=(114, 114, 114)
+    )
+
+    input_rgb = cv2.cvtColor(input_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    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 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 decode_bboxes(bbox_preds, anchors, stride, reg_max=None):
+    """Decode bounding boxes. If reg_max given and channels match, apply DFL first."""
+    if reg_max is not None and bbox_preds.shape[-1] == 4 * reg_max:
+        bbox_preds = dfl_decode(bbox_preds, reg_max)
+    lt = bbox_preds[:, :2]
+    rb = bbox_preds[:, 2:]
+    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 (left-top aligned)."""
+    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 process_mask(protos, mask_coeffs, boxes, model_shape, orig_shape, scale):
+    """
+    Process masks from prototypes and coefficients.
+
+    Args:
+        protos: (nm, proto_h, proto_w) mask prototypes
+        mask_coeffs: (N, nm) mask coefficients
+        boxes: (N, 4) boxes in model coordinates (xyxy)
+        model_shape: (h, w) model input shape
+        orig_shape: (h, w) original image shape
+        scale: preprocessing scale factor
+
+    Returns:
+        masks: (N, orig_h, orig_w) binary masks
+    """
+    nm, proto_h, proto_w = protos.shape
+    N = len(mask_coeffs)
+
+    if N == 0:
+        return np.zeros((0, orig_shape[0], orig_shape[1]), dtype=np.uint8)
+
+    # Compute masks: (N, nm) @ (nm, proto_h*proto_w) -> (N, proto_h, proto_w)
+    masks = (mask_coeffs @ protos.reshape(nm, -1)).reshape(N, proto_h, proto_w)
+    # Sigmoid activation
+    masks = 1 / (1 + np.exp(-masks))
+
+    # Scale boxes to proto coordinates
+    width_ratio = proto_w / model_shape[1]
+    height_ratio = proto_h / model_shape[0]
+    boxes_proto = boxes.copy()
+    boxes_proto[:, [0, 2]] *= width_ratio
+    boxes_proto[:, [1, 3]] *= height_ratio
+
+    # Crop masks to bounding box regions
+    for i, (x1, y1, x2, y2) in enumerate(boxes_proto.astype(int)):
+        x1, y1 = max(0, x1), max(0, y1)
+        x2, y2 = min(proto_w, x2), min(proto_h, y2)
+        masks[i, :y1, :] = 0
+        masks[i, y2:, :] = 0
+        masks[i, :, :x1] = 0
+        masks[i, :, x2:] = 0
+
+    # Upsample masks to model input size
+    masks_upsampled = np.zeros((N, model_shape[0], model_shape[1]), dtype=np.float32)
+    for i in range(N):
+        masks_upsampled[i] = cv2.resize(masks[i], (model_shape[1], model_shape[0]),
+                                        interpolation=cv2.INTER_LINEAR)
+
+    # Crop to valid region (left-top aligned) and resize to original
+    new_h = int(orig_shape[0] * scale)
+    new_w = int(orig_shape[1] * scale)
+    masks_cropped = masks_upsampled[:, :new_h, :new_w]
+
+    # Resize to original image size
+    masks_final = np.zeros((N, orig_shape[0], orig_shape[1]), dtype=np.uint8)
+    for i in range(N):
+        mask_resized = cv2.resize(masks_cropped[i], (orig_shape[1], orig_shape[0]),
+                                  interpolation=cv2.INTER_LINEAR)
+        masks_final[i] = (mask_resized > 0.5).astype(np.uint8)
+
+    return masks_final
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YOLOv8-Seg ONNX Inference')
+    parser.add_argument('-m', '--model', type=str, default='yolov8n-seg_640x640.onnx',
+                        dest='model_path', help='Path to YOLOv8-Seg *.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_seg.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})
+
+    # Parse outputs: 9 detection outputs + 1 proto
+    strides = [8, 16, 32]
+    conf_raw = -np.log(1 / opt.score_thres - 1)
+    detections = []
+    all_mask_coeffs = []
+
+    # Process each scale
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 3
+        cls_idx = scale_idx * 3 + 1
+        mask_idx = scale_idx * 3 + 2
+
+        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)
+        mask_data = outputs[mask_idx]  # (1, H, W, nm)
+
+        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
+        box_data = box_data[0].reshape(-1, box_channels)
+        cls_data = cls_data[0].reshape(-1, cls_data.shape[-1])
+        mask_data = mask_data[0].reshape(-1, mask_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
+        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]
+        v_mask = mask_data[valid_mask]
+
+        # Generate anchors
+        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]])
+            all_mask_coeffs.append(v_mask[i])
+
+    if len(detections) == 0:
+        print("No detections found.")
+        cv2.imwrite(opt.img_save_path, img0)
+        return
+
+    detections = np.array(detections)
+    all_mask_coeffs = np.array(all_mask_coeffs)
+
+    # NMS
+    xywh = detections[:, :4].copy()
+    xywh[:, 2] = xywh[:, 2] - xywh[:, 0]
+    xywh[:, 3] = xywh[:, 3] - xywh[:, 1]
+
+    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]
+    all_mask_coeffs = all_mask_coeffs[indices]
+
+    # Get proto output (last output)
+    proto = outputs[-1][0]  # (nm, proto_h, proto_w)
+
+    # Process masks (before scaling boxes!)
+    boxes_model = detections[:, :4].copy()
+    masks = process_mask(proto, all_mask_coeffs, boxes_model, imgsz, orig_shape, scale)
+
+    # Scale boxes 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 i, det in enumerate(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)
+
+        # Draw mask
+        if i < len(masks):
+            mask = masks[i]
+            mask_colored = np.zeros_like(img0)
+            mask_colored[mask > 0] = color
+            img0 = cv2.addWeighted(img0, 1.0, mask_colored, 0.5, 0)
+
+        # Draw box
+        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-seg_640x640.onnx

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

yolov8m-seg_640x640.onnx

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

yolov8n-seg_640x640.onnx

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

yolov8s-seg_640x640.onnx

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

yolov8x-seg_640x640.onnx

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