发 帖  
原厂入驻New

【大联大世平Intel®神经计算棒NCS2试用体验】目标跟踪结项篇

2020-8-29 23:13:39  155
分享
0
本帖最后由 IC爬虫 于 2020-9-2 15:35 编辑

       NCS2 作为一个可用于深度学习的加速棒,在目标跟踪这种非常讲究实时性的应用中是非常的有用的,在工作中我使用3559a实现了目标跟踪的算法,目前海思被制裁造成3559a涨到了3000元一片的价格而且还缺货,所以我将以前的那套跟踪算法移植到了NCS2上。
目前比较可用点的目标跟踪算法主要:
1.基于相关滤波的目标跟踪算法
2.基于深度学习的目标跟踪算法
3.基于检测加位置相关滤波的算法

          目前基于相关滤波司法的目标跟踪算法效果已经难满足我的要求了,主要体现在无法长时稳定跟踪,另外对小目标及纹理效果低的目标效果非常的不理想,所以这个方案不考虑。
          基于深度学习目标跟踪司法比如siamRPN,最大的问题是计算量太大,而且目标消失后无法准确知道目标消失了,所以也是无法作为长时间目标跟踪的。我的项目需要的是从时间跟踪一个人,我选择的基于人头检测加上基于人头位置前后帧相关性的跟踪算法逻辑,之前人头检测的使用NNIE进行加速,CPU根据NNIE返回的人头位置用于和前帧的位置及运动方向进行融合,判断当前获取的人头位置是否为需要跟踪的那个人的。
        1.整个跟踪算法的第一步选定合适的检测模型并实现收集合适的开源人头数据集:
我使用的是SSD模型,这个模型效果还可以并且最重要的是比较方便的部署在设备端。另外一个合适的人头数据集也非常的重要,我最后测试了多种人头检测的数据集发现hollywoodHead这个人头数据集记过各种调参后训练得到的检测效果是比较好的。
        2.训练电脑环境安装:
我训练模型所使用的电脑配置为:I7 8系列的CPU、32G内存、RTX2070显卡一张
        3.使用SSD模型训练自己的人头检测模型:
SSD上实现各种物品和人脸活在人体检测检测的很多,但是为了实现简化SSD的计算量我需要训练一个只检测人头的单分类模型,这个可以比那些基于COCO或者其他现成的检测模型的计算量小很多。相比原版的SSD训练代码改了一些地方,上训练代码:
  1. # coding=utf-8
  2. from __future__ import print_function
  3. import caffe
  4. from caffe.model_libs import *
  5. from google.protobuf import text_format

  6. import math
  7. import os
  8. import shutil
  9. import stat
  10. import subprocess
  11. import sys

  12. def AddExtraLayers(net, use_batchnorm=True, lr_mult=1):
  13.     use_relu = True

  14.     from_layer = net.keys()[-1]

  15.     out_layer = "conv6_1"
  16.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 1, 0, 1,
  17.         lr_mult=lr_mult)

  18.     from_layer = out_layer
  19.     out_layer = "conv6_2"
  20.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 512, 3, 1, 2,
  21.         lr_mult=lr_mult)

  22.     from_layer = out_layer
  23.     out_layer = "conv7_1"
  24.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1,
  25.       lr_mult=lr_mult)

  26.     from_layer = out_layer
  27.     out_layer = "conv7_2"
  28.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 1, 2,
  29.       lr_mult=lr_mult)

  30.     from_layer = out_layer
  31.     out_layer = "conv8_1"
  32.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1,
  33.       lr_mult=lr_mult)

  34.     from_layer = out_layer
  35.     out_layer = "conv8_2"
  36.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 0, 1,
  37.       lr_mult=lr_mult)

  38.     from_layer = out_layer
  39.     out_layer = "conv9_1"
  40.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 128, 1, 0, 1,
  41.       lr_mult=lr_mult)

  42.     from_layer = out_layer
  43.     out_layer = "conv9_2"
  44.     ConvBNLayer(net, from_layer, out_layer, use_batchnorm, use_relu, 256, 3, 0, 1,
  45.       lr_mult=lr_mult)

  46.     return net


  47. caffe_root = os.getcwd()

  48. run_soon = True
  49. resume_training = True
  50. remove_old_models = False

  51. train_data = "examples/hollywoodhead/hollywoodhead_trainval_lmdb"
  52. test_data = "examples/hollywoodhead/hollywoodhead_test_lmdb"
  53. resize_width = 300
  54. resize_height = 300
  55. resize = "{}x{}".format(resize_width, resize_height)
  56. batch_sampler = [
  57.         {
  58.                 'sampler': {
  59.                         },
  60.                 'max_trials': 1,
  61.                 'max_sample': 1,
  62.         },
  63.         {
  64.                 'sampler': {
  65.                         'min_scale': 0.3,
  66.                         'max_scale': 1.0,
  67.                         'min_aspect_ratio': 0.5,
  68.                         'max_aspect_ratio': 2.0,
  69.                         },
  70.                 'sample_constraint': {
  71.                         'min_jaccard_overlap': 0.1,
  72.                         },
  73.                 'max_trials': 50,
  74.                 'max_sample': 1,
  75.         },
  76.         {
  77.                 'sampler': {
  78.                         'min_scale': 0.3,
  79.                         'max_scale': 1.0,
  80.                         'min_aspect_ratio': 0.5,
  81.                         'max_aspect_ratio': 2.0,
  82.                         },
  83.                 'sample_constraint': {
  84.                         'min_jaccard_overlap': 0.3,
  85.                         },
  86.                 'max_trials': 50,
  87.                 'max_sample': 1,
  88.         },
  89.         {
  90.                 'sampler': {
  91.                         'min_scale': 0.3,
  92.                         'max_scale': 1.0,
  93.                         'min_aspect_ratio': 0.5,
  94.                         'max_aspect_ratio': 2.0,
  95.                         },
  96.                 'sample_constraint': {
  97.                         'min_jaccard_overlap': 0.5,
  98.                         },
  99.                 'max_trials': 50,
  100.                 'max_sample': 1,
  101.         },
  102.         {
  103.                 'sampler': {
  104.                         'min_scale': 0.3,
  105.                         'max_scale': 1.0,
  106.                         'min_aspect_ratio': 0.5,
  107.                         'max_aspect_ratio': 2.0,
  108.                         },
  109.                 'sample_constraint': {
  110.                         'min_jaccard_overlap': 0.7,
  111.                         },
  112.                 'max_trials': 50,
  113.                 'max_sample': 1,
  114.         },
  115.         {
  116.                 'sampler': {
  117.                         'min_scale': 0.3,
  118.                         'max_scale': 1.0,
  119.                         'min_aspect_ratio': 0.5,
  120.                         'max_aspect_ratio': 2.0,
  121.                         },
  122.                 'sample_constraint': {
  123.                         'min_jaccard_overlap': 0.9,
  124.                         },
  125.                 'max_trials': 50,
  126.                 'max_sample': 1,
  127.         },
  128.         {
  129.                 'sampler': {
  130.                         'min_scale': 0.3,
  131.                         'max_scale': 1.0,
  132.                         'min_aspect_ratio': 0.5,
  133.                         'max_aspect_ratio': 2.0,
  134.                         },
  135.                 'sample_constraint': {
  136.                         'max_jaccard_overlap': 1.0,
  137.                         },
  138.                 'max_trials': 50,
  139.                 'max_sample': 1,
  140.         },
  141.         ]
  142. train_transform_param = {
  143.         'mirror': True,
  144.         'mean_value': [104, 117, 123],
  145.         'resize_param': {
  146.                 'prob': 1,
  147.                 'resize_mode': P.Resize.WARP,
  148.                 'height': resize_height,
  149.                 'width': resize_width,
  150.                 'interp_mode': [
  151.                         P.Resize.linear,
  152.                         P.Resize.AREA,
  153.                         P.Resize.NEAREST,
  154.                         P.Resize.CUBIC,
  155.                         P.Resize.LANCZOS4,
  156.                         ],
  157.                 },
  158.         'distort_param': {
  159.                 'brightness_prob': 0.5,
  160.                 'brightness_delta': 32,
  161.                 'contrast_prob': 0.5,
  162.                 'contrast_lower': 0.5,
  163.                 'contrast_upper': 1.5,
  164.                 'hue_prob': 0.5,
  165.                 'hue_delta': 18,
  166.                 'saturation_prob': 0.5,
  167.                 'saturation_lower': 0.5,
  168.                 'saturation_upper': 1.5,
  169.                 'random_order_prob': 0.0,
  170.                 },
  171.         'expand_param': {
  172.                 'prob': 0.5,
  173.                 'max_expand_ratio': 4.0,
  174.                 },
  175.         'emit_constraint': {
  176.             'emit_type': caffe_pb2.EmitConstraint.CENTER,
  177.             }
  178.         }
  179. test_transform_param = {
  180.         'mean_value': [104, 117, 123],
  181.         'resize_param': {
  182.                 'prob': 1,
  183.                 'resize_mode': P.Resize.WARP,
  184.                 'height': resize_height,
  185.                 'width': resize_width,
  186.                 'interp_mode': [P.Resize.LINEAR],
  187.                 },
  188.         }

  189. use_batchnorm = False
  190. lr_mult = 1
  191. IF use_batchnorm:
  192.     base_lr = 0.0004
  193. else:
  194.     base_lr = 0.00004

  195. job_name = "TK_{}".format(resize)
  196. model_name = "hollywoodhead_{}".format(job_name)

  197. save_dir = "models/VGGNet/hollywoodhead/{}".format(job_name)
  198. snapshot_dir = "models/VGGNet/hollywoodhead/{}".format(job_name)
  199. job_dir = "jobs/VGGNet/hollywoodhead/{}".format(job_name)
  200. output_result_dir = "{}/data/VOCdevkit/results/hollywoodhead/{}/Main".format(os.environ['HOME'], job_name)

  201. train_net_file = "{}/train.prototxt".format(save_dir)
  202. test_net_file = "{}/test.prototxt".format(save_dir)
  203. deploy_net_file = "{}/deploy.prototxt".format(save_dir)
  204. solver_file = "{}/solver.prototxt".format(save_dir)
  205. snapshot_prefix = "{}/{}".format(snapshot_dir, model_name)
  206. job_file = "{}/{}.sh".format(job_dir, model_name)

  207. name_size_file = "data/hollywoodhead/test_name_size.txt"
  208. pretrain_model = "models/VGGNet/VGG_ILSVRC_16_layers_fc_reduced.caffemodel"
  209. label_map_file = "data/hollywoodhead/labelmap_voc.prototxt"

  210. num_classes = 2                                 
  211. share_location = True                           
  212. background_label_id=0                           
  213. train_on_diff_gt = True                        
  214. normalization_mode = P.Loss.VALID               
  215. code_type = P.PriorBox.CENTER_SIZE              
  216. ignore_cross_boundary_bbox = False              
  217. mining_type = P.MultiBoxLoss.MAX_NEGATIVE      
  218. neg_pos_ratio = 3.                              
  219. loc_weight = (neg_pos_ratio + 1.) / 4.         
  220. multibox_loss_param = {                           
  221.     'loc_loss_type': P.MultiBoxLoss.SMOOTH_L1,   
  222.     'conf_loss_type': P.MultiBoxLoss.SOFTMAX,   
  223.     'loc_weight': loc_weight,
  224.     'num_classes': num_classes,
  225.     'share_location': share_location,
  226.     'match_type': P.MultiBoxLoss.PER_PREDICTION,  
  227.     'overlap_threshold': 0.5,                  
  228.     'use_prior_for_matching': True,            
  229.     'background_label_id': background_label_id,
  230.     'use_difficult_gt': train_on_diff_gt,         
  231.     'mining_type': mining_type,
  232.     'neg_pos_ratio': neg_pos_ratio,            
  233.     'neg_overlap': 0.5,                        
  234.     'code_type': code_type,
  235.     'ignore_cross_boundary_bbox': ignore_cross_boundary_bbox,
  236.     }
  237. loss_param = {
  238.     'normalization': normalization_mode,
  239.     }

  240. min_dim = 512
  241. mbox_source_layers = ['conv4_3', 'fc7', 'conv6_2', 'conv7_2', 'conv8_2', 'conv9_2', 'conv10_2']   
  242. min_ratio = 20               
  243. max_ratio = 90
  244. step = int(math.floor((max_ratio - min_ratio) / (len(mbox_source_layers) - 2))) #
  245. min_sizes = []         
  246. max_sizes = []
  247. for ratio in xrange(min_ratio, max_ratio + 1, step):   
  248.   min_sizes.append(min_dim * ratio / 100.)               
  249.   max_sizes.append(min_dim * (ratio + step) / 100.)
  250. min_sizes = [min_dim * 10 / 100.] + min_sizes
  251. max_sizes = [min_dim * 20 / 100.] + max_sizes
  252. steps = [8, 16, 32, 64, 100, 300]                        
  253. aspect_ratios = [[2], [2, 3], [2, 3], [2, 3], [2], [2]]        
  254.                                                         
  255. normalizations = [20, -1, -1, -1, -1, -1]      
  256. if code_type == P.PriorBox.CENTER_SIZE:           
  257.   prior_variance = [0.1, 0.1, 0.2, 0.2]
  258. else:
  259.   prior_variance = [0.1]
  260. flip = True     
  261. clip = False      
  262.         

  263. gpus = "0"
  264. gpulist = gpus.split(",")      
  265. num_gpus = len(gpulist)         

  266. batch_size = 16
  267. accum_batch_size = 16
  268. iter_size = accum_batch_size / batch_size   
  269. solver_mode = P.Solver.CPU
  270. device_id = 0
  271. batch_size_per_device = batch_size
  272. if num_gpus > 0:               
  273.   batch_size_per_device = int(math.ceil(float(batch_size) / num_gpus))                          
  274.   iter_size = int(math.ceil(float(accum_batch_size) / (batch_size_per_device * num_gpus)))      
  275.   solver_mode = P.Solver.GPU
  276.   device_id = int(gpulist[0])

  277. if normalization_mode == P.Loss.NONE:        
  278.   base_lr /= batch_size_per_device
  279. elif normalization_mode == P.Loss.VALID:        
  280.   base_lr *= 25. / loc_weight
  281. elif normalization_mode == P.Loss.FULL:
  282.   base_lr *= 2000.                    

  283. num_test_image = 500               
  284. test_batch_size = 4                  
  285.                                        
  286. test_iter = num_test_image / test_batch_size     

  287. solver_param = {                       
  288.     'base_lr': base_lr,
  289.     'weight_decay': 0.0005,
  290.     'lr_policy': "multistep",
  291.     'stepvalue': [80000, 100000, 120000],      
  292.     'gamma': 0.1,
  293.     'momentum': 0.9,
  294.     'iter_size': iter_size,
  295.     'max_iter': 120000,                  
  296.     'snapshot': 40000,
  297.     'display': 10,
  298.     'average_loss': 10,
  299.     'type': "SGD",
  300.     'solver_mode': solver_mode,
  301.     'device_id': device_id,
  302.     'debug_info': False,
  303.     'snapshot_after_train': True,
  304.     'test_iter': [test_iter],
  305.     'test_interval': 10000,                    
  306.     'eval_type': "detection",
  307.     'ap_version': "11point",
  308.     'test_initialization': False,
  309.     }

  310. det_out_param = {
  311.     'num_classes': num_classes,                        
  312.     'share_location': share_location,                  
  313.     'background_label_id': background_label_id,         
  314.     'nms_param': {'nms_threshold': 0.45, 'top_k': 400},
  315.     'save_output_param': {                              
  316.         'output_directory': output_result_dir,      
  317.         'output_name_prefix': "comp4_det_test_",        
  318.         'output_format': "VOC",                       
  319.         'label_map_file': label_map_file,              
  320.         'name_size_file': name_size_file,            
  321.         'num_test_image': num_test_image,              
  322.         },
  323.     'keep_top_k': 200,                                 
  324.     'confidence_threshold': 0.01,                    
  325.     'code_type': code_type,                        
  326.     }

  327. det_eval_param = {                                    
  328.     'num_classes': num_classes,                 
  329.     'background_label_id': background_label_id,   
  330.     'overlap_threshold': 0.5,                     
  331.     'evaluate_difficult_gt': False,            
  332.     'name_size_file': name_size_file,               
  333.     }

  334. check_if_exist(train_data)
  335. check_if_exist(test_data)
  336. check_if_exist(label_map_file)
  337. check_if_exist(pretrain_model)
  338. make_if_not_exist(save_dir)
  339. make_if_not_exist(job_dir)
  340. make_if_not_exist(snapshot_dir)

  341. net = caffe.NetSpec()
  342. net.data, net.label = CreateAnnotatedDataLayer(train_data, batch_size=batch_size_per_device,
  343.         train=True, output_label=True, label_map_file=label_map_file,
  344.         transform_param=train_transform_param, batch_sampler=batch_sampler)
  345. VGGNetBody(net, from_layer='data', fully_conv=True, reduced=True, dilated=True, dropout=False)
  346. AddExtraLayers(net, use_batchnorm, lr_mult=lr_mult)
  347. mbox_layers = CreateMultiBoxHead(net, data_layer='data', from_layers=mbox_source_layers,
  348.         use_batchnorm=use_batchnorm, min_sizes=min_sizes, max_sizes=max_sizes,
  349.         aspect_ratios=aspect_ratios, steps=steps, normalizations=normalizations,
  350.         num_classes=num_classes, share_location=share_location, flip=flip, clip=clip,
  351.         prior_variance=prior_variance, kernel_size=3, pad=1, lr_mult=lr_mult)

  352. name = "mbox_loss"
  353. mbox_layers.append(net.label)
  354. net[name] = L.MultiBoxLoss(*mbox_layers, multibox_loss_param=multibox_loss_param,
  355.         loss_param=loss_param, include=dict(phase=caffe_pb2.Phase.Value('TRAIN')),
  356.         propagate_down=[True, True, False, False])

  357. with open(train_net_file, 'w') as f:
  358.     print('name: "{}_train"'.format(model_name), file=f)
  359.     print(net.to_proto(), file=f)
  360. shutil.copy(train_net_file, job_dir)

  361. net = caffe.NetSpec()
  362. net.data, net.label = CreateAnnotatedDataLayer(test_data, batch_size=test_batch_size,
  363.         train=False, output_label=True, label_map_file=label_map_file,
  364.         transform_param=test_transform_param)

  365. VGGNetBody(net, from_layer='data', fully_conv=True, reduced=True, dilated=True,
  366.     dropout=False)

  367. AddExtraLayers(net, use_batchnorm, lr_mult=lr_mult)

  368. mbox_layers = CreateMultiBoxHead(net, data_layer='data', from_layers=mbox_source_layers,
  369.         use_batchnorm=use_batchnorm, min_sizes=min_sizes, max_sizes=max_sizes,
  370.         aspect_ratios=aspect_ratios, steps=steps, normalizations=normalizations,
  371.         num_classes=num_classes, share_location=share_location, flip=flip, clip=clip,
  372.         prior_variance=prior_variance, kernel_size=3, pad=1, lr_mult=lr_mult)

  373. conf_name = "mbox_conf"         
  374. if multibox_loss_param["conf_loss_type"] == P.MultiBoxLoss.SOFTMAX:
  375.   reshape_name = "{}_reshape".format(conf_name)
  376.   net[reshape_name] = L.Reshape(net[conf_name], shape=dict(dim=[0, -1, num_classes]))
  377.   softmax_name = "{}_softmax".format(conf_name)
  378.   net[softmax_name] = L.Softmax(net[reshape_name], axis=2)
  379.   flatten_name = "{}_flatten".format(conf_name)
  380.   net[flatten_name] = L.Flatten(net[softmax_name], axis=1)
  381.   mbox_layers[1] = net[flatten_name]
  382. elif multibox_loss_param["conf_loss_type"] == P.MultiBoxLoss.LOGISTIC:
  383.   sigmoid_name = "{}_sigmoid".format(conf_name)
  384.   net[sigmoid_name] = L.Sigmoid(net[conf_name])
  385.   mbox_layers[1] = net[sigmoid_name]

  386. net.detection_out = L.DetectionOutput(*mbox_layers,
  387.     detection_output_param=det_out_param,
  388.     include=dict(phase=caffe_pb2.Phase.Value('TEST')))
  389. net.detection_eval = L.DetectionEvaluate(net.detection_out, net.label,
  390.     detection_evaluate_param=det_eval_param,
  391.     include=dict(phase=caffe_pb2.Phase.Value('TEST')))

  392. with open(test_net_file, 'w') as f:
  393.     print('name: "{}_test"'.format(model_name), file=f)
  394.     print(net.to_proto(), file=f)
  395. shutil.copy(test_net_file, job_dir)

  396. deploy_net = net
  397. with open(deploy_net_file, 'w') as f:
  398.     net_param = deploy_net.to_proto()
  399.     del net_param.layer[0]                             
  400.     del net_param.layer[-1]                             
  401.     net_param.name = '{}_deploy'.format(model_name)   
  402.     net_param.input.extend(['data'])                    
  403.     net_param.input_shape.extend([
  404.         caffe_pb2.BlobShape(dim=[1, 3, resize_height, resize_width])])  
  405.     print(net_param, file=f)                           
  406. shutil.copy(deploy_net_file, job_dir)              

  407. solver = caffe_pb2.SolverParameter(            
  408.         train_net=train_net_file,      
  409.         test_net=[test_net_file],
  410.         snapshot_prefix=snapshot_prefix,
  411.         **solver_param)

  412. with open(solver_file, 'w') as f:              
  413.     print(solver, file=f)
  414. shutil.copy(solver_file, job_dir)            

  415. max_iter = 0                                    
  416. for file in os.listdir(snapshot_dir):            
  417.   if file.endswith(".solverstate"):            
  418.     basename = os.path.splitext(file)[0]
  419.     iter = int(basename.split("{}_iter_".format(model_name))[1])
  420.     if iter > max_iter:                                
  421.       max_iter = iter

  422. train_src_param = '--weights="{}" \\\n'.format(pretrain_model)
  423. if resume_training:
  424.   if max_iter > 0:
  425.     train_src_param = '--snapshot="{}_iter_{}.solverstate" \\\n'.format(snapshot_prefix, max_iter)     

  426. if remove_old_models:
  427.   for file in os.listdir(snapshot_dir):                              
  428.     if file.endswith(".solverstate"):                                   
  429.       basename = os.path.splitext(file)[0]
  430.       iter = int(basename.split("{}_iter_".format(model_name))[1])      
  431.       if max_iter > iter:                                               
  432.         os.remove("{}/{}".format(snapshot_dir, file))
  433.     if file.endswith(".caffemodel"):                                    
  434.       basename = os.path.splitext(file)[0]
  435.       iter = int(basename.split("{}_iter_".format(model_name))[1])      
  436.       if max_iter > iter:                                               
  437.         os.remove("{}/{}".format(snapshot_dir, file))

  438. with open(job_file, 'w') as f:                                         
  439.   f.write('cd {}\n'.format(caffe_root))
  440.   f.write('./build/tools/caffe train \\\n')
  441.   f.write('--solver="{}" \\\n'.format(solver_file))
  442.   f.write(train_src_param)
  443.   if solver_param['solver_mode'] == P.Solver.GPU:
  444.     f.write('--gpu {} 2>&1 | tee {}/{}.log\n'.format(gpus, job_dir, model_name))
  445.   else:
  446.     f.write('2>&1 | tee {}/{}.log\n'.format(job_dir, model_name))

  447. py_file = os.path.abspath(__file__)
  448. shutil.copy(py_file, job_dir)

  449. os.chmod(job_file, stat.S_IRWXU)
  450. if run_soon:
  451.   subprocess.call(job_file, shell=True)
复制代码
总的训练耗时在8小时左右!!!!!!!!!!!!!!!!!!!!!!!!
得到人头检测模型后可以根据SSD官方模型测试代码稍微改一下就可以用于测试自己的模型,这部分我就不贴代码了。。。。。。
         4.在NCS2 部署你的SSD 人头检测模型
NCS2 是基于OpenVINO框架,所以想在NCS2部分SSD其实可以直接参考OpenVINO SSD 的列子。
将caffe版的SSD转化为openvino框架下的模型:
进入/opt/intel/openvino/deployment_tools/model_optimizer$目录
执行
  1. python mo_caffe.py -h
复制代码
参数如下:
–input_proto:prototxt文件所在位置
-k:CustomLayersMapping.xml文件所在位置
–input_mode:
–mean_file:
–mean_file_offsets:
–output_dir
–scale SCALE
–log_level {CRITICAL,ERROR,WARN,WARNING,INFO,DEBUG,NOTSET}]
–input
–mean_values
–data_type {FP16,FP32,half,float}] [–disable_fusing]
–disable_resnet_optimization
–finegrain_fusing
–enable_concat_optimization
–extensions
–silent
–freeze_placeholder_with_value
–generate_deprecated_IR_v2
–mean_file_offsets
–disable_omitting_optional
–enable_flattening_nested_params

另外我也罗列了
OpenVINO支持的caffe模型a. Classification models:
  • AlexNet
  • VGG-16, VGG-19
  • SqueezeNet v1.0, SqueezeNet v1.1
  • ResNet-50, ResNet-101, Res-Net-152
  • Inception v1, Inception v2, Inception v3, Inception v4
  • CaffeNet
  • MobileNet
  • Squeeze-and-Excitation Networks: SE-BN-Inception, SE-Resnet-101, SE-ResNet-152, SE-ResNet-50, SE-ResNeXt-101, SE-ResNeXt-50
  • ShuffleNet v2
b. Object detection models:
  • SSD300-VGG16, SSD500-VGG16
  • Faster-RCNN
  • RefineDet (Myriad plugin only)
c. Face detection models:
  • VGG Face
d. Semantic segmentation models:
  • FCN8

OpenVINO支持的caffe层与其在Intermediate Representation (IR)中的对应关系[td]
NUMBERLAYER NAME IN CAFFE*LAYER NAME IN THE INTERMEDIATE REPRESENTATION
1InputInput
2GlobalInputInput
3InnerProductFullyConnected
4DropoutIgnored, does not appear in IR
5ConvolutionConvolution
6DeconvolutionDeconvolution
7PoolingPooling
8BatchNormBatchNormalization
9LRNNorm
10PowerPower
11ReLUReLU
12ScaleScaleShift
13ConcatConcat
14EltwiseEltwise
15FlattenFlatten
16ReshapeReshape
17SliceSlice
18SoftmaxSoftMax
19PermutePermute
20ROIPoolingROIPooling
21TileTile
22ShuffleChannelReshape + Split + Permute + Concat
23AxpyScaleShift + Eltwise
24BNScaleShift
25DetectionOutputDetectionOutput
26StridedSliceStridedSlice
27BiasEltwise(operation = sum)


参考这个链接:
https://docs.openvinotoolkit.org/latest/openvino_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Caffe.html

实际在NCS2运行的代码建议参考ncappzoo 里面SSD的代码,这部分我就不提供了。
在NCS2上运行人头检测得到人头位置后就可以在CP上根据这些信息跟踪了,核心代码如下:
  1. switch(status)
  2.     {
  3.     case HEAD_DETECT:
  4.         head_detection(bgr, headResult);
  5.         for(int i = 0; i < headResult.size(); i++)
  6.         {
  7.             actual_box = drawRect(pData, headResult[i], Scalar(255, 0, 0), offset_x, offset_y, offset_s, img_w, img_h);
  8.         }
  9.         if(headResult.size() == 1)
  10.         {
  11.             if(idx < filteQueueDetect)
  12.             {
  13.                 headFilte[idx] = headResult[0];
  14.                 idx++;
  15.             }
  16.             else
  17.             {
  18.                 for(i = 0; i < filteQueueDetect - 1; i++)
  19.                 {
  20.                     headFilte[i] = headFilte[i + 1];
  21.                 }
  22.                 headFilte[filteQueueDetect - 1] = headResult[0];
  23.                 var = variance(headFilte, filteQueueDetect);
  24.                 // printf("var = %f\n", var);
  25.                 if(var < 1)
  26.                 {
  27.                     box_src = headResult[0];
  28.                     box_src_last = box_src;
  29.                     // status = OBJ_TRACK_INIT;

  30.                     status = TICK_HEAD_DETECT;
  31.                     idx = 0;
  32.                 }
  33.             }
  34.         }
  35.         break;
  36.     case OBJ_TRACK_INIT:
  37.         // dst = mRGBAImg.clone();
  38.         tracker.init(box_src, dst);
  39.         actual_box = drawRect(pData, box_src, Scalar(0, 255, 255), offset_x, offset_y, offset_s, img_w, img_h);
  40.         status = OBJ_TRACK;
  41.         break;
  42.     case OBJ_TRACK:
  43. result = tracker.update(dst);
  44.         actual_box = drawRect(pData, result, Scalar(0, 255, 255), offset_x, offset_y, offset_s, img_w, img_h);
  45.         if(count++ == 5)
  46.         {
  47.             status = TICK_HEAD_DETECT;
  48.             count = 0;
  49.             detect_count = 0;
  50.         }
  51.         break;
  52.     case TICK_HEAD_DETECT:
  53.         head_detection(bgr, headResult);
  54.         IOU = 0;
  55.         IOU_max = 0;
  56.         for(i = 0; i < headResult.size(); i++)
  57.         {
  58.             IOU = iou(box_src_last, headResult[i]);
  59.             if(IOU_max < IOU && IOU>0)
  60.             {
  61.                 IOU_max = IOU;
  62.                 box_src = headResult[i];
  63.             }
  64.         }
  65. if(IOU_max > 0.1)
  66.         {
  67.             status = TICK_HEAD_DETECT;
  68.             int mean_x=0,mean_y=0,mean_w=0,mean_h=0;
  69.             if(box_src.area() < box_src_last.area()*1.5 && box_src.area() > box_src_last.area()*0.7)
  70.             {
  71.                 if(idx < trackQueueDetect)
  72.                 {
  73.                     trackFilte[idx] = box_src;
  74.                     if(idx>2)
  75.                     {
  76.                         for(i=0;i<idx;i++)
  77.                         {
  78.                             mean_x += trackFilte[i].x;
  79.                             mean_y += trackFilte[i].y;
  80.                             mean_w += trackFilte[i].width;
  81.                             mean_h += trackFilte[i].height;
  82.                         }
  83.                         box_src.x = (int)(mean_x/(idx));
  84.                         box_src.y = (int)(mean_y/(idx));
  85.                         box_src.width = (int)(mean_w/(idx));
  86.                         box_src.width = (int)(mean_h/(idx));
  87.                     }
  88.                     idx++;
  89.                 }
  90.                 else
  91.                 {
  92.                     trackFilte[trackQueueDetect - 1] = box_src;
  93.                     for(i = 0; i < trackQueueDetect - 1; i++)
  94.                     {
  95.                         trackFilte[i] = trackFilte[i + 1];
  96.                         mean_x += trackFilte[i].x;
  97.                         mean_y += trackFilte[i].y;
  98.                         mean_w += trackFilte[i].width;
  99.                         mean_h += trackFilte[i].height;
  100.                     }
  101.                     box_src.x = (int)((mean_x/(trackQueueDetect-1)+box_src.x)/2);
  102.                     box_src.y = (int)((mean_y/(trackQueueDetect-1)+box_src.y)/2);
  103.                     box_src.width = (int)((mean_w/(trackQueueDetect-1)+box_src.width)/2);
  104.                     box_src.height = (int)((mean_h/(trackQueueDetect-1)+box_src.height)/2);
  105.                 }
  106.                 actual_box = drawRect(pData, box_src, Scalar(0, 255, 255), offset_x, offset_y, offset_s, img_w, img_h);
  107.                 box_src_last = box_src;
  108.                
  109.                 target_width = (int)(actual_box.width*(camera_w/img_w));
  110.                 target_height = (int)(actual_box.height*(camera_h/img_h));
  111.                 target_x = (int)(actual_box.x*(camera_w/img_w)+target_width/2);
  112.                 target_y = (int)(actual_box.y*(camera_h/img_h)+target_height/2);
  113.                 printf("box_src.x=%d,box_src.y=%d,box_src.width=%d,box_src.height=%d,target_x=%d,target_y=%d,target_width=%d,target_height=%d\n", box_src.x, box_src.y, box_src.width, box_src.height, target_x, target_y, target_width, target_height);
  114.             }
  115.         }
  116.         else
  117.         {
  118.             detect_count++;
  119.             if(detect_count > 30)
  120.             {
  121.                 detect_count = 0;
  122.                 status = HEAD_DETECT;
  123.                 offset_x = src_init_x;
  124.                 offset_y = src_init_y;
  125.                 offset_s = 1;
  126.             }
  127.         }
  128.         break;
  129.     default:
  130.         break;
  131.     }
复制代码
测试在NSC2的检测结果如下: result.jpg
速度每秒22帧,这个速度算非常不错了。
总结:使用这个计算棒基本可以代替我目前在3559A上实现的这个项目的需求,而且这个价格还不错,如果能直接购买这个芯片集成到自己的产品中价格那是非常有优势的,后续打算和RK3399搭配使用。

只有小组成员才能发言,加入小组>>

85个成员聚集在这个小组

加入小组

创建小组步骤

关闭

站长推荐 上一条 /9 下一条

快速回复 返回顶部 返回列表