目錄

• • 1、需求解讀
  • 2、YOLOv5算法簡介
  • 3、YOLOv5算法詳解
  • • 3.1 YOLOv5網絡架構
    • 3.2 YOLOv5實現細節詳解
    • • 3.2.1 YOLOv5基礎組件
      • 3.2.2 輸入端細節詳解
      • 3.2.3 基準網絡細節詳解
      • 3.2.4 Neck網絡細節詳解
      • 3.2.5 Head輸出端細節詳解
  • 4、YOLOv5網絡代碼實現
  • 5、YOLOv5效果展示與分析
  • • 5.1、YOLOv5客觀效果展示與分析
    • 5.2、YOLOv5主觀效果展示與分析
  • 6、總結與分析
  • 參考資料
  • 注意事項

1、需求解讀

??YOLOV4出現之后不久，YOLOv5橫空出世。YOLOv5在YOLOv4算法的基礎上做了進一步的改進，檢測性能得到進一步的提升。雖然YOLOv5算法并沒有與YOLOv4算法進行性能比較與分析，但是YOLOv5在COCO數據集上面的測試效果還是挺不錯的。大家對YOLOv5算法的創新性半信半疑，有的人對其持肯定態度，有的人對其持否定態度。在我看來，YOLOv5檢測算法中還是存在很多可以學習的地方，雖然這些改進思路看來比較簡單或者創新點不足，但是它們確定可以提升檢測算法的性能。其實工業界往往更喜歡使用這些方法，而不是利用一個超級復雜的算法來獲得較高的檢測精度。本文將對YOLOv5檢測算法中提出的改進思路進行詳細的解說，大家可以嘗試者將這些改進思路應用到其它的目標檢測算法中。

2、YOLOv5算法簡介

??YOLOv5是一種單階段目標檢測算法，該算法在YOLOv4的基礎上添加了一些新的改進思路，使其速度與精度都得到了極大的性能提升。主要的改進思路如下所示：

• 輸入端：在模型訓練階段，提出了一些改進思路，主要包括Mosaic數據增強、自適應錨框計算、自適應圖片縮放；
• 基準網絡：融合其它檢測算法中的一些新思路，主要包括：Focus結構與CSP結構；
• Neck網絡：目標檢測網絡在BackBone與最后的Head輸出層之間往往會插入一些層，Yolov5中添加了FPN+PAN結構；
• Head輸出層：輸出層的錨框機制與YOLOv4相同，主要改進的是訓練時的損失函數GIOU_Loss，以及預測框篩選的DIOU_nms。

3、YOLOv5算法詳解

3.1 YOLOv5網絡架構

??上圖展示了YOLOv5目標檢測算法的整體框圖。對于一個目標檢測算法而言，我們通常可以將其劃分為4個通用的模塊，具體包括：輸入端、基準網絡、Neck網絡與Head輸出端，對應于上圖中的4個紅色模塊。YOLOv5算法具有4個版本，具體包括：YOLOv5s、YOLOv5m、YOLOv5l、YOLOv5x四種，本文重點講解YOLOv5s，其它的版本都在該版本的基礎上對網絡進行加深與加寬。

• 輸入端-輸入端表示輸入的圖片。該網絡的輸入圖像大小為608*608，該階段通常包含一個圖像預處理階段，即將輸入圖像縮放到網絡的輸入大小，并進行歸一化等操作。在網絡訓練階段，YOLOv5使用Mosaic數據增強操作提升模型的訓練速度和網絡的精度；并提出了一種自適應錨框計算與自適應圖片縮放方法。
• 基準網絡-基準網絡通常是一些性能優異的分類器種的網絡，該模塊用來提取一些通用的特征表示。YOLOv5中不僅使用了CSPDarknet53結構，而且使用了Focus結構作為基準網絡。
• Neck網絡-Neck網絡通常位于基準網絡和頭網絡的中間位置，利用它可以進一步提升特征的多樣性及魯棒性。雖然YOLOv5同樣用到了SPP模塊、FPN+PAN模塊，但是實現的細節有些不同。
• Head輸出端-Head用來完成目標檢測結果的輸出。針對不同的檢測算法，輸出端的分支個數不盡相同，通常包含一個分類分支和一個回歸分支。YOLOv4利用GIOU_Loss來代替Smooth L1 Loss函數，從而進一步提升算法的檢測精度。

3.2 YOLOv5實現細節詳解

3.2.1 YOLOv5基礎組件

• CBL-CBL模塊由Conv+BN+Leaky_relu激活函數組成，如上圖中的模塊1所示。
• Res unit-借鑒ResNet網絡中的殘差結構，用來構建深層網絡，CBM是殘差模塊中的子模塊，如上圖中的模塊2所示。
• CSP1_X-借鑒CSPNet網絡結構，該模塊由CBL模塊、Res unint模塊以及卷積層、Concate組成而成，如上圖中的模塊3所示。
• CSP2_X-借鑒CSPNet網絡結構，該模塊由卷積層和X個Res unint模塊Concate組成而成，如上圖中的模塊4所示。
• Focus-如上圖中的模塊5所示，Focus結構首先將多個slice結果Concat起來，然后將其送入CBL模塊中。
• SPP-采用1×1、5×5、9×9和13×13的最大池化方式，進行多尺度特征融合，如上圖中的模塊6所示。

3.2.2 輸入端細節詳解

• Mosaic數據增強-YOLOv5中在訓練模型階段仍然使用了Mosaic數據增強方法，該算法是在CutMix數據增強方法的基礎上改進而來的。CutMix僅僅利用了兩張圖片進行拼接，而Mosaic數據增強方法則采用了4張圖片，并且按照隨機縮放、隨機裁剪和隨機排布的方式進行拼接而成，具體的效果如下圖所示。這種增強方法可以將幾張圖片組合成一張，這樣不僅可以豐富數據集的同時極大的提升網絡的訓練速度，而且可以降低模型的內存需求。
  
• 自適應錨框計算-在YOLO系列算法中，針對不同的數據集，都需要設定特定長寬的錨點框。在網絡訓練階段，模型在初始錨點框的基礎上輸出對應的預測框，計算其與GT框之間的差距，并執行反向更新操作，從而更新整個網絡的參數，因此設定初始錨點框也是比較關鍵的一環。在YOLOv3和YOLOv4檢測算法中，訓練不同的數據集時，都是通過單獨的程序運行來獲得初始錨點框。YOLOv5中將此功能嵌入到代碼中，每次訓練時，根據數據集的名稱自適應的計算出最佳的錨點框，用戶可以根據自己的需求將功能關閉或者打開，具體的指令為parser.add_argument(’–noautoanchor’, action=‘store_ true’, help=‘disable autoanchor check’)，如果需要打開，只需要在訓練代碼時增加–noautoanch or選項即可。
• 自適應圖片縮放-針對不同的目標檢測算法而言，我們通常需要執行圖片縮放操作，即將原始的輸入圖片縮放到一個固定的尺寸，再將其送入檢測網絡中。YOLO系列算法中常用的尺寸包括416*416，608 *608等尺寸。原始的縮放方法存在著一些問題，由于在實際的使用中的很多圖片的長寬比不同，因此縮放填充之后，兩端的黑邊大小都不相同，然而如果填充的過多，則會存在大量的信息冗余，從而影響整個算法的推理速度。為了進一步提升YOLOv5算法的推理速度，該算法提出一種方法能夠自適應的添加最少的黑邊到縮放之后的圖片中。具體的實現步驟如下所述。
  步驟1-根據原始圖片大小與輸入到網絡圖片大小計算縮放比例。
  
  步驟2-根據原始圖片大小與縮放比例計算縮放后的圖片大小。
  
  步驟3-計算黑邊填充數值。
  
  ??如上圖所示，416表示YOLOv5網絡所要求的圖片寬度，312表示縮放后圖片的寬度。首先執行相減操作來獲得需要填充的黑邊長度104；然后對該數值執行取余操作，即104%32=8，使用32是因為整個YOLOv5網絡執行了5次下采樣操作，即$2^5=32$；最后對該數值除以2，即將填充的區域分散到兩邊。這樣將416*416大小的圖片縮小到416*320大小，因而極大的提升了算法的推理速度。
  ??需要注意的是：（1）該操作僅在模型推理階段執行，模型訓練階段仍然和傳統的方法相同，將原始圖片裁剪到416*416大小；(2)YOLOv3與YOLOv4中默認填充的數值是(0,0,0)，而YOLOv5中默認填充的數值是(114,114,114)；（3）該操作僅僅針對原始圖片的短邊而言，仍然將長邊裁剪到416。

3.2.3 基準網絡細節詳解

• Focus結構-該結構的主要思想是通過slice操作來對輸入圖片進行裁剪。如下圖所示，原始輸入圖片大小為608*608*3，經過Slice與Concat操作之后輸出一個304*304*12的特征映射；接著經過一個通道個數為32的Conv層（該通道個數僅僅針對的是YOLOv5s結構，其它結構會有相應的變化），輸出一個304*304*32大小的特征映射。
  
• CSP結構-YOLOv4網絡結構中，借鑒了CSPNet的設計思路，僅僅在主干網絡中設計了CSP結構。而YOLOv5中設計了兩種CSP結構，以YOLOv5s網絡為例，CSP1_X結構應用于Backbone主干網絡中，另一種CSP2_X結構則應用于Neck網絡中。CSP1_X與CSP2_X模塊的實現細節如3.1所示。

3.2.4 Neck網絡細節詳解

• FPN+PAN-YOLOv5的Neck網絡仍然使用了FPN+PAN結構，但是在它的基礎上做了一些改進操作，YOLOv4的Neck結構中，采用的都是普通的卷積操作。而YOLOv5的Neck網絡中，采用借鑒CSPnet設計的CSP2結構，從而加強網絡特征融合能力。下圖展示了YOLOv4與YOLOv5的Neck網絡的具體細節，通過比較我們可以發現：（1）灰色區域表示第1個不同點，YOLOv5不僅利用CSP2_\1結構代替部分CBL模塊，而且去掉了下方的CBL模塊；（2）綠色區域表示第2個不同點，YOLOv5不僅將Concat操作之后的CBL模塊更換為CSP2_1模塊，而且更換了另外一個CBL模塊的位置；（3）藍色區域表示第3個不同點，YOLOv5中將原始的CBL模塊更換為CSP2_1模塊。
  

3.2.5 Head輸出端細節詳解

• GIoU_Loss-YOLOv5中采用GIoU_Loss做Bounding box的損失函數，更多的細節請參考這篇博客。

4、YOLOv5網絡代碼實現

# 檢測類 class Detect(nn.Module):stride = None # strides computed during buildexport = False # onnx exportdef __init__(self, nc=80, anchors=(), ch=()): # detection layersuper(Detect, self).__init__()self.nc = nc # number of classesself.no = nc + 5 # number of outputs per anchorself.nl = len(anchors) # number of detection layersself.na = len(anchors[0]) // 2 # number of anchorsself.grid = [torch.zeros(1)] * self.nl # init grida = torch.tensor(anchors).float().view(self.nl, -1, 2)self.register_buffer('anchors', a) # shape(nl,na,2)self.register_buffer('anchor_grid', a.clone().view(self.nl, 1, -1, 1, 1, 2)) # shape(nl,1,na,1,1,2)self.m = nn.ModuleList(nn.Conv2d(x, self.no * self.na, 1) for x in ch) # output convdef forward(self, x):# x = x.copy() # for profilingz = [] # inference outputself.training |= self.exportfor i in range(self.nl):x[i] = self.m[i](x[i]) # convbs, _, ny, nx = x[i].shape # x(bs,255,20,20) to x(bs,3,20,20,85)x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()if not self.training: # inferenceif self.grid[i].shape[2:4] != x[i].shape[2:4]:self.grid[i] = self._make_grid(nx, ny).to(x[i].device)y = x[i].sigmoid()y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i].to(x[i].device)) * self.stride[i] # xyy[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i] # whz.append(y.view(bs, -1, self.no))return x if self.training else (torch.cat(z, 1), x)@staticmethoddef _make_grid(nx=20, ny=20):yv, xv = torch.meshgrid([torch.arange(ny), torch.arange(nx)])return torch.stack((xv, yv), 2).view((1, 1, ny, nx, 2)).float()# 根據配置的.yaml文件搭建模型 class Model(nn.Module):def __init__(self, cfg='yolov5s.yaml', ch=3, nc=None): # model, input channels, number of classessuper(Model, self).__init__()if isinstance(cfg, dict):self.yaml = cfg # model dictelse: # is *.yamlimport yaml # for torch hubself.yaml_file = Path(cfg).namewith open(cfg) as f:self.yaml = yaml.load(f, Loader=yaml.SafeLoader) # model dict# Define modelch = self.yaml['ch'] = self.yaml.get('ch', ch) # input channelsif nc and nc != self.yaml['nc']:logger.info('Overriding model.yaml nc=%g with nc=%g' % (self.yaml['nc'], nc))self.yaml['nc'] = nc # override yaml valueself.model, self.save = parse_model(deepcopy(self.yaml), ch=[ch]) # model, savelistself.names = [str(i) for i in range(self.yaml['nc'])] # default names# print([x.shape for x in self.forward(torch.zeros(1, ch, 64, 64))])# Build strides, anchorsm = self.model[-1] # Detect()if isinstance(m, Detect):s = 256 # 2x min stridem.stride = torch.tensor([s / x.shape[-2] for x in self.forward(torch.zeros(1, ch, s, s))]) # forwardm.anchors /= m.stride.view(-1, 1, 1)check_anchor_order(m)self.stride = m.strideself._initialize_biases() # only run once# print('Strides: %s' % m.stride.tolist())# Init weights, biasesinitialize_weights(self)self.info()logger.info('')def forward(self, x, augment=False, profile=False):if augment:img_size = x.shape[-2:] # height, widths = [1, 0.83, 0.67] # scalesf = [None, 3, None] # flips (2-ud, 3-lr)y = [] # outputsfor si, fi in zip(s, f):xi = scale_img(x.flip(fi) if fi else x, si, gs=int(self.stride.max()))yi = self.forward_once(xi)[0] # forward# cv2.imwrite(f'img_{si}.jpg', 255 * xi[0].cpu().numpy().transpose((1, 2, 0))[:, :, ::-1]) # saveyi[..., :4] /= si # de-scaleif fi == 2:yi[..., 1] = img_size[0] - yi[..., 1] # de-flip udelif fi == 3:yi[..., 0] = img_size[1] - yi[..., 0] # de-flip lry.append(yi)return torch.cat(y, 1), None # augmented inference, trainelse:return self.forward_once(x, profile) # single-scale inference, traindef forward_once(self, x, profile=False):y, dt = [], [] # outputsfor m in self.model:if m.f != -1: # if not from previous layerx = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f] # from earlier layersif profile:o = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 if thop else 0 # FLOPSt = time_synchronized()for _ in range(10):_ = m(x)dt.append((time_synchronized() - t) * 100)print('%10.1f%10.0f%10.1fms %-40s' % (o, m.np, dt[-1], m.type))x = m(x) # runy.append(x if m.i in self.save else None) # save outputif profile:print('%.1fms total' % sum(dt))return xdef _initialize_biases(self, cf=None): # initialize biases into Detect(), cf is class frequency# https://arxiv.org/abs/1708.02002 section 3.3# cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.m = self.model[-1] # Detect() modulefor mi, s in zip(m.m, m.stride): # fromb = mi.bias.view(m.na, -1) # conv.bias(255) to (3,85)b.data[:, 4] += math.log(8 / (640 / s) ** 2) # obj (8 objects per 640 image)b.data[:, 5:] += math.log(0.6 / (m.nc - 0.99)) if cf is None else torch.log(cf / cf.sum()) # clsmi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)def _print_biases(self):m = self.model[-1] # Detect() modulefor mi in m.m: # fromb = mi.bias.detach().view(m.na, -1).T # conv.bias(255) to (3,85)print(('%6g Conv2d.bias:' + '%10.3g' * 6) % (mi.weight.shape[1], *b[:5].mean(1).tolist(), b[5:].mean()))# def _print_weights(self):# for m in self.model.modules():# if type(m) is Bottleneck:# print('%10.3g' % (m.w.detach().sigmoid() * 2)) # shortcut weightsdef fuse(self): # fuse model Conv2d() + BatchNorm2d() layersprint('Fusing layers... ')for m in self.model.modules():if type(m) is Conv and hasattr(m, 'bn'):m.conv = fuse_conv_and_bn(m.conv, m.bn) # update convdelattr(m, 'bn') # remove batchnormm.forward = m.fuseforward # update forwardself.info()return selfdef nms(self, mode=True): # add or remove NMS modulepresent = type(self.model[-1]) is NMS # last layer is NMSif mode and not present:print('Adding NMS... ')m = NMS() # modulem.f = -1 # fromm.i = self.model[-1].i + 1 # indexself.model.add_module(name='%s' % m.i, module=m) # addself.eval()elif not mode and present:print('Removing NMS... ')self.model = self.model[:-1] # removereturn selfdef autoshape(self): # add autoShape moduleprint('Adding autoShape... ')m = autoShape(self) # wrap modelcopy_attr(m, self, include=('yaml', 'nc', 'hyp', 'names', 'stride'), exclude=()) # copy attributesreturn mdef info(self, verbose=False, img_size=640): # print model informationmodel_info(self, verbose, img_size)# 解析模型 def parse_model(d, ch): # model_dict, input_channels(3)logger.info('\n%3s%18s%3s%10s %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors # number of anchorsno = na * (nc + 5) # number of outputs = anchors * (classes + 5)layers, save, c2 = [], [], ch[-1] # layers, savelist, ch outfor i, (f, n, m, args) in enumerate(d['backbone'] + d['head']): # from, number, module, argsm = eval(m) if isinstance(m, str) else m # eval stringsfor j, a in enumerate(args):try:args[j] = eval(a) if isinstance(a, str) else a # eval stringsexcept:passn = max(round(n * gd), 1) if n > 1 else n # depth gainif m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, DWConv, MixConv2d, Focus, CrossConv, BottleneckCSP,C3]:c1, c2 = ch[f], args[0]# Normal# if i > 0 and args[0] != no: # channel expansion factor# ex = 1.75 # exponential (default 2.0)# e = math.log(c2 / ch[1]) / math.log(2)# c2 = int(ch[1] * ex ** e)# if m != Focus:c2 = make_divisible(c2 * gw, 8) if c2 != no else c2# Experimental# if i > 0 and args[0] != no: # channel expansion factor# ex = 1 + gw # exponential (default 2.0)# ch1 = 32 # ch[1]# e = math.log(c2 / ch1) / math.log(2) # level 1-n# c2 = int(ch1 * ex ** e)# if m != Focus:# c2 = make_divisible(c2, 8) if c2 != no else c2args = [c1, c2, *args[1:]]if m in [BottleneckCSP, C3]:args.insert(2, n)n = 1elif m is nn.BatchNorm2d:args = [ch[f]]elif m is Concat:c2 = sum([ch[x if x < 0 else x + 1] for x in f])elif m is Detect:args.append([ch[x + 1] for x in f])if isinstance(args[1], int): # number of anchorsargs[1] = [list(range(args[1] * 2))] * len(f)elif m is Contract:c2 = ch[f if f < 0 else f + 1] * args[0] ** 2elif m is Expand:c2 = ch[f if f < 0 else f + 1] // args[0] ** 2else:c2 = ch[f if f < 0 else f + 1]m_ = nn.Sequential(*[m(*args) for _ in range(n)]) if n > 1 else m(*args) # modulet = str(m)[8:-2].replace('__main__.', '') # module typenp = sum([x.numel() for x in m_.parameters()]) # number paramsm_.i, m_.f, m_.type, m_.np = i, f, t, np # attach index, 'from' index, type, number paramslogger.info('%3s%18s%3s%10.0f %-40s%-30s' % (i, f, n, np, t, args)) # printsave.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1) # append to savelistlayers.append(m_)ch.append(c2)return nn.Sequential(*layers), sorted(save)

5、YOLOv5效果展示與分析

5.1、YOLOv5客觀效果展示與分析

??上圖展示了不同版本的YOLOv5與EfficientDet檢測算法之間的性能比較曲線圖。橫軸表示的是該算法在GPU上面的推理時間(ms/img)，該數值越小越好；縱軸表示的是該算法在COCO測試數據集上面的AP指標，該數值越大越好。通過觀察我們可以得出以下的初步結論：（1）與EfficientDet0相比，YOLOv5s不僅可以獲得更高的AP指標，而且可以獲得更快的推理速度；（2）與EfficientDet4相比，YOLOv5x不僅能夠獲得更高的AP指標，其推理速度是它的1/5左右。

??上表展示了不同版本的YOLOv5檢測算法在COCO2017驗證集與測試集上面的各項指標，具體包括：模型輸入大小、AP50指標、Speed、FPS、params與GFLOPS。通過觀察我們可以得出以下的初步結論：（1）YOLOv5s的輸入圖片分辨率為640*640，在COCO測試集與驗證集上面的AP指標為36.8，AP50指標為55.6。該算法在V100 GPU上面的推理速度僅僅需要2.2ms，幀率為455FPS，該網絡的模型大小僅為7.3M；（2）YOLOv5x的輸入圖像分辨率為640*640，在COCO測試集與驗證集上面的AP指標為50.1，AP50指標為68.7。該算法在V100 GPU上面的推理速度僅僅需要6.0ms，幀率為167FPS，該網絡的模型大小為87.7M。（3）我們可以根據現實場景的需要選擇合適的模型，如果我們關注速度的話可以選擇YOLOv5s模型；如果我們關注精度的話可以選擇YOLOv5x模型。

5.2、YOLOv5主觀效果展示與分析

yolov5 行人檢測_車輛檢測_電動車檢測識別_交通標志識別

yolo5 車輛行人檢測

6、總結與分析

??YOLOv5是一種單階段目標檢測算法，該算法在YOLOv4的基礎上添加了一些新的改進思路，使得其速度與精度都得到了極大的性能提升，具體包括：輸入端的Mosaic數據增強、自適應錨框計算、自適應圖片縮放操作；基準端的Focus結構與CSP結構；Neck端的SPP與FPN+PAN結構；輸出端的損失函數GIOU_Loss以及預測框篩選的DIOU_nms。除此之外，YOLOv5中的各種改進思路仍然可以應用到其它的目標檢測算法中。

參考資料

[1] 博客鏈接1

注意事項

[1] 該博客是本人原創博客，如果您對該博客感興趣，想要轉載該博客，請與我聯系（qq郵箱：1575262785@qq.com）,我會在第一時間回復大家，謝謝大家的關注。
[2] 由于個人能力有限，該博客可能存在很多的問題，希望大家能夠提出改進意見。
[3] 如果您在閱讀本博客時遇到不理解的地方，希望您可以聯系我，我會及時的回復您，和您交流想法和意見，謝謝。
[4] 本文中部分圖像的版權歸江大白所有。

總結

以上是生活随笔為你收集整理的YOLOv5算法详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。