一  
    
    
 、前言

YOLO系列框架凭借其超高的运行流畅度和不俗的准确率  
    
    
 ，一直被广泛地应用到各个领域    
    
    
。

刚刚推出不久的YOLOV7在5 FPS到160 FPS范围内的速度和精度达到了新的高度

     


     


     ，并在GPU V100上具有30 FPS或更高的所有已知实时目标检测器中具有最高的精度56.8%AP   


     


     


 。YOLOv7-E6目标检测器（56 FPS V100 




 




 




，55.9% AP）比基于Transform的检测器SWINL Cascade-Mask R-CNN（9.2 FPS A100  

   

   

，53.9% AP）的速度和准确度分别高出509%和2%

     

     

     ，以及基于卷积的检测器ConvNeXt-XL Cascade-Mask R-CNN (8.6 FPS A100, 55.2% AP) 速度提高551%  




  




  



，准确率提高0.7%



 




 




 。以及YOLOv7的表现优于：YOLOR

     


     


     、YOLOX 




 




 




、Scaled-YOLOv4  

   

   

、YOLOv5

     

     

     、DETR  




  




  



、Deformable DETR , DINO-5scale-R50, ViT-Adapter-B和许多其他目标检测器在速度和准确度上   

   

   

。

此外  


  


  


，研究者只在MS COCO数据集上从头开始训练YOLOv7
     
     
    ，而不使用任何其他数据集或预训练的权重    

     

     

。

论文地址：https://arxiv.org/pdf/2207.02696.pdf

github地址：GitHub - WongKinYiu/yolov7: Implementation of paper - YOLOv7: Trainable bag-of-freebies sets new state-of-the-art for real-time object detectors

作为目标检测领域的一种框架
   




   




   


，YOLOV7能在超低延时的情况下 



 



 



，还能把准确率提升一个层次              ，效果相当惊人




  




  




  。在识别过程中

    




    




    

，将视频流中每一帧图像中的信息进行提取














，获得待检测目标的识别种类  


  


  


、具体坐标
     
     
    、置信度等              ，这些信息可以应用到工业环境下的多个方向

     



     



     
，比如：协助机械臂来实现精准夹取














，协助无人车进行货物的运输和夹取  
    
    
 ，监控控制报警器等等

     


     


     ，用途广泛  


  


  

。

二
   




   




   


、整体制作过程

1.起因

YOLOV7的原始代码argparse库进行封装 




 




 




，让大多数的小白凭借终端命令行可以快速地运行代码查看效果  

   

   

，但是只运行代码而不能获取相关的信息来进一步控制一些硬件

     

     

     ，这样的代码是难以落地到实际使用中去的     
     
     
。

于是  




  




  



，如何将detect.py即实时检测代码制作成API是个问题




   




   




  。只有制作成可调用的API  


  


  


，使得其他python程序可以快速调用
     
     
    ，且在识别的过程中
   




   




   


，还能实时超低延时地获取到识别到的信息（包括：识别到的种类 



 



 



、目标的大致二维坐标 



 



 



，置信度）              ，通过这些信息再来编写相关的硬件控制代码来控制下位机（比如：arduino              、STM32等）

    




    




    

，进而实现一定的自动化控制功能
 



 



 

。

2.爆改detect.py的大致思路

将原始代码中使用 argparse库 封装的部分删去














，尝试使用面向对象编程中的类来封装；原始的detect.py中还包含很多与其核心识别功能无关的部分              ，包括：对识别结果的保存等

     



     



     
，我们的目标是制作出来的 API 还能保持原来的识别流畅度














，于是我只保留进行核心识别的部分               。

原本我采用的思路通过 OpenCV 将摄像头的图像保存到某个文件夹下  
    
    
 ，再将图像导入 YOLOV7 中来实现识别

     


     


     ，这样通过图像文件作为中介 




 




 




，运行时还有考虑到读取和保存图像所用的时间  

   

   

，尝试后发现识别相当卡顿

     

     

     ，无法应用到实际场景 




    




    




  。于是  




  




  



，我删除了原始代码中的调用摄像头的代码  


  


  


，在调用程序中来调用摄像头图像
     
     
    ，以 Mat 的格式传输到 API 中
   




   




   


，再将得到的识别信息 return 到调用函数中 



 



 



，大大提高了运行速率













。

3.代码

保留原始框架下的大部分代码              ，只修改和新增几个部分

    




    




    

，分别是：

新建一个   detect_with_API.py    文件来代替原始的    detect.py   文件

import torch from numpy import random from models.experimental import attempt_load from utils.datasets import MyLoadImages from utils.general import check_img_size, non_max_suppression, apply_classifier, \ scale_coords, set_logging from utils.plots import plot_one_box from utils.torch_utils import select_device, load_classifier class simulation_opt: def __init__(self, weights=models/yolov7.pt, img_size = 640, conf_thres = 0.25, iou_thres = 0.45,device=, view_img= False, classes = None, agnostic_nms = False, augment = False, update = False, exist_ok = False): self.weights = weights self.source = None self.img_size = img_size self.conf_thres = conf_thres self.iou_thres = iou_thres self.device = device self.view_img = view_img self.classes = classes self.agnostic_nms = agnostic_nms self.augment =augment self.update = update self.exist_ok = exist_ok class detectapi: def __init__(self, weights, img_size=640): self.opt = simulation_opt(weights=weights, img_size=img_size) weights, imgsz = self.opt.weights, self.opt.img_size # Initialize set_logging() self.device = select_device(self.opt.device) self.half = self.device.type != cpu # half precision only supported on CUDA # Load model self.model = attempt_load(weights, map_location=self.device) # load FP32 model self.stride = int(self.model.stride.max()) # model stride self.imgsz = check_img_size(imgsz, s=self.stride) # check img_size if self.half: self.model.half() # to FP16 # Second-stage classifier self.classify = False if self.classify: self.modelc = load_classifier(name=resnet101, n=2) # initialize self.modelc.load_state_dict(torch.load(weights/resnet101.pt, map_location=self.device)[model]).to(self.device).eval() # read names and colors self.names = self.model.module.names if hasattr(self.model, module) else self.model.names self.colors = [[random.randint(0, 255) for _ in range(3)] for _ in self.names] def detect(self, source): # 使用时














，调用这个函数 if type(source) != list: raise TypeError(source must be a list which contain pictures read by cv2) dataset = MyLoadImages(source, img_size=self.imgsz, stride=self.stride)#imgsz # 原来是通过路径加载数据集的              ，现在source里面就是加载好的图片

     



     



     
，所以数据集对象的实现要 # 重写               。修改代码后附  



     



     



  。在utils.dataset.py上修改













。 # Run inference if self.device.type != cpu: self.model(torch.zeros(1, 3, self.imgsz, self.imgsz).to(self.device).type_as(next(self.model.parameters()))) # run once #t0 = time.time() result = [] for path, img, im0s, vid_cap in dataset: for img, im0s in dataset: img = torch.from_numpy(img).to(self.device) img = img.half() if self.half else img.float() # uint8 to fp16/32 img /= 255.0 # 0 - 255 to 0.0 - 1.0 if img.ndimension() == 3: img = img.unsqueeze(0) # Inference #t1 = time_synchronized() pred = self.model(img, augment=self.opt.augment)[0] # Apply NMS pred = non_max_suppression(pred, self.opt.conf_thres, self.opt.iou_thres, classes=self.opt.classes, agnostic=self.opt.agnostic_nms) #t2 = time_synchronized() # Apply Classifier if self.classify: pred = apply_classifier(pred, self.modelc, img, im0s) # Print time (inference + NMS) #print(f{s}Done. ({t2 - t1:.3f}s)) # Process detections det = pred[0] # 原来的情况是要保持图片














，因此多了很多关于保持路径上的处理    
    
    
。另外  
    
    
 ，pred # 其实是个列表   


     


     


 。元素个数为batch_size



 




 




 。由于对于我这个api

     


     


     ，每次只处理一个图片 




 




 




， # 所以pred中只有一个元素  

   

   

，直接取出来就行

     

     

     ，不用for循环   

   

   

。 im0 = im0s.copy() # 这是原图片  




  




  



，与被传进来的图片是同地址的  


  


  


，需要copy一个副本
     
     
    ，否则
   




   




   


，原来的图片会受到影响 # s += %gx%g % img.shape[2:] # print string # gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh result_txt = [] # 对于一张图片 



 



 



，可能有多个可被检测的目标    

     

     

。所以结果标签也可能有多个




  




  




  。 # 每被检测出一个物体              ，result_txt的长度就加一  


  


  

。result_txt中的每个元素是个列表

    




    




    

，记录着 # 被检测物的类别引索














，在图片上的位置              ，以及置信度 if len(det): # Rescale boxes from img_size to im0 size det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round() # Write results for *xyxy, conf, cls in reversed(det): # xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh line = (int(cls.item()), [int(_.item()) for _ in xyxy], conf.item()) # label format result_txt.append(line) label = f{self.names[int(cls)]} {conf:.2f} plot_one_box(xyxy, im0, label=label, color=self.colors[int(cls)], line_thickness=3) result.append((im0, result_txt)) # 对于每张图片

     



     



     
，返回画完框的图片














，以及该图片的标签列表     
     
     
。 return result, self.names

修改  根目录下  utils/datasets.py  文件  
    
    
 ，在 logger = logging.getLogger(__name__)  后一行加入以下代码

     


     


     ，其他的代码保留原始的 




 




 




，不用删除也不用修改




   




   




  。

class MyLoadImages: # for inference def __init__(self, path, img_size=640, stride=32): for img in path: if type(img)!=np.ndarray or len(img.shape)!=3: raise TypeError(there is a object which is not a picture read by cv2 in source) p = str(Path(path).absolute()) # os-agnostic absolute path if * in p: files = sorted(glob.glob(p, recursive=True)) # glob elif os.path.isdir(p): files = sorted(glob.glob(os.path.join(p, *.*))) # dir elif os.path.isfile(p): files = [p] # files else: raise Exception(fERROR: {p} does not exist) images = [x for x in files if x.split(.)[-1].lower() in img_formats] videos = [x for x in files if x.split(.)[-1].lower() in vid_formats] ni, nv = len(images), len(videos) self.img_size = img_size self.stride = stride self.files = path self.nf = len(path) #self.video_flag = [False] * ni + [True] * nv self.mode = image #if any(videos): #self.new_video(videos[0]) # new video #else: #self.cap = None #assert self.nf > 0, fNo images or videos found in {p}. \ #fSupported formats are:\nimages: {img_formats}\nvideos: {vid_formats} def __iter__(self): self.count = 0 return self def __next__(self): if self.count == self.nf: raise StopIteration path = self.files[self.count] if self.video_flag[self.count]: # Read video self.mode = video ret_val, img0 = self.cap.read() if not ret_val: self.count += 1 self.cap.release() if self.count == self.nf: # last video raise StopIteration else: path = self.files[self.count] self.new_video(path) ret_val, img0 = self.cap.read() self.frame += 1 print(fvideo {self.count + 1}/{self.nf} ({self.frame}/{self.nframes}) {path}: , end=) # Read image self.count += 1 #img0 = cv2.imread(path) # BGR #assert img0 is not None, Image Not Found + path #print(fimage {self.count}/{self.nf} {path}: , end=) # Padded resize img = letterbox(path, self.img_size, stride=self.stride)[0] # Convert img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416 img = np.ascontiguousarray(img) return img, path

新建一个   demo_run_API.py   文件  

   

   

，对   detect_with_API.py   中的  API  进行调用

import cv2 import detect_with_API import torch cap=cv2.VideoCapture(http://admin:admin@192.168.1.109:8081)# 0 a = detect_with_API.detectapi(weights=models/yolov7.pt) if __name__ == __main__: with torch.no_grad(): while True: rec,img = cap.read() result,names = a.detect([img]) img=result[0][0] #每一帧图片的处理结果图片 # 每一帧图像的识别结果（可包含多个物体） for cls,(x1,y1,x2,y2),conf in result[0][1]: print(names[cls],x1,y1,x2,y2,conf)#识别物体种类

    




    




    

、左上角x坐标














、左上角y轴坐标              、右下角x轴坐标

     



     



     
、右下角y轴坐标

     

     

     ，置信度 cv2.rectangle(img,(x1,y1),(x2,y2),(0,255,0)) cv2.putText(img,names[cls],(x1,y1-20),cv2.FONT_HERSHEY_DUPLEX,1.5,(255,0,0)) print()#将每一帧的结果输出分开 cv2.imshow("vedio",img) if cv2.waitKey(1)==ord(q): break

三














、效果演示

我这里使用的是网络摄像头  




  




  



，你也可以用 USB 的接口摄像头或者电脑自带的摄像头
 



 



 

。

配置好环境  


  


  


，摄像头后
     
     
    ，运行  demo_run_API.py
   




   




   


，得：

 我的整体项目框架如下 



 



 



，有需要的自取：

YOLOV7_with_API.7z-深度学习文档类资源-CSDN下载

若你用自己的数据集来定制化地训练自己的识别模型              ，可以参考：

YOLOV5训练自己的无人车避坑（障）系统_Leonard2021的博客-CSDN博客_yolo训练

YOLOV7的训练的函数是没有修改的

    




    




    

，训练完成后














，在我制作API中调用你自己训练的模型即可               。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

如果本文对你有帮助              ，欢迎一键三连！