Upload 47 files

.gitattributes

@@ -38,3 +38,5 @@ ax_yolov8_pose filter=lfs diff=lfs merge=lfs -text
 football.jpg filter=lfs diff=lfs merge=lfs -text
 yolov8_pose_out.jpg filter=lfs diff=lfs merge=lfs -text
 ax_aarch64/ax_yolov8_pose filter=lfs diff=lfs merge=lfs -text
+bus.jpg filter=lfs diff=lfs merge=lfs -text
+result_yolov8_pose.jpg filter=lfs diff=lfs merge=lfs -text

AX615/yolov8l-pose_640x640_npu1.axmodel

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

AX615/yolov8l-pose_640x640_npu2.axmodel

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

AX615/yolov8m-pose_640x640_npu1.axmodel

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

AX615/yolov8m-pose_640x640_npu2.axmodel

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

AX615/yolov8n-pose_640x640_npu1.axmodel

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

AX615/yolov8n-pose_640x640_npu2.axmodel

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

AX615/yolov8s-pose_640x640_npu1.axmodel

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

AX615/yolov8s-pose_640x640_npu2.axmodel

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

AX615/yolov8x-pose_640x640_npu1.axmodel

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

AX615/yolov8x-pose_640x640_npu2.axmodel

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

AX620E/yolov8l-pose_640x640_npu1.axmodel

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

AX620E/yolov8l-pose_640x640_npu2.axmodel

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

AX620E/yolov8m-pose_640x640_npu1.axmodel

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

AX620E/yolov8m-pose_640x640_npu2.axmodel

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

AX620E/yolov8n-pose_640x640_npu1.axmodel

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

AX620E/yolov8n-pose_640x640_npu2.axmodel

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

AX620E/yolov8s-pose_640x640_npu1.axmodel

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

AX620E/yolov8s-pose_640x640_npu2.axmodel

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

AX620E/yolov8x-pose_640x640_npu1.axmodel

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

AX620E/yolov8x-pose_640x640_npu2.axmodel

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

AX637/yolov8l-pose_640x640_npu1.axmodel

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

AX637/yolov8m-pose_640x640_npu1.axmodel

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

AX637/yolov8n-pose_640x640_npu1.axmodel

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

AX637/yolov8s-pose_640x640_npu1.axmodel

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

AX637/yolov8x-pose_640x640_npu1.axmodel

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

AX650/yolov8l-pose_640x640_npu1.axmodel

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

AX650/yolov8l-pose_640x640_npu3.axmodel

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

AX650/yolov8m-pose_640x640_npu1.axmodel

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

AX650/yolov8m-pose_640x640_npu3.axmodel

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

AX650/yolov8n-pose_640x640_npu1.axmodel

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

AX650/yolov8n-pose_640x640_npu3.axmodel

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

AX650/yolov8s-pose_640x640_npu1.axmodel

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

AX650/yolov8s-pose_640x640_npu3.axmodel

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

AX650/yolov8x-pose_640x640_npu1.axmodel

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

AX650/yolov8x-pose_640x640_npu3.axmodel

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

ax_infer.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+# Usage: python ax_infer.py --model-path yolov8n-pose_640x640.axmodel --test-img bus.jpg --img-save-path result_yolov8_pose.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-Pose")
+
+
+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 decode_keypoints(kpt_preds, anchors, stride, kpt_shape=(17, 3)):
+    """
+    Decode keypoints from predictions (standard YOLOv8-Pose formula, export mode):
+        a = (y[:, :, :2] * 2.0 + (self.anchors - 0.5)) * self.strides
+        if ndim == 3:
+            a = torch.cat((a, y[:, :, 2:3].sigmoid()), 2)
+
+    Here anchors are grid indices + 0.5, so (anchors - 0.5) == grid indices.
+
+    Args:
+        kpt_preds: (N, nk) raw keypoint predictions, nk = 17 * 3 = 51
+        anchors: (N, 2) - anchor points (x, y) with offset 0.5
+        stride: scalar - stride value
+        kpt_shape: (num_keypoints, num_dims) = (17, 3)
+
+    Returns:
+        keypoints: (N, 17, 3) decoded keypoints [x, y, conf]
+    """
+    N = kpt_preds.shape[0]
+    nk = kpt_shape[0] * kpt_shape[1]  # 51
+
+    kpt_preds = kpt_preds[:, :nk]
+    kpts = kpt_preds.reshape(N, kpt_shape[0], kpt_shape[1])
+
+    anchor_x = anchors[:, 0:1]  # (N, 1)
+    anchor_y = anchors[:, 1:2]  # (N, 1)
+
+    kpts_decoded = np.zeros_like(kpts)
+    kpts_decoded[:, :, 0] = (kpts[:, :, 0] * 2.0 + (anchor_x - 0.5)) * stride
+    kpts_decoded[:, :, 1] = (kpts[:, :, 1] * 2.0 + (anchor_y - 0.5)) * stride
+
+    if kpt_shape[1] == 3:
+        kpts_decoded[:, :, 2] = 1 / (1 + np.exp(-kpts[:, :, 2]))
+
+    return kpts_decoded
+
+
+def scale_keypoints_lefttop(keypoints, scale, orig_shape):
+    """Scale keypoints from model output to original image coordinates."""
+    keypoints = keypoints.copy()
+    keypoints[..., 0] /= scale
+    keypoints[..., 1] /= scale
+    keypoints[..., 0] = np.clip(keypoints[..., 0], 0, orig_shape[1])
+    keypoints[..., 1] = np.clip(keypoints[..., 1], 0, orig_shape[0])
+    return keypoints
+
+
+def main():
+    ap = argparse.ArgumentParser(description='YOLOv8-Pose Inference (AXERARuntime)')
+    ap.add_argument('--model-path', type=str, default='yolov8n-pose_640x640.axmodel')
+    ap.add_argument('--test-img', type=str, default='bus.jpg')
+    ap.add_argument('--img-save-path', type=str, default='result_yolov8_pose.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_keypoints = []
+    kpt_shape = (17, 3)
+
+    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 outputs: 3 scales * 3 outputs per scale)
+    for scale_idx, stride in enumerate(strides):
+        box_idx = scale_idx * 3
+        cls_idx = scale_idx * 3 + 1
+        kpt_idx = scale_idx * 3 + 2
+
+        if box_idx >= len(output_items) or cls_idx >= len(output_items) or kpt_idx >= len(output_items):
+            continue
+
+        box_data, box_shape = output_items[box_idx]
+        cls_data, cls_shape = output_items[cls_idx]
+        kpt_data, kpt_shape_raw = output_items[kpt_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])
+        kpt_data = kpt_data[0].reshape(-1, kpt_shape_raw[-1])
+
+        # Get max class scores (for pose, usually nc=1)
+        if cls_data.shape[-1] == 1:
+            cls_scores = cls_data[:, 0]
+            cls_ids = np.zeros(len(cls_scores), dtype=np.int32)
+        else:
+            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_kpt = kpt_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
+
+        kpts = decode_keypoints(v_kpt, anchors, stride, kpt_shape)
+
+        for i in range(len(boxes)):
+            detections.append([*boxes[i], v_score[i], v_id[i]])
+            all_keypoints.append(kpts[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_keypoints = np.array(all_keypoints)
+
+    # 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]
+    final_kpts = all_keypoints[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)
+    final_kpts = scale_keypoints_lefttop(final_kpts, scale, (orig_h, orig_w))
+
+    kpt_color = [
+        (0, 255, 0), (0, 255, 0), (0, 255, 0), (0, 255, 0), (0, 255, 0),  # face
+        (255, 128, 0), (255, 128, 0), (255, 128, 0), (255, 128, 0), (255, 128, 0), (255, 128, 0),  # arms
+        (51, 153, 255), (51, 153, 255), (51, 153, 255), (51, 153, 255), (51, 153, 255), (51, 153, 255)  # legs
+    ]
+    limb_color = [
+        (51, 153, 255), (0, 255, 0), (255, 128, 0), (255, 153, 255), (102, 178, 255),
+        (255, 51, 51), (51, 255, 153), (255, 178, 102), (230, 230, 0), (255, 153, 204),
+        (255, 102, 255), (153, 255, 153), (255, 255, 128), (0, 255, 255), (255, 255, 0),
+        (255, 204, 153), (153, 204, 255), (255, 153, 153), (204, 153, 255)
+    ]
+    skeleton = [
+        [16, 14], [14, 12], [17, 15], [15, 13], [12, 13],
+        [6, 12], [7, 13], [6, 7],
+        [6, 8], [7, 9], [8, 10], [9, 11],
+        [2, 3], [1, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7]
+    ]
+
+    logger.info(f"\033[1;32mDraw Results ({len(final_dets)} persons): \033[0m")
+
+    for i, det in enumerate(final_dets):
+        box = det[:4].astype(int)
+        conf = det[4]
+
+        logger.info(f"({box[0]}, {box[1]}, {box[2]}, {box[3]}) -> person: {conf:.2f}")
+
+        cv2.rectangle(img, (box[0], box[1]), (box[2], box[3]), (255, 42, 4), 2)
+        cv2.putText(img, f"person {conf:.2f}", (box[0], box[1] - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 42, 4), 2)
+
+        kpt = final_kpts[i]
+
+        for sk_idx, sk in enumerate(skeleton):
+            idx1, idx2 = sk[0] - 1, sk[1] - 1
+            if idx1 < 0 or idx1 >= 17 or idx2 < 0 or idx2 >= 17:
+                continue
+            if kpt[idx1, 2] > 0.5 and kpt[idx2, 2] > 0.5:
+                pt1 = (int(kpt[idx1, 0]), int(kpt[idx1, 1]))
+                pt2 = (int(kpt[idx2, 0]), int(kpt[idx2, 1]))
+                color = limb_color[sk_idx % len(limb_color)]
+                cv2.line(img, pt1, pt2, color, 2)
+
+        for j, (x, y, conf_kpt) in enumerate(kpt):
+            if conf_kpt > 0.5:
+                color = kpt_color[j] if j < len(kpt_color) else (0, 255, 0)
+                cv2.circle(img, (int(x), int(y)), 5, color, -1)
+
+    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,98 @@
+#!/usr/bin/env python3
+import torch
+from ultralytics import YOLO
+from ultralytics.nn.modules.head import Pose
+import os
+import shutil
+
+
+def npu_pose_forward(self, x):
+    """
+    YOLOv8 Pose Head Modified for NPU.
+
+    YOLOv8 Pose structure (NOT end2end):
+        - cv2: box regression layers (DFL, out channels = 4 * reg_max = 64)
+        - cv3: classification layers (out channels = nc, nc=1 for pose)
+        - cv4: keypoint output layers (out channels = nk = 17 * 3 = 51)
+
+    Output:
+        List of Tensors (9 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=1 for pose
+          - Kpt_Raw (B, H, W, nk),         <-- raw keypoints (nk = 17*3 = 51)
+    """
+    if not isinstance(x, (list, tuple)):
+        x = [x]
+
+    res = []
+
+    box_layers = self.cv2
+    cls_layers = self.cv3
+    kpt_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. Keypoints branch (raw) - NHWC
+        kpts = kpt_layers[i](x[i]).permute(0, 2, 3, 1)
+
+        res.append(bboxes)
+        res.append(scores)
+        res.append(kpts)
+
+    return res
+
+
+def batch_export_yolov8_pose():
+    variants = ['n', 's', 'm', 'l', 'x']
+    imgsz = 640
+
+    # Execute Monkey Patch
+    Pose.forward = npu_pose_forward
+    print("Monkey patch applied for Pose: Output Layout forced to NHWC (Box, Cls, Kpt for each scale).")
+
+    for v in variants:
+        model_name = f"yolov8{v}-pose"
+        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
+            Pose.forward = npu_pose_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, Pose):
+                    head.forward = lambda x: npu_pose_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_pose()

onnx_infer.py

@@ -0,0 +1,356 @@
+#!/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 decode_keypoints(kpt_preds, anchors, stride, kpt_shape=(17, 3)):
+    """
+    Decode keypoints from predictions.
+
+    IMPORTANT: This is the standard YOLOv8-Pose formula (export mode):
+        a = (y[:, :, :2] * 2.0 + (self.anchors - 0.5)) * self.strides
+        if ndim == 3:
+            a = torch.cat((a, y[:, :, 2:3].sigmoid()), 2)
+
+    Note: YOLOv8 multiplies keypoint offsets by 2.0 and uses (anchors - 0.5).
+    Here anchors are grid indices + 0.5, so (anchors - 0.5) == grid indices.
+
+    Args:
+        kpt_preds: (N, nk) raw keypoint predictions, nk = 17 * 3 = 51
+        anchors: (N, 2) - anchor points (x, y) with offset 0.5
+        stride: scalar - stride value
+        kpt_shape: (num_keypoints, num_dims) = (17, 3)
+
+    Returns:
+        keypoints: (N, 17, 3) decoded keypoints [x, y, conf]
+    """
+    N = kpt_preds.shape[0]
+    nk = kpt_shape[0] * kpt_shape[1]  # 51
+
+    kpt_preds = kpt_preds[:, :nk]
+    kpts = kpt_preds.reshape(N, kpt_shape[0], kpt_shape[1])
+
+    anchor_x = anchors[:, 0:1]  # (N, 1)
+    anchor_y = anchors[:, 1:2]  # (N, 1)
+
+    kpts_decoded = np.zeros_like(kpts)
+    kpts_decoded[:, :, 0] = (kpts[:, :, 0] * 2.0 + (anchor_x - 0.5)) * stride
+    kpts_decoded[:, :, 1] = (kpts[:, :, 1] * 2.0 + (anchor_y - 0.5)) * stride
+
+    # Apply sigmoid to confidence
+    if kpt_shape[1] == 3:
+        kpts_decoded[:, :, 2] = 1 / (1 + np.exp(-kpts[:, :, 2]))
+
+    return kpts_decoded
+
+
+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 scale_keypoints_lefttop(keypoints, scale, orig_shape):
+    """Scale keypoints from model output to original image coordinates."""
+    keypoints = keypoints.copy()
+    keypoints[..., 0] /= scale
+    keypoints[..., 1] /= scale
+    keypoints[..., 0] = np.clip(keypoints[..., 0], 0, orig_shape[1])
+    keypoints[..., 1] = np.clip(keypoints[..., 1], 0, orig_shape[0])
+    return keypoints
+
+
+def main():
+    parser = argparse.ArgumentParser(description='YOLOv8-Pose ONNX Inference')
+    parser.add_argument('-m', '--model', type=str, default='yolov8n-pose_640x640.onnx',
+                        dest='model_path', help='Path to YOLOv8-Pose *.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_pose.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])
+
+    # Get metadata
+    metadata = session.get_modelmeta().custom_metadata_map
+    kpt_shape = eval(metadata.get('kpt_shape', '[17, 3]')) if metadata else [17, 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 = []
+    all_keypoints = []
+
+    # Process each scale
+    for scale_idx, stride in enumerate(strides):
+        grid_size = imgsz[0] // stride
+
+        box_idx = scale_idx * 3
+        cls_idx = scale_idx * 3 + 1
+        kpt_idx = scale_idx * 3 + 2
+
+        if box_idx >= len(outputs) or cls_idx >= len(outputs) or kpt_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)
+        kpt_data = outputs[kpt_idx]  # (1, H, W, nk)
+
+        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])
+        kpt_data = kpt_data[0].reshape(-1, kpt_data.shape[-1])
+
+        # Get max class scores
+        if cls_data.shape[-1] == 1:
+            cls_scores = cls_data[:, 0]
+            cls_ids = np.zeros(len(cls_scores), dtype=np.int32)
+        else:
+            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]
+        v_kpt = kpt_data[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)
+
+        # Decode keypoints
+        kpts = decode_keypoints(v_kpt, anchors, stride, tuple(kpt_shape))
+
+        # Store detections
+        for i in range(len(boxes)):
+            detections.append([*boxes[i], v_score[i], v_id[i]])
+            all_keypoints.append(kpts[i])
+
+    if len(detections) == 0:
+        print("No detections found.")
+        cv2.imwrite(opt.img_save_path, img0)
+        return
+
+    detections = np.array(detections)
+    all_keypoints = np.array(all_keypoints)
+
+    # 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]
+    all_keypoints = all_keypoints[indices]
+
+    # Scale to original image
+    detections[:, :4] = scale_boxes_lefttop(detections[:, :4], scale, orig_shape)
+    all_keypoints = scale_keypoints_lefttop(all_keypoints, scale, orig_shape)
+
+    # Keypoint colors: green for face, orange for arms, blue for legs
+    kpt_color = [
+        (0, 255, 0), (0, 255, 0), (0, 255, 0), (0, 255, 0), (0, 255, 0),  # face
+        (255, 128, 0), (255, 128, 0), (255, 128, 0), (255, 128, 0), (255, 128, 0), (255, 128, 0),  # arms
+        (51, 153, 255), (51, 153, 255), (51, 153, 255), (51, 153, 255), (51, 153, 255), (51, 153, 255)  # legs
+    ]
+    limb_color = [
+        (51, 153, 255), (0, 255, 0), (255, 128, 0), (255, 153, 255), (102, 178, 255),
+        (255, 51, 51), (51, 255, 153), (255, 178, 102), (230, 230, 0), (255, 153, 204),
+        (255, 102, 255), (153, 255, 153), (255, 255, 128), (0, 255, 255), (255, 255, 0),
+        (255, 204, 153), (153, 204, 255), (255, 153, 153), (204, 153, 255)
+    ]
+
+    # Draw results
+    for i, det in enumerate(detections):
+        box = det[:4].astype(int)
+        conf = det[4]
+
+        cv2.rectangle(img0, (box[0], box[1]), (box[2], box[3]), (255, 42, 4), 2)
+        cv2.putText(img0, f"person {conf:.2f}", (box[0], box[1] - 10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 42, 4), 2)
+
+        # COCO skeleton (1-based indices)
+        skeleton = [
+            [16, 14], [14, 12], [17, 15], [15, 13], [12, 13],  # legs
+            [6, 12], [7, 13], [6, 7],  # torso
+            [6, 8], [7, 9], [8, 10], [9, 11],  # arms
+            [2, 3], [1, 2], [1, 3], [2, 4], [3, 5], [4, 6], [5, 7]  # face
+        ]
+
+        kpt = all_keypoints[i]
+
+        for sk_idx, sk in enumerate(skeleton):
+            idx1, idx2 = sk[0] - 1, sk[1] - 1
+            if idx1 < 0 or idx1 >= 17 or idx2 < 0 or idx2 >= 17:
+                continue
+            if kpt[idx1, 2] > 0.5 and kpt[idx2, 2] > 0.5:
+                pt1 = (int(kpt[idx1, 0]), int(kpt[idx1, 1]))
+                pt2 = (int(kpt[idx2, 0]), int(kpt[idx2, 1]))
+                color = limb_color[sk_idx % len(limb_color)]
+                cv2.line(img0, pt1, pt2, color, 2)
+
+        for j, (x, y, conf_kpt) in enumerate(kpt):
+            if conf_kpt > 0.5:
+                color = kpt_color[j] if j < len(kpt_color) else (0, 255, 0)
+                cv2.circle(img0, (int(x), int(y)), 5, color, -1)
+
+    cv2.imwrite(opt.img_save_path, img0)
+    print(f"Done! Found {len(detections)} persons. Result saved to {opt.img_save_path}")
+
+
+if __name__ == "__main__":
+    main()

yolov8l-pose_640x640.onnx

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

yolov8m-pose_640x640.onnx

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

yolov8n-pose_640x640.onnx

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

yolov8s-pose_640x640.onnx

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

yolov8x-pose_640x640.onnx

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