第十六周周报：单发的目标检测系列

目次
择要
Abstract
一、SSD
1.1 模子结构
1.2 代码
二、YOLO
三、Termius
总结

---

择要

本周紧张学习单阶段的目标检测算法，如SSD、YOLO模子。具体学习了每个模子的原理，以及SSD和YOLO模子之间的异同。在本篇博客中将展示SSD的PyTorch实当代码，以及在第三章会介绍一下Termius的使用，便于连接服务器。

Abstract

This week, I will mainly learn single-stage object detection algorithms such as SSD and YOLO models. I have studied in detail the principles of each model, as well as the similarities and differences between SSD and YOLO models. In this blog post, we will showcase the PyTorch implementation code for SSD, and in Chapter 3, we will introduce the use of Termius for easy server connection.

一、SSD

1.1 模子结构

上一篇博客学习了R-CNN系列，其都为2步走系列，先进行候选地域的提取，再进行候选地域的分类等使用。而Single Shot MultiBox Detector（SSD）为单发的目标检测，即通过一次网络便可以完成边框的猜测和类概率的输出。
   正由于是Single Shot，极大进步了目标检测的速率，如下图所示：
  

  SSD能做到每秒59帧的速率，比上一篇博客中提到的Faster R-CNN的每秒7帧，拥有更高的准确率。
  我们来看看SSD是做了哪些改进得到云云优秀的效果吧！SSD结构图如下所示：

SSD接入 300x300 巨细的图像，起首，通过ImageNet上预训练的分类模子VGG-16（去除末了1000维的全连接层）进行特性提取。
SSD的焦点头脑是，通过差别维度的特性图像，到达猜测差别巨细目标的目标。如上图所示，在VGG-16提取特性之后，通过卷积将特性图像变革为差别巨细和维度的特性图像，如：FC6——FC11。然后，在差别维度的特性图像（检测层）上进行目标检测。
关键在于怎样对不消检测层进行检测。这里作者对每一层设置了差别巨细的anchor，同一层的anchor也有差别的比例，如1:1、1:2、1:3、2:1、3:1。在上述6个差别的检测层中，以每个特性图像的像素点为中心，同一层中每个像素点绘制巨细相同，但有5种比例的anchor。如下图所示：

正由于特性图像的巨细差别，以是纵然巨细相同的anchor得到的特性，再映射回原图像，也会得到巨细差别的原图像截取。于是，SSD通过这种方式就能实现对差别尺寸的目标进行检测。
在每个检测层中，anchor像滑动窗口一样依次滑动，然后再通过 3x3 的卷积连接两个并行层，即分类和框回归。 
颠末上述步骤，再将猜测框和分类概率映射回原图像。通过非极大值避免等使用留下终极的猜测框，与样本框进行偏差计算，再经反向传播更新参数得以训练SSD模子。
   正由于上述所说anchor是作者事先设置好的，针对于每一层都有差别巨细的anchor，以是不必要后期训练，也不必要通过算法进行候选地域的提取，极大进步了目标检测的速率。
  1.2 代码

骨干网络采用在ImageNet上预训练的VGG-16来提取图像特性，下面是SSD网络模子PyTorch代码：

1. import colorsys
2. import os
3. import time
4. import warnings
6. import numpy as np
7. import torch
8. import torch.backends.cudnn as cudnn
9. from PIL import Image, ImageDraw, ImageFont
11. from nets.ssd import SSD300
12. from utils.anchors import get_anchors
13. from utils.utils import (cvtColor, get_classes, preprocess_input, resize_image,
14.                          show_config)
15. from utils.utils_bbox import BBoxUtility
17. warnings.filterwarnings("ignore")
19. #--------------------------------------------#
20. #   使用自己训练好的模型预测需要修改3个参数
21. #   model_path、backbone和classes_path都需要修改！
22. #   如果出现shape不匹配
23. #   一定要注意训练时的config里面的num_classes、
24. #   model_path和classes_path参数的修改
25. #--------------------------------------------#
26. class SSD(object):
27.     _defaults = {
28.         #--------------------------------------------------------------------------#
29.         #   使用自己训练好的模型进行预测一定要修改model_path和classes_path！
30.         #   model_path指向logs文件夹下的权值文件，classes_path指向model_data下的txt
31.         #
32.         #   训练好后logs文件夹下存在多个权值文件，选择验证集损失较低的即可。
33.         #   验证集损失较低不代表mAP较高，仅代表该权值在验证集上泛化性能较好。
34.         #   如果出现shape不匹配，同时要注意训练时的model_path和classes_path参数的修改
35.         #--------------------------------------------------------------------------#
36.         "model_path"        : 'logs/ssd_weights.pth',
37.         "classes_path"      : 'model_data/voc_classes.txt',
38.         #---------------------------------------------------------------------#
39.         #   用于预测的图像大小，和train时使用同一个即可
40.         #---------------------------------------------------------------------#
41.         "input_shape"       : [300, 300],
42.         #-------------------------------#
43.         #   主干网络的选择
44.         #   vgg或者mobilenetv2或者resnet50
45.         #-------------------------------#
46.         "backbone"          : "vgg",
47.         #---------------------------------------------------------------------#
48.         #   只有得分大于置信度的预测框会被保留下来
49.         #---------------------------------------------------------------------#
50.         "confidence"        : 0.5,
51.         #---------------------------------------------------------------------#
52.         #   非极大抑制所用到的nms_iou大小
53.         #---------------------------------------------------------------------#
54.         "nms_iou"           : 0.45,
55.         #---------------------------------------------------------------------#
56.         #   用于指定先验框的大小
57.         #---------------------------------------------------------------------#
58.         'anchors_size'      : [30, 60, 111, 162, 213, 264, 315],
59.         #---------------------------------------------------------------------#
60.         #   该变量用于控制是否使用letterbox_image对输入图像进行不失真的resize，
61.         #   在多次测试后，发现关闭letterbox_image直接resize的效果更好
62.         #---------------------------------------------------------------------#
63.         "letterbox_image"   : False,
64.         #-------------------------------#
65.         #   是否使用Cuda
66.         #   没有GPU可以设置成False
67.         #-------------------------------#
68.         "cuda"              : False,
69.     }
71.     @classmethod
72.     def get_defaults(cls, n):
73.         if n in cls._defaults:
74.             return cls._defaults[n]
75.         else:
76.             return "Unrecognized attribute name '" + n + "'"
78.     #---------------------------------------------------#
79.     #   初始化ssd
80.     #---------------------------------------------------#
81.     def __init__(self, **kwargs):
82.         self.__dict__.update(self._defaults)
83.         for name, value in kwargs.items():
84.             setattr(self, name, value)
85.         #---------------------------------------------------#
86.         #   计算总的类的数量
87.         #---------------------------------------------------#
88.         self.class_names, self.num_classes  = get_classes(self.classes_path)
89.         self.anchors                        = torch.from_numpy(get_anchors(self.input_shape, self.anchors_size, self.backbone)).type(torch.FloatTensor)
90.         if self.cuda:
91.             self.anchors = self.anchors.cuda()
92.         self.num_classes                    = self.num_classes + 1
93.         
94.         #---------------------------------------------------#
95.         #   画框设置不同的颜色
96.         #---------------------------------------------------#
97.         hsv_tuples = [(x / self.num_classes, 1., 1.) for x in range(self.num_classes)]
98.         self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
99.         self.colors = list(map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)), self.colors))
101.         self.bbox_util = BBoxUtility(self.num_classes)
102.         self.generate()
103.         
104.         show_config(**self._defaults)
106.     #---------------------------------------------------#
107.     #   载入模型
108.     #---------------------------------------------------#
109.     def generate(self, onnx=False):
110.         #-------------------------------#
111.         #   载入模型与权值
112.         #-------------------------------#
113.         self.net    = SSD300(self.num_classes, self.backbone)
114.         device      = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
115.         self.net.load_state_dict(torch.load(self.model_path, map_location=device))
116.         self.net    = self.net.eval()
117.         print('{} model, anchors, and classes loaded.'.format(self.model_path))
118.         if not onnx:
119.             if self.cuda:
120.                 self.net = torch.nn.DataParallel(self.net)
121.                 self.net = self.net.cuda()
123.     #---------------------------------------------------#
124.     #   检测图片
125.     #---------------------------------------------------#
126.     def detect_image(self, image, crop = False, count = False):
127.         #---------------------------------------------------#
128.         #   计算输入图片的高和宽
129.         #---------------------------------------------------#
130.         image_shape = np.array(np.shape(image)[0:2])
131.         #---------------------------------------------------------#
132.         #   在这里将图像转换成RGB图像，防止灰度图在预测时报错。
133.         #   代码仅仅支持RGB图像的预测，所有其它类型的图像都会转化成RGB
134.         #---------------------------------------------------------#
135.         image       = cvtColor(image)
136.         #---------------------------------------------------------#
137.         #   给图像增加灰条，实现不失真的resize
138.         #   也可以直接resize进行识别
139.         #---------------------------------------------------------#
140.         image_data  = resize_image(image, (self.input_shape[1], self.input_shape[0]), self.letterbox_image)
141.         #---------------------------------------------------------#
142.         #   添加上batch_size维度，图片预处理，归一化。
143.         #---------------------------------------------------------#
144.         image_data = np.expand_dims(np.transpose(preprocess_input(np.array(image_data, dtype='float32')), (2, 0, 1)), 0)
146.         with torch.no_grad():
147.             #---------------------------------------------------#
148.             #   转化成torch的形式
149.             #---------------------------------------------------#
150.             images = torch.from_numpy(image_data).type(torch.FloatTensor)
151.             if self.cuda:
152.                 images = images.cuda()
153.             #---------------------------------------------------------#
154.             #   将图像输入网络当中进行预测！
155.             #---------------------------------------------------------#
156.             outputs     = self.net(images)
157.             #-----------------------------------------------------------#
158.             #   将预测结果进行解码
159.             #-----------------------------------------------------------#
160.             results     = self.bbox_util.decode_box(outputs, self.anchors, image_shape, self.input_shape, self.letterbox_image,
161.                                                     nms_iou = self.nms_iou, confidence = self.confidence)
162.             #--------------------------------------#
163.             #   如果没有检测到物体，则返回原图
164.             #--------------------------------------#
165.             if len(results[0]) <= 0:
166.                 return image
168.             top_label   = np.array(results[0][:, 4], dtype = 'int32')
169.             top_conf    = results[0][:, 5]
170.             top_boxes   = results[0][:, :4]
171.         #---------------------------------------------------------#
172.         #   设置字体与边框厚度
173.         #---------------------------------------------------------#
174.         font = ImageFont.truetype(font='model_data/simhei.ttf', size=np.floor(3e-2 * np.shape(image)[1] + 0.5).astype('int32'))
175.         thickness = max((np.shape(image)[0] + np.shape(image)[1]) // self.input_shape[0], 1)
176.         #---------------------------------------------------------#
177.         #   计数
178.         #---------------------------------------------------------#
179.         if count:
180.             print("top_label:", top_label)
181.             classes_nums    = np.zeros([self.num_classes])
182.             for i in range(self.num_classes):
183.                 num = np.sum(top_label == i)
184.                 if num > 0:
185.                     print(self.class_names[i], " : ", num)
186.                 classes_nums[i] = num
187.             print("classes_nums:", classes_nums)
188.         #---------------------------------------------------------#
189.         #   是否进行目标的裁剪
190.         #---------------------------------------------------------#
191.         if crop:
192.             for i, c in list(enumerate(top_boxes)):
193.                 top, left, bottom, right = top_boxes[i]
194.                 top     = max(0, np.floor(top).astype('int32'))
195.                 left    = max(0, np.floor(left).astype('int32'))
196.                 bottom  = min(image.size[1], np.floor(bottom).astype('int32'))
197.                 right   = min(image.size[0], np.floor(right).astype('int32'))
198.                
199.                 dir_save_path = "img_crop"
200.                 if not os.path.exists(dir_save_path):
201.                     os.makedirs(dir_save_path)
202.                 crop_image = image.crop([left, top, right, bottom])
203.                 crop_image.save(os.path.join(dir_save_path, "crop_" + str(i) + ".png"), quality=95, subsampling=0)
204.                 print("save crop_" + str(i) + ".png to " + dir_save_path)
205.         #---------------------------------------------------------#
206.         #   图像绘制
207.         #---------------------------------------------------------#
208.         for i, c in list(enumerate(top_label)):
209.             predicted_class = self.class_names[int(c)]
210.             box             = top_boxes[i]
211.             score           = top_conf[i]
213.             top, left, bottom, right = box
215.             top     = max(0, np.floor(top).astype('int32'))
216.             left    = max(0, np.floor(left).astype('int32'))
217.             bottom  = min(image.size[1], np.floor(bottom).astype('int32'))
218.             right   = min(image.size[0], np.floor(right).astype('int32'))
220.             label = '{} {:.2f}'.format(predicted_class, score)
221.             draw = ImageDraw.Draw(image)
222.             label_size = draw.textsize(label, font)
223.             label = label.encode('utf-8')
224.             print(label, top, left, bottom, right)
225.             
226.             if top - label_size[1] >= 0:
227.                 text_origin = np.array([left, top - label_size[1]])
228.             else:
229.                 text_origin = np.array([left, top + 1])
231.             for i in range(thickness):
232.                 draw.rectangle([left + i, top + i, right - i, bottom - i], outline=self.colors[c])
233.             draw.rectangle([tuple(text_origin), tuple(text_origin + label_size)], fill=self.colors[c])
234.             draw.text(text_origin, str(label,'UTF-8'), fill=(0, 0, 0), font=font)
235.             del draw
237.         return image
239.     def get_FPS(self, image, test_interval):
240.         #---------------------------------------------------#
241.         #   计算输入图片的高和宽
242.         #---------------------------------------------------#
243.         image_shape = np.array(np.shape(image)[0:2])
244.         #---------------------------------------------------------#
245.         #   在这里将图像转换成RGB图像，防止灰度图在预测时报错。
246.         #   代码仅仅支持RGB图像的预测，所有其它类型的图像都会转化成RGB
247.         #---------------------------------------------------------#
248.         image       = cvtColor(image)
249.         #---------------------------------------------------------#
250.         #   给图像增加灰条，实现不失真的resize
251.         #   也可以直接resize进行识别
252.         #---------------------------------------------------------#
253.         image_data  = resize_image(image, (self.input_shape[1], self.input_shape[0]), self.letterbox_image)
254.         #---------------------------------------------------------#
255.         #   添加上batch_size维度，图片预处理，归一化。
256.         #---------------------------------------------------------#
257.         image_data = np.expand_dims(np.transpose(preprocess_input(np.array(image_data, dtype='float32')), (2, 0, 1)), 0)
259.         with torch.no_grad():
260.             #---------------------------------------------------#
261.             #   转化成torch的形式
262.             #---------------------------------------------------#
263.             images = torch.from_numpy(image_data).type(torch.FloatTensor)
264.             if self.cuda:
265.                 images = images.cuda()
266.             #---------------------------------------------------------#
267.             #   将图像输入网络当中进行预测！
268.             #---------------------------------------------------------#
269.             outputs     = self.net(images)
270.             #-----------------------------------------------------------#
271.             #   将预测结果进行解码
272.             #-----------------------------------------------------------#
273.             results     = self.bbox_util.decode_box(outputs, self.anchors, image_shape, self.input_shape, self.letterbox_image,
274.                                                     nms_iou = self.nms_iou, confidence = self.confidence)
276.         t1 = time.time()
277.         for _ in range(test_interval):
278.             with torch.no_grad():
279.                 #---------------------------------------------------------#
280.                 #   将图像输入网络当中进行预测！
281.                 #---------------------------------------------------------#
282.                 outputs     = self.net(images)
283.                 #-----------------------------------------------------------#
284.                 #   将预测结果进行解码
285.                 #-----------------------------------------------------------#
286.                 results     = self.bbox_util.decode_box(outputs, self.anchors, image_shape, self.input_shape, self.letterbox_image,
287.                                                         nms_iou = self.nms_iou, confidence = self.confidence)
289.         t2 = time.time()
290.         tact_time = (t2 - t1) / test_interval
291.         return tact_time
293.     def convert_to_onnx(self, simplify, model_path):
294.         import onnx
295.         self.generate(onnx=True)
297.         im                  = torch.zeros(1, 3, *self.input_shape).to('cpu')  # image size(1, 3, 512, 512) BCHW
298.         input_layer_names   = ["images"]
299.         output_layer_names  = ["output"]
300.         
301.         # Export the model
302.         print(f'Starting export with onnx {onnx.__version__}.')
303.         torch.onnx.export(self.net,
304.                         im,
305.                         f               = model_path,
306.                         verbose         = False,
307.                         opset_version   = 12,
308.                         training        = torch.onnx.TrainingMode.EVAL,
309.                         do_constant_folding = True,
310.                         input_names     = input_layer_names,
311.                         output_names    = output_layer_names,
312.                         dynamic_axes    = None)
314.         # Checks
315.         model_onnx = onnx.load(model_path)  # load onnx model
316.         onnx.checker.check_model(model_onnx)  # check onnx model
318.         # Simplify onnx
319.         if simplify:
320.             import onnxsim
321.             print(f'Simplifying with onnx-simplifier {onnxsim.__version__}.')
322.             model_onnx, check = onnxsim.simplify(
323.                 model_onnx,
324.                 dynamic_input_shape=False,
325.                 input_shapes=None)
326.             assert check, 'assert check failed'
327.             onnx.save(model_onnx, model_path)
329.         print('Onnx model save as {}'.format(model_path))
330.    
331.     def get_map_txt(self, image_id, image, class_names, map_out_path):
332.         f = open(os.path.join(map_out_path, "detection-results/"+image_id+".txt"),"w")
333.         #---------------------------------------------------#
334.         #   计算输入图片的高和宽
335.         #---------------------------------------------------#
336.         image_shape = np.array(np.shape(image)[0:2])
337.         #---------------------------------------------------------#
338.         #   在这里将图像转换成RGB图像，防止灰度图在预测时报错。
339.         #   代码仅仅支持RGB图像的预测，所有其它类型的图像都会转化成RGB
340.         #---------------------------------------------------------#
341.         image       = cvtColor(image)
342.         #---------------------------------------------------------#
343.         #   给图像增加灰条，实现不失真的resize
344.         #   也可以直接resize进行识别
345.         #---------------------------------------------------------#
346.         image_data  = resize_image(image, (self.input_shape[1], self.input_shape[0]), self.letterbox_image)
347.         #---------------------------------------------------------#
348.         #   添加上batch_size维度，图片预处理，归一化。
349.         #---------------------------------------------------------#
350.         image_data = np.expand_dims(np.transpose(preprocess_input(np.array(image_data, dtype='float32')), (2, 0, 1)), 0)
352.         with torch.no_grad():
353.             #---------------------------------------------------#
354.             #   转化成torch的形式
355.             #---------------------------------------------------#
356.             images = torch.from_numpy(image_data).type(torch.FloatTensor)
357.             if self.cuda:
358.                 images = images.cuda()
359.             #---------------------------------------------------------#
360.             #   将图像输入网络当中进行预测！
361.             #---------------------------------------------------------#
362.             outputs     = self.net(images)
363.             #-----------------------------------------------------------#
364.             #   将预测结果进行解码
365.             #-----------------------------------------------------------#
366.             results     = self.bbox_util.decode_box(outputs, self.anchors, image_shape, self.input_shape, self.letterbox_image,
367.                                                     nms_iou = self.nms_iou, confidence = self.confidence)
368.             #--------------------------------------#
369.             #   如果没有检测到物体，则返回原图
370.             #--------------------------------------#
371.             if len(results[0]) <= 0:
372.                 return
374.             top_label   = np.array(results[0][:, 4], dtype = 'int32')
375.             top_conf    = results[0][:, 5]
376.             top_boxes   = results[0][:, :4]
377.         
378.         for i, c in list(enumerate(top_label)):
379.             predicted_class = self.class_names[int(c)]
380.             box             = top_boxes[i]
381.             score           = str(top_conf[i])
383.             top, left, bottom, right = box
384.             if predicted_class not in class_names:
385.                 continue
387.             f.write("%s %s %s %s %s %s\n" % (predicted_class, score[:6], str(int(left)), str(int(top)), str(int(right)),str(int(bottom))))
389.         f.close()
390.         return

复制代码

采用图片进行猜测：

1. #-----------------------------------------------------------------------#
2. #   predict.py将单张图片预测、摄像头检测、FPS测试和目录遍历检测等功能
3. #   整合到了一个py文件中，通过指定mode进行模式的修改。
4. #-----------------------------------------------------------------------#
5. import time
6. import cv2
7. import numpy as np
8. from PIL import Image
9. from matplotlib import pyplot as plt
11. from ssd import SSD
13. if __name__ == "__main__":
14.     ssd = SSD()
15.     #----------------------------------------------------------------------------------------------------------#
16.     #   mode用于指定测试的模式：
17.     #   'predict'           表示单张图片预测，如果想对预测过程进行修改，如保存图片，截取对象等，可以先看下方详细的注释
18.     #   'video'             表示视频检测，可调用摄像头或者视频进行检测，详情查看下方注释。
19.     #   'fps'               表示测试fps，使用的图片是img里面的street.jpg，详情查看下方注释。
20.     #   'dir_predict'       表示遍历文件夹进行检测并保存。默认遍历img文件夹，保存img_out文件夹，详情查看下方注释。
21.     #   'export_onnx'       表示将模型导出为onnx，需要pytorch1.7.1以上。
22.     #----------------------------------------------------------------------------------------------------------#
23.     mode = "predict"
24.     #-------------------------------------------------------------------------#
25.     #   crop                指定了是否在单张图片预测后对目标进行截取
26.     #   count               指定了是否进行目标的计数
27.     #   crop、count仅在mode='predict'时有效
28.     #-------------------------------------------------------------------------#
29.     crop            = False
30.     count           = False
31.     #----------------------------------------------------------------------------------------------------------#
32.     #   video_path          用于指定视频的路径，当video_path=0时表示检测摄像头
33.     #                       想要检测视频，则设置如video_path = "xxx.mp4"即可，代表读取出根目录下的xxx.mp4文件。
34.     #   video_save_path     表示视频保存的路径，当video_save_path=""时表示不保存
35.     #                       想要保存视频，则设置如video_save_path = "yyy.mp4"即可，代表保存为根目录下的yyy.mp4文件。
36.     #   video_fps           用于保存的视频的fps
37.     #
38.     #   video_path、video_save_path和video_fps仅在mode='video'时有效
39.     #   保存视频时需要ctrl+c退出或者运行到最后一帧才会完成完整的保存步骤。
40.     #----------------------------------------------------------------------------------------------------------#
41.     video_path      = 0
42.     video_save_path = ""
43.     video_fps       = 25.0
44.     #----------------------------------------------------------------------------------------------------------#
45.     #   test_interval       用于指定测量fps的时候，图片检测的次数。理论上test_interval越大，fps越准确。
46.     #   fps_image_path      用于指定测试的fps图片
47.     #   
48.     #   test_interval和fps_image_path仅在mode='fps'有效
49.     #----------------------------------------------------------------------------------------------------------#
50.     test_interval = 100
51.     fps_image_path = "img/"
52.     #-------------------------------------------------------------------------#
53.     #   dir_origin_path     指定了用于检测的图片的文件夹路径
54.     #   dir_save_path       指定了检测完图片的保存路径
55.     #   
56.     #   dir_origin_path和dir_save_path仅在mode='dir_predict'时有效
57.     #-------------------------------------------------------------------------#
58.     dir_origin_path = "img/"
59.     dir_save_path = "img_out/"
60.     #-------------------------------------------------------------------------#
61.     #   simplify            使用Simplify onnx
62.     #   onnx_save_path      指定了onnx的保存路径
63.     #-------------------------------------------------------------------------#
64.     simplify        = True
65.     onnx_save_path  = "model_data/models.onnx"
66.    
67.     if mode == "predict":
68.         '''
69.         1、如果想要进行检测完的图片的保存，利用r_image.save("img.jpg")即可保存，直接在predict.py里进行修改即可。
70.         2、如果想要获得预测框的坐标，可以进入ssd.detect_image函数，在绘图部分读取top，left，bottom，right这四个值。
71.         3、如果想要利用预测框截取下目标，可以进入ssd.detect_image函数，在绘图部分利用获取到的top，left，bottom，right这四个值
72.         在原图上利用矩阵的方式进行截取。
73.         4、如果想要在预测图上写额外的字，比如检测到的特定目标的数量，可以进入ssd.detect_image函数，在绘图部分对predicted_class进行判断，
74.         比如判断if predicted_class == 'car': 即可判断当前目标是否为车，然后记录数量即可。利用draw.text即可写字。
75.         '''
76.         while True:
77.             # img = input('Input image filename:')
78.             # try:
79.             #     image = Image.open(img)
80.             # except:
81.             #     print('Open Error! Try again!')
82.             #     continue
83.             # else:
84.             #     r_image = ssd.detect_image(image, crop = crop, count=count)
85.             #     r_image.show()
86.             image = Image.open("img/street.jpg")
87.             plt.imshow(image)
88.             plt.show()
89.             r_image = ssd.detect_image(image, crop=crop, count=count)
90.             plt.imshow(r_image)
91.             plt.show()
93.     elif mode == "video":
94.         capture = cv2.VideoCapture(video_path)
95.         if video_save_path != "":
96.             fourcc = cv2.VideoWriter_fourcc(*'XVID')
97.             size = (int(capture.get(cv2.CAP_PROP_FRAME_WIDTH)), int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT)))
98.             out = cv2.VideoWriter(video_save_path, fourcc, video_fps, size)
100.         ref, frame = capture.read()
101.         if not ref:
102.             raise ValueError("未能正确读取摄像头（视频），请注意是否正确安装摄像头（是否正确填写视频路径）。")
104.         fps = 0.0
105.         while(True):
106.             t1 = time.time()
107.             # 读取某一帧
108.             ref, frame = capture.read()
109.             if not ref:
110.                 break
111.             # 格式转变，BGRtoRGB
112.             frame = cv2.cvtColor(frame,cv2.COLOR_BGR2RGB)
113.             # 转变成Image
114.             frame = Image.fromarray(np.uint8(frame))
115.             # 进行检测
116.             frame = np.array(ssd.detect_image(frame))
117.             # RGBtoBGR满足opencv显示格式
118.             frame = cv2.cvtColor(frame,cv2.COLOR_RGB2BGR)
119.             
120.             fps  = ( fps + (1./(time.time()-t1)) ) / 2
121.             print("fps= %.2f"%(fps))
122.             frame = cv2.putText(frame, "fps= %.2f"%(fps), (0, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
123.             
124.             cv2.imshow("video",frame)
125.             c= cv2.waitKey(1) & 0xff
126.             if video_save_path!="":
127.                 out.write(frame)
129.             if c==27:
130.                 capture.release()
131.                 break
133.         print("Video Detection Done!")
134.         capture.release()
135.         if video_save_path!="":
136.             print("Save processed video to the path :" + video_save_path)
137.             out.release()
138.         cv2.destroyAllWindows()
139.         
140.     elif mode == "fps":
141.         img = Image.open(fps_image_path)
142.         tact_time = ssd.get_FPS(img, test_interval)
143.         print(str(tact_time) + ' seconds, ' + str(1/tact_time) + 'FPS, @batch_size 1')
145.     elif mode == "dir_predict":
146.         import os
148.         from tqdm import tqdm
150.         img_names = os.listdir(dir_origin_path)
151.         for img_name in tqdm(img_names):
152.             if img_name.lower().endswith(('.bmp', '.dib', '.png', '.jpg', '.jpeg', '.pbm', '.pgm', '.ppm', '.tif', '.tiff')):
153.                 image_path = os.path.join(dir_origin_path, img_name)
154.                 image = Image.open(image_path)
155.                 r_image = ssd.detect_image(image)
156.                 if not os.path.exists(dir_save_path):
157.                     os.makedirs(dir_save_path)
158.                 r_image.save(os.path.join(dir_save_path, img_name.replace(".jpg", ".png")), quality=95, subsampling=0)
160.     elif mode == "export_onnx":
161.         ssd.convert_to_onnx(simplify, onnx_save_path)
162.         
163.     else:
164.         raise AssertionError("Please specify the correct mode: 'predict', 'video', 'fps' or 'dir_predict'.")

复制代码

  代码猜测效果如下：
  

• 输入图像
  

  

• 猜测效果 
  

  

  

猜测的准确率照旧异常高的，但是猜测的时间照旧有点长。

  

二、YOLO

这次我紧张学习了YOLO-v1，由于YOLO是个很大的系列，我这次对其主体头脑进行了学习。SSD是在YOLO-v1之后出来的，比第一版本的YOLO效果好，但是SSD的作者后期没用继承对其优化，但是YOLO不停源源不停更新，如今以高精度、高速率广泛应用于各商业之中。
我们先来看看YOLO和SSD之间有何异同，两个模子网络结构对比图如下所示：

这里我们可以看出，YOLO在提取特性之后，直接进入猜测环节。相比于上面的SSD将特性图像分为6个维度，采用差别尺寸的anchor而言轻便了很多，轻便代表了更易于训练模子，但是准确度会不会仍然可以可能保持较高水准呢？让我们先来相知趣识YOLO的原理吧。

YOLO是将图像分为 7x7 的网格，每个网格就类似于感爱好地域。假如某个目标的中心在这个网格之中，则该网格负责猜测这个目标。 每个网格必要猜测B个bounding box，每个bounding box除了猜测目标框位置外，还必要附带confidence值，以及C个种别的猜测分数。

我们先看看YOLO模子的团体过程，继承 448x448 巨细的图像输入，颠末卷积、池化等使用得到 7x7x1024 的特性图像，将其展平后连接4096维的全连接层，得到4096维的特性向量。末了，在接入一个1470维（7x7x30）的全连接层后，将其reshape为 7x7x30 的特性图像，即上图结构中最右侧。
这里的 7x7x30 的特性图像对应了原图像 7x7=49 个网格，即每30维的特性向量代表着每个表格猜测值。由于这30不是凭空出现的，而是B=2，即猜测两个bounding box，每个bounding  box有4个值（x，y，w，h）；以及一个confidence值，conference值代表猜测的目标框与真实框的交并比IoU。又由于VOC数据集种别为20类，以是c=20。于是，

。
用一张图片来资助明确，如下所示：

YOLO的bounding box猜测的坐标是直接猜测原图对应的位置，再加上整个网络没有使用anchor，直接将图像分为49个网格，以是速率特殊快，可以可能到达45FPS。也因此可想而知，一定捐躯一些准确率，比使用anchor的SSD准确率低。这也回应开篇的疑问，同时也暗示了YOLO系列后期的优化门路。 下周还会继承完成YOLO系列的学习。
末了，我们再来看看YOLO模子的丧失计算吧。

可能会迷惑在计算bounding box丧失时，为什么计算w和h时，必要先开根号。

由于假如两个巨细差别的框，但是w和h相差相同，假如不进行开根号使用，则计算出来的偏差是相同的。这显然不符合逻辑，由于

对应的框更小，纵然

，其相对于框的偏差偏移是更大的，以是必要先进行开根号使用，如上图左侧坐标所示。

三、Termius

英文必要频仍使用租用的服务器，但服务器管理又比力麻烦，上传数据也会消耗很多时间。于是，我学习使用了Termius，用以管理服务器数据，便于数据传输，同时团结PyCharm实现当地与远程服务器之间同步使用。

 起首，点击NEW HOST就可以创建一个新的服务器连接。

输入服务器ip地点，以及用户名、密码和端标语，就可以进行服务器连接了。
连接乐成之后，会主动进入服务器终端界面，如下图所示：

点击SFTP，便可进行服务器端和当地之间的数据传输界面，如下图所示：

直接拖已往，就能实现服务器端和当地直接的数据传输，大大进步了速率。
然后，确保您的PyCharm已通过SSH连接到远程服务器，然后通过下图的使用，就可以可能看到刚才通过Termius上传到远程服务器的代码和数据。

假如想同步到当地，在当地进行修改等使用，可以从服务器端将文件下载到当地，使用如下：

统统就大功告成啦，可以在当地调试，然后通过远程服务器的资源训练自己的模子了。
 
总结

本周的学习到此竣事，下周将学习YOLO系列更新最大的几个版本，以及如今使用最为广泛的版本，并乐成跑通其代码。
如有错误，请各位大佬提出，谢谢！