目前，文本检测主要分为基于检测网络和分割网络实现，上文(风影：记录densenet-ocr识别网络转ncnn并移植到安卓手机)讲到将yolo3文本检测+densenet识别网络转ncnn推理，并成功移植到安卓上，本文介绍基于分割网络--dbnet文本检测，转ncnn推理并移植到安卓上。

模型转换步骤，dbnet(pytorch)--onnx--ncnn。

2.将pytorch转换为onnx格式，目前onnx支持动态输入，我们暂时可以先将图像的输入设为固定，比如，1280*1280*3，后面再手动修改ncnn模型结构；

device = torch.device("cpu")

print('device:', device)

checkpoint = torch.load(dbnet_modelfile, map_location=device)

config = checkpoint['config']

config['arch']['backbone']['pretrained'] = False

db_model = build_model(config['arch'])

db_model.load_state_dict(checkpoint['state_dict'])

db_model.to(device)

db_model.eval()

input_name = ['input']

output_name = ['output']

input = Variable(torch.randn(1,3, 1280, 1280))

torch.onnx.export(db_model, input, export_onnx_file,

input_names=input_name,

output_names=output_name,

verbose=True,

opset_version=11,

export_params=True,

keep_initializers_as_inputs=True,

# dynamic_axes={"input": {3: "time_step"},

# "output": {3: "time_step"}}

)

print('export done')

3.使用onnxruntime测试导出的模型是否正确；

mean = (0.485, 0.456, 0.406)

std = (0.229, 0.224, 0.225)

src_img = cv2.imread(img_path, 1)

img = cv2.cvtColor(src_img, cv2.COLOR_BGR2RGB)

h, w = img.shape[:2]

# img = resize_image(img, 640)

img = cv2.resize(img, (1280, 1280))

# 将图片由(w,h)变为(1,img_channel,h,w)

img1 = img / 255.0

img1 -= mean

img1 /= std

img1 = img1.transpose(2, 0, 1)

img1 = np.expand_dims(img1, axis=0)

img1 = np.float32(img1)

ort_session = onnxruntime.InferenceSession(export_onnx_file)

for input_meta in ort_session.get_inputs():

print(input_meta)

for output_meta in ort_session.get_outputs():

print(output_meta)

ort_inputs = {ort_session.get_inputs()[0].name: img1}

ort_outs = ort_session.run(["output"], ort_inputs)

pred_map = ort_outs[0]

pred_map = torch.from_numpy(pred_map)

post_process = seg_detector_representer.SegDetectorRepresenter(

thresh=0.3, box_thresh=0.7, max_candidates=1000, unclip_ratio=1.5)

batch = {'shape': [(h, w)]}

box_list, score_list = post_process.db_post_process(batch, pred_map)

box_list, score_list = box_list[0], score_list[0]

if len(box_list) > 0:

idx = box_list.reshape(box_list.shape[0], -1).sum(axis=1) > 0 # 去掉全为0的框

box_list, score_list = box_list[idx], score_list[idx]

else:

box_list, score_list = [], []

img2 = draw_bbox(src_img, box_list)

cv2.imwrite('./result/001_result2.jpg', img2)

print('onnxruntime_infer done')

4.对生成的onnx模型进行优化，使用大老师提供的工具daquexian/onnx-simplifier)，目前不支持动态输入，命令 python -m onnxsim dbnet.onnx dbnet-sim.onnx，因为生成onnx的时候固定了输入大小，所以不需要--input-shape参数；

5.编译ncnn(Tencent/ncnn)，将onnx模型转ncnn，命令 ./onnx/onnx2ncnn dbnet-sim.onnx dbnet-sim.param dbnet-sim.bin;打开dbnet-sim.param，并可视化下模型结构，Interp层有5个参数；

6.对生成的ncnn模型进行优化，命令 ./ncnnoptimize dbnet-sim.param dbnet-sim.bin dbnet-opt.param dbnet-opt.bin 0；优化后Interp层参数如下所示，此时模型只能输入固定尺寸1280*1280，找到./src/layer/interp.cpp文件，可以看到0代表resize_type，1和2分别是高和宽的缩放比例，3和4分别是输出的高和宽，此时需要手动修改Interp层参数以便支持动态输入，同时删除最后一层的参数；

int Interp::load_param(const ParamDict& pd)

{

resize_type = pd.get(0, 0);

height_scale = pd.get(1, 1.f);

width_scale = pd.get(2, 1.f);

output_height = pd.get(3, 0);

output_width = pd.get(4, 0);

if (resize_type < 0 || resize_type > 3)

{

NCNN_LOGE("unsupported resize type %d", resize_type);

return -1;

}

return 0;

}

7.使用ncnn进行推理；

ncnn::Net dbnet;

// the ncnn model https://github.com/nihui/ncnn-assets/tree/master/models

char *param = "./models/dbnet-opt.param";

char *bin = "./models/dbnet-opt.bin";

char *save_file = "./imgs/result2.jpg";

dbnet.load_param(param);

dbnet.load_model(bin);

const float mean_vals_dbnet[3] = { 0.485 * 255, 0.456 * 255, 0.406 * 255 };

const float norm_vals_dbnet[3] = { 1.0 / 0.229 / 255.0, 1.0 / 0.224 / 255.0, 1.0 / 0.225 / 255.0 };

const float unclip_ratio = 1.5;

const float box_thresh = 0.5;

const float thresh = 0.3;

const int min_size = 3;

int srcwid, srchi, wid, hi;

srcwid = bgr.cols;

srchi = bgr.rows;

wid = srcwid;

hi = srchi;

float scale = 1.f;

int inshortsize = srcwid;

if (wid > hi)

{

scale = (float)inshortsize / wid;

wid = inshortsize;

hi = hi * scale;

}

else

{

scale = (float)inshortsize / hi;

hi = inshortsize;

wid = wid * scale;

}

if (hi % 32 != 0)

{

hi = (hi / 32 + 1) * 32;

}

if (wid % 32 != 0)

{

wid = (wid / 32 + 1) * 32;

}

ncnn::Mat in = ncnn::Mat::from_pixels_resize(bgr.data, ncnn::Mat::PIXEL_BGR,

srcwid, srchi, wid, hi);

in.substract_mean_normalize(mean_vals_dbnet, norm_vals_dbnet);

ncnn::Extractor dbnet_ex = dbnet.create_extractor();

dbnet_ex.set_num_threads(4);

dbnet_ex.input("input", in);

ncnn::Mat dbnet_out;

dbnet_ex.extract("output", dbnet_out);

// post_process

cv::Mat fmapmat(hi, wid, CV_32FC1);

memcpy(fmapmat.data, (float*)dbnet_out.data, wid * hi * sizeof(float));

cv::Mat norfmapmat;

norfmapmat = fmapmat > thresh;

std::vector rsbox;

rsbox.clear();

std::vector<:vector>> contours;

cv::findContours(norfmapmat, contours, cv::RETR_LIST, cv::CHAIN_APPROX_SIMPLE);

for (int i = 0; i < contours.size(); ++i)

{

std::vector<:point> minbox;

float minedgesize, alledgesize;

get_mini_boxes(contours[i], minbox, minedgesize, alledgesize);

if (minedgesize < min_size)

continue;

float score = box_score_fast(fmapmat, contours[i]);

if (score < box_thresh)

continue;

std::vector<:point> newbox;

unclip(minbox, alledgesize, newbox, unclip_ratio);

get_mini_boxes(newbox, minbox, minedgesize, alledgesize);

if (minedgesize < min_size + 2)

continue;

for (int j = 0; j < minbox.size(); ++j)

{

minbox[j].x = (minbox[j].x / (float)wid * srcwid);

minbox[j].x = (std::min)((std::max)(minbox[j].x, 0), srcwid);

minbox[j].y = (minbox[j].y / (float)hi * srchi);

minbox[j].y = (std::min)((std::max)(minbox[j].y, 0), srchi);

}

rsbox.push_back(TextBox(minbox, score));

}

cv::Mat srcmat = bgr.clone();

for (int i = 0; i < rsbox.size(); ++i)

{

DrawMatText(srcmat, rsbox[i].Box);

}

cv::imwrite(save_file, srcmat);

参考：