yolov5在pc上正常，一上开发板就跑飞

Viewed 15
linux_rtos k230

问题描述

如标题，我的yolov5是从官方模型用工具剪枝的，原模型，剪枝模型，转为onnx和kmodel后的模型在pc端全都能正常使用，在开发板端就不行了，没找到明显的问题（也有可能是resize问题，但我确实不知道怎么改），可能是我对官方工具的理解有些出入，请大佬帮忙看看

硬件板卡

k230_canmv_v3

软件版本

rtos+linux

复现步骤

代码在主体就发不出来
void Model::preprocess(uintptr_t vaddr, uintptr_t paddr)
{
// input tensor
dims_t in_shape{1,720,1280,3};
auto in_tensor = host_runtime_tensor::create(dt_uint8, in_shape, { (gsl::byte *)vaddr, compute_size(in_shape) },false,hrt::pool_shared,paddr).expect("cannot create input tensor");
hrt::sync(in_tensor, sync_op_t::sync_write_back, true).expect("write back input failed");
// output tensor
dims_t out_shape=interp_.input_shape(0);
printf("kmodel:%dx%dx%dx%d\n",kmodel_shape[0],kmodel_shape[1],kmodel_shape[2],kmodel_shape[3]);
printf("shape:%dx%dx%dx%d\n",out_shape[0],out_shape[1],out_shape[2],out_shape[3]);
// config ai2d
ai2d_datatype_t ai2d_dtype { ai2d_format::RGB_packed, ai2d_format::NCHW_FMT, dt_uint8,dt_float32};//在头文件里找到相似定义（simple_types）
ai2d_crop_param_t crop_param { false, 0, 0, 720,1280};//横向裁减2/3,false了，美使用
ai2d_shift_param_t shift_param { false, 0 };
ai2d_pad_param_t pad_param { true, { { 0, 0 }, { 0, 0 }, { 70, 70 }, { 0, 0 } }, ai2d_pad_mode::constant, { 114,114,114 } };//pad模式常数
ai2d_resize_param_t resize_param { true, ai2d_interp_method::tf_bilinear, ai2d_interp_mode::half_pixel};
ai2d_affine_param_t affine_param { false};

// run
ai2d_builder builder { in_shape, out_shape, ai2d_dtype, crop_param, shift_param, pad_param, resize_param, affine_param };
auto start = std::chrono::steady_clock::now();
builder.build_schedule().expect("error occurred in ai2d build_schedule");
builder.invoke(in_tensor, ai2d_out_tensor_).expect("error occurred in ai2d invoke");
auto stop = std::chrono::steady_clock::now();
double duration = std::chrono::duration<double, std::milli>(stop - start).count();
std::cout << "ai2d run: duration = " << duration << " ms, fps = " << 1000 / duration << std::endl;

return;

}
int Model::run(uintptr_t vaddr, uintptr_t paddr)
{
preprocess(vaddr, paddr);
kpu_run();
return postprocess();
}
// ==================== NMS后处理 ====================

int Model::nms_filter(const float* model_output, float conf_threshold, float iou_threshold)
{
static int n=0;
// 直接写文件，最简版
FILE *fp = fopen("out.txt", "a");
fprintf(fp,"第%d次\n",n++);
for (int i = 0; i < 6300; i++) {
for (int j = 0; j < 7; j++) {
fprintf(fp, "%.6f ", model_output[i * 7 + j]);
}
fprintf(fp, "\t\n");
}
fclose(fp);
const int num_boxes = 6300; // 固定总框数
const int num_classes = 2; // 固定2分类
int valid_boxes[num_boxes]; // 存储有效框索引
int stride[num_boxes];
int num_valid = 0;
float x=0,y=0,w=0,h=0;
float max_conf=0,conf=0,max_conf_o=0;
float conf_i=0,conf_j=0;
k_vo_draw_frame frame{false,0,0,0,0,0};
int class_id=0;
//清除框（便顺序了）
for(int n=0;n<16;n++)
{
frame.draw_en=false;
frame.frame_num=n;
int ret=kd_mpi_vo_draw_frame(&frame);
if(ret)
{
printf("clear triangle error!!!\n");
}
}
// ====================== 1. 筛选有效框（置信度过滤） ======================
for (int i = 0; i < num_boxes; i++)
{
max_conf = 0;
// 6300×7结构：[x,y,w,h,conf,cls0,cls1]

    conf = model_output[i * 7 + 4];
    if (conf > max_conf)
        max_conf = conf;
    // 低于阈值跳过
    if (max_conf < conf_threshold)
        continue;

    valid_boxes[num_valid++] = i;
    
}
printf("num_valid:%d\n",num_valid);
if (num_valid <= 0)
    return 0;

for (int i = 0; i < num_valid - 1; i++)
{
int idx_i = valid_boxes[i];
// 只用第5个值作为置信度
float score_i = model_output[idx_i * 7 + 4];

for (int j = i + 1; j < num_valid; j++)
{
    int idx_j = valid_boxes[j];
    // 只用第5个值作为置信度
    float score_j = model_output[idx_j * 7 + 4];

    // 降序：分数小的往后排
    if (score_i < score_j)
    {
        // 交换 box 索引
        swap_float(valid_boxes[i], valid_boxes[j]);
        // 同时更新 score_i
        swap_float(score_i, score_j);
    }
}

}
// ====================== 3. NMS 抑制 ======================
int removed[num_valid];
for (int i = 0; i < num_valid; i++)
removed[i] = 0;

int keep_count = 0;

for (int i = 0; i < num_valid; i++)
{
    if (removed[i])
        continue;

    keep_count++;
    int a_idx = valid_boxes[i];

    float ax = model_output[a_idx * 7 + 0];
    float ay = model_output[a_idx * 7 + 1];
    float aw = model_output[a_idx * 7 + 2];
    float ah = model_output[a_idx * 7 + 3];

    float a_x1 = ax - aw * 0.5f;
    float a_y1 = ay - ah * 0.5f;
    float a_x2 = ax + aw * 0.5f;
    float a_y2 = ay + ah * 0.5f;

    for (int j = i + 1; j < num_valid; j++)
    {
        if (removed[j])
            continue;

        int b_idx = valid_boxes[j];
        float bx = model_output[b_idx * 7 + 0];
        float by = model_output[b_idx * 7 + 1];
        float bw = model_output[b_idx * 7 + 2];
        float bh = model_output[b_idx * 7 + 3];

        float b_x1 = bx - bw * 0.5f;
        float b_y1 = by - bh * 0.5f;
        float b_x2 = bx + bw * 0.5f;
        float b_y2 = by + bh * 0.5f;

        // 计算 IoU
        float inter_x1 = (a_x1 > b_x1) ? a_x1 : b_x1;
        float inter_y1 = (a_y1 > b_y1) ? a_y1 : b_y1;
        float inter_x2 = (a_x2 < b_x2) ? a_x2 : b_x2;
        float inter_y2 = (a_y2 < b_y2) ? a_y2 : b_y2;

        float iou = 0.0f;
        if (inter_x2 > inter_x1 && inter_y2 > inter_y1)
        {
            float inter_area = (inter_x2 - inter_x1) * (inter_y2 - inter_y1);
            float a_area = aw * ah;
            float b_area = bw * bh;
            iou = inter_area / (a_area + b_area - inter_area);
        }

        if (iou > iou_threshold)
            removed[j] = 1;
    }
}

// ====================== 4. 输出最终保留的框 ======================
printf("\n===== NMS 最终保留框 =====\n");
//清除框

int final_count = 0;

for (int i = 0,p=0; i < num_valid; i++)
{

    if (!removed[i])
    {
        int idx = valid_boxes[i];
        float x = model_output[idx * 7 + 0];
        float y = model_output[idx * 7 + 1];
        float w = model_output[idx * 7 + 2];
        float h = model_output[idx * 7 + 3];

        float conf = 0;
        class_id = 0;
        for (int c = 0; c < num_classes; c++)
        {
            float v = model_output[idx * 7 + 5 + c];
            if (v > conf) {
                conf = v;
                class_id = c;
            }
        }

        // 输出坐标
	frame.draw_en=true;
frame.line_x_start = (x-w*0.5f) * (1280.0f / 320.0f);
frame.line_y_start = (y-h*0.5f) * (1280.0f / 320.0f);
frame.line_x_end   = (x + w*0.5f) * (1280.0f / 320.0f);
frame.line_y_end   = (y + h*0.5f) * (1280.0f / 320.0f);
        frame.frame_num=p++;
        int ret=kd_mpi_vo_draw_frame(&frame);
        final_count++;
printf("x:%d,y:%d,w:%d,h:%d\n",frame.line_x_start,frame.line_y_start,frame.line_x_end,frame.line_y_end);
    }
}
printf("numg valid:%d\n",num_valid);

return final_count;

}
int Model::postprocess()
{

float *out;
auto tensor = output_tensor(0);
    auto buf = tensor.impl()->to_host().unwrap()->buffer().as_host().unwrap().map(map_access_::map_read).unwrap().buffer();
    out = reinterpret_cast<float *>(buf.data());
auto input_shape = interp_.input_shape(0);
printf("in_shape:%dx%dx%d\n",input_shape[0],input_shape[1],input_shape[2]);
auto output_shape = interp_.output_shape(0);
printf("out_shape:%dx%dx%d\n",output_shape[0],output_shape[1],output_shape[2]);

int final_boxes = nms_filter(
out, // 输入
0.5f, // 置信度阈值
0.45f // IOU 阈值
);
printf("final_boxes:%d\n",final_boxes);

return final_boxes;

}

硬件板卡

k230_canmv_v3

软件版本

rtos+linux

8883-1
1 Answers

这是模拟代码
import os
import copy
import argparse
import numpy as np
import onnx
import onnxruntime as ort
import nncase
import sys
import subprocess
import cv2

result = subprocess.run(["pip", "show", "nncase"], capture_output=True)
split_flag = "\n"
if sys.platform == "win32":
split_flag = "\r\n"

location_s = [i for i in result.stdout.decode().split(split_flag) if i.startswith("Location:")]
location = location_s[0].split(": ")[1]

if "PATH" in os.environ:
os.environ["PATH"] += os.pathsep + location
else:
os.environ["PATH"] = location

def read_model_file(model_file):
with open(model_file, 'rb') as f:
model_content = f.read()
return model_content

def cosine(gt, pred):
return (gt @ pred) / (np.linalg.norm(gt, 2) * np.linalg.norm(pred, 2))

==================== YOLOv5 前处理 ====================

def letterbox(img, new_shape=(320, 320), color=(114, 114, 114)):
shape = img.shape[:2]
r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1]
dw, dh = dw / 2, dh / 2
if shape[::-1] != new_unpad:
img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
top = int(round(dh - 0.1))
bottom = int(round(dh + 0.1))
left = int(round(dw - 0.1))
right = int(round(dw + 0.1))
img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)
return img, r, (dw, dh)

def preprocess_image(image_path):
img = cv2.imread(image_path)
# 保存原始图用于画图
ori_img = img.copy()
img, scale, (pad_w, pad_h) = letterbox(img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = img.astype(np.float32) / 255.0
blob = img.transpose(2, 0, 1)
blob = blob[None, ...]
return blob, scale, pad_w, pad_h, ori_img

==================== YOLOv5 后处理 ====================

def postprocess(output, scale, pad_w, pad_h, conf_thres=0.15, iou_thres=0.45):
predictions = output[0]
obj_conf = predictions[:, 4]
cls_max = np.maximum(predictions[:, 5], predictions[:, 6])
final_conf = obj_conf * cls_max
mask = final_conf >= conf_thres
filtered = predictions[mask]
confs = final_conf[mask]
dets = []
for p, c in zip(filtered, confs):
x, y, w, h = p[0:4]
# 坐标映射回原图
x1 = int((x - w/2 - pad_w) / scale)
y1 = int((y - h/2 - pad_h) / scale)
x2 = int((x + w/2 - pad_w) / scale)
y2 = int((y + h/2 - pad_h) / scale)
cls = 0 if p[5] > p[6] else 1
dets.append([x1, y1, x2, y2, c, cls])

# NMS
dets = sorted(dets, key=lambda x: x[4], reverse=True)
keep = []
for d in dets:
    keep_flag = True
    for k in keep:
        ix1 = max(d[0], k[0])
        iy1 = max(d[1], k[1])
        ix2 = min(d[2], k[2])
        iy2 = min(d[3], k[3])
        area = max(0, ix2-ix1) * max(0, iy2-iy1)
        iou = area / ((d[2]-d[0])*(d[3]-d[1]) + (k[2]-k[0])*(k[3]-k[1]) - area + 1e-8)
        if iou > iou_thres:
            keep_flag = False
            break
    if keep_flag:
        keep.append(d)
return keep

==================== 画图函数 ====================

def draw_and_save(img, dets, save_path="result.jpg"):
for x1, y1, x2, y2, conf, cls in dets:
cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
cv2.putText(img, f"{conf:.2f}", (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.imwrite(save_path, img)

==================== main ====================

def main():
parser = argparse.ArgumentParser(prog="nncase")
parser.add_argument("--model", type=str, help='original model file')
parser.add_argument("--kmodel", type=str, help='kmodel file')
parser.add_argument("--image", type=str, help='test image path')
args = parser.parse_args()

# 前处理（融合）
blob, scale, pad_w, pad_h, ori_img = preprocess_image(args.image)
blob.tofile("input.bin")

# ONNX 推理
ort_session = ort.InferenceSession(args.model)
output_names = [node.name for node in ort_session.get_outputs()]
model_input = ort_session.get_inputs()[0]
model_input_name = model_input.name
model_input_shape = (1,3,320,320)

model_input_data = np.fromfile("input.bin", dtype=np.float32).reshape(model_input_shape)
cpu_results = ort_session.run(output_names, {model_input_name: model_input_data})

# kmodel 推理
sim = nncase.Simulator()
kmodel = read_model_file(args.kmodel)
sim.load_model(kmodel)

input = np.fromfile("input.bin", dtype=np.float32).reshape([1,3,320,320])
sim.set_input_tensor(0, nncase.RuntimeTensor.from_numpy(input))

sim.run()
nncase_results = []
for i in range(sim.outputs_size):
    nncase_result = sim.get_output_tensor(i).to_numpy()
    nncase_results.append(copy.deepcopy(nncase_result))

# 保存输出
with open("out1.txt", "w") as f:
    for idx, res in enumerate(cpu_results):
        f.write(f"========== ONNX Output {idx} ==========\n")
        f.write(f"Shape: {res.shape}\n")
        f.write(f"Data:\n{res}\n\n")
print(" ONNX 输出已保存 → out1.txt")

with open("out2.txt", "w") as f:
    for idx, res in enumerate(nncase_results):
        f.write(f"========== KMODEL Output {idx} ==========\n")
        f.write(f"Shape: {res.shape}\n")
        f.write(f"Data:\n{res}\n\n")
print(" Kmodel 输出已保存 → out2.txt")

# 余弦对比
print("\n========== 余弦相似度对比 ==========")
for i in range(len(cpu_results)):
    cos = cosine(cpu_results[i].flatten(), nncase_results[i].flatten())
    print(f'Output {i} cosine: {cos:.6f}')

# 后处理（融合）
print("\n========== ONNX 后处理结果 ==========")
boxes_onnx = postprocess(cpu_results[0], scale, pad_w, pad_h)
print(f"检测目标：{len(boxes_onnx)}")

print("\n========== Kmodel 后处理结果 ==========")
boxes_kmodel = postprocess(nncase_results[0], scale, pad_w, pad_h)
print(f"检测目标：{len(boxes_kmodel)}")

# ==================== 画图输出图片====================
draw_and_save(ori_img, boxes_onnx, "result_onnx.jpg")
draw_and_save(ori_img.copy(), boxes_kmodel, "result_kmodel.jpg")
print("\n  检测完成！结果图已保存：")
print("   - result_onnx.jpg")
print("   - result_kmodel.jpg")

if name == 'main':
main()
#as

8883-1