devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

AI项目十九：YOLOV8实现目标追踪_yolov8目标追踪

作者：小丑西瓜9 | 2024-04-23 21:28:24

赞

踩

yolov8目标追踪

若该文为原创文章，转载请注明原文出处。

主要是学习一下实现目标追踪的原理，并测试一下效果。

目的是通过YOLOV8实现人员检测，并实现人员追踪，没个人员给分配一个ID，实现追踪的效果。

也可以统计人数。在小区办公楼的出入场所，这类很常见。

一、简介

追踪任务是指识别和跟踪特定目标在视频序列中的运动和位置，一般用唯一ID或固定颜色检测框表示），如下图：

目标检测和目标跟踪的区别：
目标检测:目标检测任务要求同时完成对象的定位（即确定对象的边界框位置）和分类（即确定对象的类别）。这意味着目标检测算法必须不仅能够确定对象是否存在，还要知道它是什么。
目标检测通常用于识别和定位图像或视频帧中的对象，通常需要明确的目标类别信息。
目标跟踪:目标跟踪任务更关注对象在帧与帧之间的连续性，通常更注重对象的运动特征，而不要求进行目标的分类。
目标跟踪可以不涉及目标的类别，它的主要目标是维护对象的位置和轨迹，以实现在视频序列中的跟踪。

这里就有个问题，视频中不同时刻的同一个人，位置发生了变化，那么是如何关联上的呢？答案就是匈牙利算法和卡尔曼滤波。

  • 匈牙利算法可以告诉我们当前帧的某个目标，是否与前一帧的某个目标相同。
  • 卡尔曼滤波可以基于目标前一时刻的位置，来预测当前时刻的位置，并且可以比传感器（在目标跟踪中即目标检测器，比如Yolo等）更准确的估计目标的位置。

最经典的是DeepSORT，本篇记录的是如何使用IOU，所以了解下DeepSORT。

DeepSORT对每一帧的处理流程如下：

检测器得到bbox → 生成detections → 卡尔曼滤波预测→ 使用匈牙利算法将预测后的tracks和当前帧中的detecions进行匹配（级联匹配和IOU匹配） → 卡尔曼滤波更新

Frame 0：检测器检测到了3个detections，当前没有任何tracks，将这3个detections初始化为tracks
Frame 1：检测器又检测到了3个detections，对于Frame 0中的tracks，先进行预测得到新的tracks，然后使用匈牙利算法将新的tracks与detections进行匹配，得到(track, detection)匹配对，最后用每对中的detection更新对应的track

二、方法介绍

目前主流的目标跟踪算法都是基于Tracking-by-Detecton策略，即基于目标检测的结果来进行目标跟踪。

实现目标跟踪的方法：

1、IOU

比较前后两帧检测框IOU是否大于指定阈值，是则是同一个物体，不是则分配新ID，此方法对于运动慢的可以，效果差。

2、卡尔曼滤波

卡尔曼滤波是一种用于估计系统状态的优秀算法。它结合了传感器测量和系统模型，通过递归地计算加权平均值，实时更新状态估计。卡尔曼滤波在众多领域，如导航、机器人技术和信号处理中广泛应用，以提高系统的准确性和鲁棒性。

可以用的库：GitHub - adipandas/multi-object-tracker: Multi-object trackers in Python

3、botsort&bytetrack

BoT-SORT是今年非常游戏的跟踪器模型。就所有主要 MOT 指标MOTA、IDF1 和 HOTA而言，BoT-SORT 和 BoT-SORT-ReID 在 MOT17 和 MOT20 测试集的 MOTChallenge数据集中排名第一。对于 MOT17：实现了 80.5 MOTA、80.2 IDF1 和 65.0 HOTA，在跟踪器的排行榜上暂居第一。
论文翻译：https://blog.csdn.net/hhhhhhhhhhwwwwwwwwww/article/details/126890651
论文链接：https://arxiv.org/pdf/2206.14651.pdf
代码：https://github.com/NirAharon/BOT-SORT
 

ByteTrack是基于tracking-by-detection范式的跟踪方法。大多数多目标跟踪方法通过关联分数高于阈值的检测框来获取目标ID。对于检测分数较低的目标，例如遮挡目标，会被简单的丢弃，这带来了不可忽略的问题，包括大量的漏检和碎片化轨迹。为了解决该问题，作者提出了一种简单、高效且通用的数据关联方法BYTE，通过关联每个检测框而不仅仅是高分检测框来进行跟踪。对于低分检测框，利用它们与轨迹的相似性来恢复真实目标并过滤掉背景检测。

BoT-SORT：https://github.com/NirAharon/BoT-SORT

ByteTrack ：https://github.com/ifzhang/ByteTrack

三、IOU实现目标追踪

1、环境安装

本人的电脑使用的是CPU（无GPU）版本，所以直接安装，GPU需要安装CUDA等，自行安装。

  1. # 使用Conda为本项目单独创建一个虚拟环境（python 3.8版本）
  2. conda create -n yolov8_env python=3.8
  3. # 激活进入环境
  4. conda activate yolov8_env
  5.  
  6. # YOLOv8安装方式
  7. pip install ultralytics

2、验证

  1. # 图片cli验证
  2. yolo predict model=yolov8n.pt source=./bus.jpg
  3.  
  4. # 视频cli验证
  5. yolo predict model=yolov8n.pt source=./test.mp4

3、使用python验证

使用python语言验证主要是熟悉YOLOV8的API,知道如何调用，并测试。

  1. from ultralytics import YOLO
  2. import cv2
  3. import numpy as np
  4. import time
  5.  
  6. # 加载模型
  7. model = YOLO("./yolov8n.pt")  # load a pretrained model (recommended for training)
  8. objs_labels = model.names  # get class labels
  9. print(objs_labels)
  10.  
  11.  
  12. # 打开摄像头
  13. cap = cv2.VideoCapture(0)
  14.  
  15. while True:
  16.     # 读取一帧
  17.     start_time = time.time()
  18.     ret, frame = cap.read()
  19.     if ret:
  20.         # 检测
  21.         result = list(model(frame, stream=True))[0]  # inference，如果stream=False，返回的是一个列表，如果stream=True，返回的是一个生成器
  22.  
  23.         boxes = result.boxes  # Boxes object for bbox outputs
  24.         boxes = boxes.cpu().numpy()  # convert to numpy array
  25.         
  26.         # 遍历每个框
  27.         for box in boxes.data:
  28.             l,t,r,b = box[:4].astype(np.int32) # left, top, right, bottom
  29.             conf, id = box[4:] # confidence, class
  30.             # 绘制框
  31.             cv2.rectangle(frame, (l,t), (r,b), (0,0,255), 2)
  32.             # 绘制类别+置信度（格式：98.1%）
  33.             cv2.putText(frame, f"{objs_labels[id]} {conf*100:.1f}%", (l, t-10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
  34.             
  35.         end_time = time.time()
  36.         fps = 1 / (end_time - start_time)
  37.         # 绘制FPS
  38.         cv2.putText(frame, f"FPS: {fps:.2f}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
  39.                 
  40.         # 显示
  41.         cv2.imshow("frame", frame)
  42.         if cv2.waitKey(1) & 0xFF == ord('q'):
  43.             break
  44.     else:
  45.         break

在终端里执行python demo.py

4、IOU实现追踪

  1. '''
  2. iou追踪示例
  3. '''
  4. from ultralytics import YOLO
  5. import cv2
  6. import numpy as np
  7. import time
  8. import random
  9. import os
  10. from shapely.geometry import Polygon, LineString
  11. import json
  12.  
  13. class IouTracker:
  14.     def __init__(self):
  15.  
  16.         # 加载检测模型
  17.         self.detection_model = YOLO("./yolov8n.pt")  
  18.         # 获取类别 
  19.         self.objs_labels = self.detection_model.names 
  20.         # 打印类别
  21.         print(self.objs_labels)
  22.         # 只处理person
  23.         self.track_classes = {0: 'person'}
  24.  
  25.         # 追踪的IOU阈值
  26.         self.sigma_iou = 0.5
  27.         # detection threshold
  28.         self.conf_thresh = 0.3
  29.    
  30.     def iou(sel,bbox1, bbox2):
  31.         """
  32.         计算两个bounding box的IOU
  33.         """
  34.  
  35.         (x0_1, y0_1, x1_1, y1_1) = bbox1
  36.         (x0_2, y0_2, x1_2, y1_2) = bbox2
  37.  
  38.         # 计算重叠的矩形的坐标
  39.         overlap_x0 = max(x0_1, x0_2)
  40.         overlap_y0 = max(y0_1, y0_2)
  41.         overlap_x1 = min(x1_1, x1_2)
  42.         overlap_y1 = min(y1_1, y1_2)
  43.  
  44.         # 检查是否有重叠
  45.         if overlap_x1 - overlap_x0 <= 0 or overlap_y1 - overlap_y0 <= 0:
  46.             return 0
  47.  
  48.         # 计算重叠矩形的面积以及两个矩形的面积
  49.         size_1 = (x1_1 - x0_1) * (y1_1 - y0_1)
  50.         size_2 = (x1_2 - x0_2) * (y1_2 - y0_2)
  51.         size_intersection = (overlap_x1 - overlap_x0) * (overlap_y1 - overlap_y0)
  52.         size_union = size_1 + size_2 - size_intersection
  53.         # 计算IOU
  54.         return size_intersection / size_union
  55.  
  56.  
  57.     def predict(self, frame):
  58.         '''
  59.         检测
  60.         '''
  61.         result = list(self.detection_model(frame, stream=True, conf=self.conf_thresh))[0]  # inference，如果stream=False，返回的是一个列表，如果stream=True，返回的是一个生成器
  62.         boxes = result.boxes  # Boxes object for bbox outputs
  63.         boxes = boxes.cpu().numpy()  # convert to numpy array
  64.  
  65.         dets = [] # 检测结果
  66.         # 遍历每个框
  67.         for box in boxes.data:
  68.             l,t,r,b = box[:4] # left, top, right, bottom
  69.             conf, class_id = box[4:] # confidence, class
  70.             # 排除不需要追踪的类别
  71.             if class_id not in self.track_classes:
  72.                 continue
  73.             dets.append({'bbox': [l,t,r,b], 'score': conf, 'class_id': class_id })
  74.         return dets
  75.     
  76.     
  77.     def main(self):
  78.         '''
  79.         主函数
  80.         '''
  81.         # 读取视频
  82.         cap = cv2.VideoCapture("./media/video.mp4")
  83.   
  84.         # 获取视频帧率、宽、高
  85.         fps = cap.get(cv2.CAP_PROP_FPS)
  86.         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
  87.         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
  88.         print(f"fps: {fps}, width: {width}, height: {height}")
  89.  
  90.  
  91.         tracks_active = [] # 活跃的跟踪器
  92.         frame_id = 1 # 帧ID
  93.         track_idx = 1 # 跟踪器ID
  94.         
  95.         # writer
  96.         out = cv2.VideoWriter("./test_out.mp4", cv2.VideoWriter_fourcc(*'mp4v'), fps, (1280, 720))
  97.  
  98.         while True:
  99.             # 读取一帧
  100.             start_time = time.time()
  101.             ret, raw_frame = cap.read()
  102.             if ret:
  103.                 # 检测
  104.                 frame = cv2.resize(raw_frame, (1280, 720))
  105.                 raw_frame = frame
  106.                 dets = self.predict(raw_frame)
  107.                 # 更新后的跟踪器
  108.                 updated_tracks = [] 
  109.                 # 遍历活跃的跟踪器
  110.                 for track in tracks_active:
  111.                     if len(dets) > 0:
  112.                         # 根据最大IOU更新跟踪器，先去explain.ipynb中看一下MAX用法
  113.                         best_match = max(dets, key=lambda x: self.iou(track['bboxes'][-1], x['bbox'])) # 找出dets中与当前跟踪器（track['bboxes'][-1]）最匹配的检测框（IOU最大）
  114.                         # 如果最大IOU大于阈值，则将本次检测结果加入跟踪器
  115.                         if self.iou(track['bboxes'][-1], best_match['bbox']) > self.sigma_iou:
  116.                             # 将本次检测结果加入跟踪器
  117.                             track['bboxes'].append(best_match['bbox'])
  118.                             track['max_score'] = max(track['max_score'], best_match['score'])
  119.                             track['frame_ids'].append(frame_id)
  120.                             # 更新跟踪器
  121.                             updated_tracks.append(track)
  122.                             # 删除已经匹配的检测框，避免后续重复匹配以及新建跟踪器
  123.                             del dets[dets.index(best_match)]
  124.  
  125.  
  126.                 # 如有未分配的目标，创建新的跟踪器
  127.                 new_tracks = []
  128.                 for det in dets: # 未分配的目标，已经分配的目标已经从dets中删除
  129.                     new_track = {
  130.                         'bboxes': [det['bbox']], # 跟踪目标的矩形框
  131.                         'max_score': det['score'], # 跟踪目标的最大score
  132.                         'start_frame': frame_id,  # 目标出现的 帧id
  133.                         'frame_ids': [frame_id],  # 目标出现的所有帧id
  134.                         'track_id': track_idx,    # 跟踪标号
  135.                         'class_id': det['class_id'], # 类别
  136.                         'is_counted': False       # 是否已经计数
  137.                     }
  138.                     track_idx += 1
  139.                     new_tracks.append(new_track)
  140.                 # 最终的跟踪器
  141.                 tracks_active = updated_tracks + new_tracks
  142.  
  143.                 cross_line_color = (0,255,0) # 越界线的颜色
  144.  
  145.                 # 绘制跟踪器
  146.                 for tracker in tracks_active:
  147.                     # 绘制跟踪器的矩形框
  148.                     l,t,r,b = tracker['bboxes'][-1]
  149.                     # 取整
  150.                     l,t,r,b = int(l), int(t), int(r), int(b)
  151.                     class_id = tracker['class_id']
  152.                     cv2.rectangle(raw_frame, (l,t), (r,b), cross_line_color, 2)
  153.                     # 绘制跟踪器的track_id + class_name + score（99.2%格式）
  154.                     cv2.putText(raw_frame, f"{tracker['track_id']}", (l, t-10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,255,0), 2)
  155.  
  156.                 # 设置半透明
  157.                 color = (0,0,0)
  158.                 alpha = 0.2
  159.                 l,t = 0,0
  160.                 r,b = l+240,t+40
  161.                 raw_frame[t:b,l:r,0] = raw_frame[t:b,l:r,0] * alpha + color[0] * (1-alpha)
  162.                 raw_frame[t:b,l:r,1] = raw_frame[t:b,l:r,1] * alpha + color[1] * (1-alpha)
  163.                 raw_frame[t:b,l:r,2] = raw_frame[t:b,l:r,2] * alpha + color[2] * (1-alpha)
  164.  
  165.                 # end time
  166.                 end_time = time.time()
  167.                 # FPS
  168.                 fps = 1 / (end_time - start_time)
  169.                 # 绘制FPS
  170.                 cv2.putText(raw_frame, f"FPS: {fps:.2f}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
  171.                 
  172.                
  173.  
  174.                 # 显示
  175.                 cv2.imshow("frame", raw_frame)
  176.                 if cv2.waitKey(1) & 0xFF == ord('q'):
  177.                     break
  178.                     
  179.                 out.write(raw_frame)
  180.             else:
  181.                 break
  182.                 
  183.         out.release()  
  184.  
  185. # 实例化
  186. iou_tracker = IouTracker()
  187. # 运行
  188. iou_tracker.main()

测试效果，视频是马路上的，如果想要效果好，建议自己训练模型，使用的是yolov8n.pt模型

如有侵权，或需要完整代码，请及时联系博主。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/476126
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号