新建一个python文件，命名自定义即可，用于模型转换以及导出：

# 导入必要的库

import time          # 用于计时，评估推理性能

import numpy as np   # 用于数值计算和数组操作

import cv2           # 用于图像处理和可视化

import aidlite       # 用于模型加载和推理加速（特定硬件加速库）

import argparse      # 用于解析命令行参数

# --------------------- COCO‑17 骨架拓扑与颜色配置 ---------------------

# COCO-17数据集的人体关键点连接关系，定义了17个关键点之间的骨架结构

SKELETON = [

    (15, 13), (13, 11), (16, 14), (14, 12), (11, 12),  # 腿部和胯部连接

    (5, 11),  (6, 12),  (5, 6),   (5, 7),   (6, 8),    # 躯干和肩部连接

    (7, 9),   (8, 10),  (1, 2),   (0, 1),   (0, 2),    # 手臂和头部连接

    (1, 3),   (2, 4),   (3, 5),   (4, 6)             # 手部和身体连接

]

# 可视化元素的颜色配置（BGR格式，OpenCV默认使用BGR）

COLORS = {

    "bbox": (0, 255, 0),   # 检测框颜色：绿色

    "kpt":  (0, 0, 255),   # 关键点颜色：红色

    "link": (255, 0, 0)    # 骨架连接线颜色：蓝色

}

# ----------------------------- 工具函数定义 -----------------------------

def iou_xyxy(box1, box2):

    """

    计算两个边界框的交并比（IoU）

    输入格式：两个边界框均为[x1, y1, x2, y2]，其中(x1,y1)为左上角坐标，(x2,y2)为右下角坐标

    返回值：IoU值（0-1之间）

    """

    # 计算交集区域的左上角和右下角坐标

    xa, ya = max(box1[0], box2[0]), max(box1[1], box2[1])  # 交集左上角

    xb, yb = min(box1[2], box2[2]), min(box1[3], box2[3])  # 交集右下角

   

    # 计算交集面积（如果交集区域无效则为0）

    inter = max(0, xb - xa) * max(0, yb - ya)

   

    # 计算两个边界框的面积

    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])  # 第一个框面积

    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])  # 第二个框面积

   

    # 计算IoU = 交集面积 / (两个框面积之和 - 交集面积)，加1e-6避免除零

    return inter / (area1 + area2 - inter + 1e-6)

def nms(dets, confs, iou_thres):

    """

    非极大值抑制（NMS）算法，用于去除重叠度过高的检测框

    参数：

        dets: 边界框列表，格式为[[x1,y1,x2,y2], ...]

        confs: 每个边界框对应的置信度列表

        iou_thres: IoU阈值，超过此阈值的框会被抑制

    返回值：保留的边界框索引列表

    """

    # 按置信度从高到低排序，获取排序后的索引

    idxs = np.argsort(-confs)

    keep = []  # 用于存储保留的框索引

   

    while idxs.size > 0:

        # 保留当前置信度最高的框

        i = idxs[0]

        keep.append(i)

       

        # 如果只剩一个框，直接退出循环

        if idxs.size == 1:

            break

       

        # 计算当前框与其他所有框的IoU

        ious = np.array([iou_xyxy(dets[i], dets[j]) for j in idxs[1:]])

       

        # 只保留IoU小于阈值的框的索引

        idxs = idxs[1:][ious < iou_thres]

   

    return keep

def scale_coords(coords, ratio):

    """

    将模型输出的归一化坐标（0-640范围）缩放回原始图像尺寸

    参数：

        coords: 需要缩放的坐标（可以是边界框或关键点坐标）

        ratio: 缩放比例（原始图像最长边 / 640）

    返回值：缩放后的坐标

    """

    return coords * ratio

def draw_pose(img, bbox, kpts, kpt_thr=0.3):

    """

    在图像上绘制检测框、关键点和骨架连接线

    参数：

        img: 原始图像（用于绘制的画布）

        bbox: 边界框坐标，格式为[x1,y1,x2,y2]

        kpts: 关键点坐标及置信度，格式为[[x1,y1,s1], [x2,y2,s2], ...]

              其中s为关键点的置信度分数

        kpt_thr: 关键点置信度阈值，低于此值的关键点不绘制

    """

    # 绘制边界框

    x1, y1, x2, y2 = map(int, bbox)  # 将坐标转换为整数

    cv2.rectangle(img, (x1, y1), (x2, y2), COLORS["bbox"], 2)  # 绘制矩形框

    # 绘制关键点

    for x, y, s in kpts:

        if s < kpt_thr:  # 跳过置信度低的关键点

            continue

        # 绘制红色圆点（半径3，填充）

        cv2.circle(img, (int(x), int(y)), 3, COLORS["kpt"], -1)

    # 绘制骨架连接线

    for a, b in SKELETON:

        # 检查两个关键点的置信度是否都高于阈值

        if kpts[a][2] < kpt_thr or kpts[b][2] < kpt_thr:

            continue

        # 获取两个关键点的坐标

        xa, ya = int(kpts[a][0]), int(kpts[a][1])

        xb, yb = int(kpts[b][0]), int(kpts[b][1])

        # 绘制蓝色连接线

        cv2.line(img, (xa, ya), (xb, yb), COLORS["link"], 2)

# ----------------------------- 主函数 -----------------------------

def main(args):

    """

    主函数：加载模型、处理图像、执行推理、后处理并可视化结果

    参数：args为命令行解析得到的参数对象

    """

    print("Start image inference ... ...")

    size = 640  # 模型输入图像的固定分辨率（宽度和高度均为640）

    # ---------- 1. 创建模型配置 & 解释器 ----------

    # 创建aidlite配置实例

    config = aidlite.Config.create_instance()

    if config is None:

        print("Create config failed !")

        return False

    # 配置模型运行参数

    config.implement_type = aidlite.ImplementType.TYPE_LOCAL  # 本地运行模式

    # 根据模型类型选择框架（QNN或SNPE2）

    if args.model_type.lower() == "qnn":

        config.framework_type = aidlite.FrameworkType.TYPE_QNN231

    elif args.model_type.lower() in ("snpe2", "snpe"):

        config.framework_type = aidlite.FrameworkType.TYPE_SNPE2

    config.accelerate_type  = aidlite.AccelerateType.TYPE_DSP  # 使用DSP加速

    config.is_quantify_model = 1  # 标记为量化模型

    # 加载模型文件

    model = aidlite.Model.create_instance(args.target_model)

    if model is None:

        print("Create model failed !")

        return False

    # 设置模型输入输出形状

    input_shapes  = [[1, size, size, 3]]  # 输入形状：[批次大小, 高度, 宽度, 通道数]

    # 输出形状：分别对应关键点、置信度、边界框

    output_shapes = [[1, 51, 8400], [1, 1, 8400], [1, 4, 8400]]

    model.set_model_properties(

        input_shapes,

        aidlite.DataType.TYPE_FLOAT32,  # 输入数据类型：32位浮点数

        output_shapes,

        aidlite.DataType.TYPE_FLOAT32   # 输出数据类型：32位浮点数

    )

    # 创建并初始化解释器

    interpreter = aidlite.InterpreterBuilder.build_interpretper_from_model_and_config(model, config)

    # 检查解释器初始化和模型加载是否成功

    if interpreter is None or interpreter.init() != 0 or interpreter.load_model() != 0:

        print("Interpreter init/load failed !")

        return False

    print("detect model load success!")

    # ---------- 2. 读取并预处理图像 ----------

    # 读取输入图像

    img = cv2.imread(args.image_path)

    if img is None:

        print("Error: Could not open image file")

        return False

    h0, w0 = img.shape[:2]  # 获取原始图像的高度和宽度

    length = max(h0, w0)    # 取高度和宽度中的最大值（用于保持宽高比）

    ratio  = length / size  # 计算缩放比例（用于后续将模型输出映射回原图）

    # 创建正方形画布（避免拉伸图像），将原图放置在画布左上角

    canvas = np.zeros((length, length, 3), np.uint8)  # 黑色背景画布

    canvas[0:h0, 0:w0] = img  # 将原图复制到画布

    # 图像预处理：转换颜色空间、调整大小、归一化

    img_in = cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB)  # BGR转RGB（模型输入要求）

    img_in = cv2.resize(img_in, (size, size))         # 调整为模型输入尺寸640x640

    img_in = img_in.astype(np.float32) / 255.0        # 归一化到0-1范围

    # ---------- 3. 模型预热 ----------

    # 执行3次推理预热，避免首次推理耗时过长影响性能评估

    for _ in range(3):

        interpreter.set_input_tensor(0, img_in.data)  # 设置输入张量

        interpreter.invoke()                          # 执行推理

    # ---------- 4. 推理性能测试 ----------

    invoke_nums = 100  # 测试迭代次数

    invoke_times = []  # 存储每次推理耗时（毫秒）

    print(f"Running performance test with {invoke_nums} iterations...")

   

    for i in range(invoke_nums):

        # 设置输入张量

        interpreter.set_input_tensor(0, img_in.data)

        # 记录推理开始时间

        t1 = time.time()

        # 执行推理

        result = interpreter.invoke()

        # 记录推理结束时间

        t2 = time.time()

       

        # 检查推理是否成功

        if result != 0:

            print("interpreter invoke() failed")

            return False

       

        # 计算推理耗时（转换为毫秒）并存储

        invoke_time = (t2 - t1) * 1000

        invoke_times.append(invoke_time)

       

        # 每10次迭代打印一次进度

        if (i + 1) % 10 == 0:

            print(f"Completed {i + 1}/{invoke_nums} iterations")

    # 计算性能统计指标

    mean_invoke_time = np.mean(invoke_times)  # 平均耗时

    max_invoke_time = np.max(invoke_times)    # 最大耗时

    min_invoke_time = np.min(invoke_times)    # 最小耗时

    var_invoke_time = np.var(invoke_times)    # 方差（反映耗时稳定性）

    fps = 1000 / mean_invoke_time             # 计算每秒帧率（FPS）

   

    # 打印性能测试结果

    print(f"\nInference {invoke_nums} times:\n"

          f"-- mean_invoke_time is {mean_invoke_time:.2f} ms\n"

          f"-- max_invoke_time is {max_invoke_time:.2f} ms\n"

          f"-- min_invoke_time is {min_invoke_time:.2f} ms\n"

          f"-- var_invoke_time is {var_invoke_time:.2f}\n"

          f"-- FPS: {fps:.2f}\n")

   

    # ---------- 5. 获取模型输出 ----------

    # 提取输出张量并调整形状

    # 关键点输出：17个关键点×3（x,y,置信度）=51，共8400个检测框

    qnn_local = interpreter.get_output_tensor(0).reshape(1, 51, 8400)

    # 置信度输出：每个检测框的置信度，共8400个

    qnn_conf  = interpreter.get_output_tensor(1).reshape(1, 1, 8400)

    # 边界框输出：每个框的4个坐标值（cx,cy,w,h），共8400个

    qnn_bbox  = interpreter.get_output_tensor(2).reshape(1, 4, 8400)

    # 合并输出：将关键点、置信度、边界框合并为一个数组

    pred = np.concatenate((qnn_local, qnn_conf, qnn_bbox), axis=1)  # 形状变为(1,56,8400)

    pred = pred.transpose(0, 2, 1)[0]                               # 调整为(8400,56)，即8400个检测框，每个56维特征

    # ---------- 6. 后处理（过滤和筛选有效检测结果） ----------

    # 提取每个检测框的置信度（第51列）

    confs = pred[:, 51]

    # 根据置信度阈值过滤检测框（只保留置信度高于阈值的）

    mask  = confs > args.conf_thres

    if not np.any(mask):  # 如果没有符合条件的检测框

        print("No objects found.")

        interpreter.destory()  # 销毁解释器释放资源

        return True

    # 应用过滤 mask

    pred  = pred[mask]    # 过滤后的检测框特征

    confs = confs[mask]   # 过滤后的置信度

    # 将边界框格式从[cx, cy, w, h]转换为[x1, y1, x2, y2]

    b = pred[:, 52:56]  # 提取边界框参数（cx, cy, w, h）

    boxes_xyxy = np.empty_like(b)  # 创建相同形状的数组存储转换后的坐标

    boxes_xyxy[:, 0] = b[:, 0] - b[:, 2] / 2  # 计算左上角x

    boxes_xyxy[:, 1] = b[:, 1] - b[:, 3] / 2  # 计算左上角y

    boxes_xyxy[:, 2] = b[:, 0] + b[:, 2] / 2  # 计算右下角x

    boxes_xyxy[:, 3] = b[:, 1] + b[:, 3] / 2  # 计算右下角y

    # 应用非极大值抑制（NMS）去除重叠框

    keep = nms(boxes_xyxy, confs, args.iou_thres)

    boxes_xyxy = boxes_xyxy[keep]  # 保留的边界框

    # 提取并调整关键点形状：[-1, 51] → [-1, 17, 3]（17个关键点，每个含x,y,置信度）

    kpts = pred[keep, :51].reshape(-1, 17, 3)

    # ---------- 7. 可视化结果 ----------

    out_img = img.copy()  # 复制原图用于绘制（避免修改原图）

    # 遍历每个保留的检测结果，绘制到图像上

    for box, kp in zip(boxes_xyxy, kpts):

        # 将边界框和关键点坐标缩放回原始图像尺寸

        box_scaled = scale_coords(box, ratio)

        kp_scaled  = scale_coords(kp[:, :2], ratio)  # 只缩放x,y坐标

        # 合并缩放后的坐标和原始置信度

        kp_vis = np.concatenate([kp_scaled, kp[:, 2:3]], axis=1)

        # 绘制检测框、关键点和骨架

        draw_pose(out_img, box_scaled, kp_vis, kpt_thr=0.25)

    # 保存结果图像（注释了显示图像的代码，适合服务器环境）

    # cv2.imshow("YOLOv11‑pose Result", out_img)

    cv2.imwrite("result1111.jpg", out_img)

    print("Result saved to result11.jpg")

    # cv2.waitKey(0)

    # 销毁解释器，释放资源

    interpreter.destory()

    return True

# --------------------------- 命令行参数解析 ---------------------------

def parser_args():

    """

    解析命令行参数

    返回值：解析后的参数对象

    """

    parser = argparse.ArgumentParser(description="Run image inference with YOLOv11‑pose")

    # 模型文件路径

    parser.add_argument('--target_model', type=str,

                        default='yolov11n_pose/cutoff_yolo11n-pose_qcs8550_w8a8.qnn231.ctx.bin',

                        help="Path to model binary")

    # 输入图像路径

    parser.add_argument('--image_path', type=str, default='bus.jpg', help="Input image path")

    # 模型框架类型（QNN或SNPE2）

    parser.add_argument('--model_type', type=str, default='QNN', help="Backend: QNN / SNPE2")

    # 置信度阈值

    parser.add_argument('--conf_thres', type=float, default=0.25, help="Confidence threshold")

    # NMS的IoU阈值

    parser.add_argument('--iou_thres',  type=float, default=0.45, help="NMS IoU threshold")

    return parser.parse_args()

# ----------------------------- 程序入口 -----------------------------

if __name__ == "__main__":

    # 解析命令行参数

    args = parser_args()

    # 执行主函数

    main(args)