您现在的位置是：网站首页> AI人工智能
AI人工智能模型创建训练等知识积累
- AI人工智能
- 2024-06-04
- 800人已阅读
AI人工智能模型创建训练等知识积累
yolo训练工具详细使用教程，全面讲解训练AI目标检测模型。终于把功能完善了，头好痒
YOLOv8第一步 環境安裝
查看你的机器支持的cuda版本
版本选择不要比看到的高,也可以用命令行：nvidia-smi 查看支持的最高版本
0:00~13:55 第一步:下載CUDA以及CUDNN
13:56~17:10 第二步:下載Python跟Pycharm(程式編譯環境)
17:11~26:22 第三步:安裝yoloV8環境套件
26:23~27:40 第四步:測試是否裝好
pytorch安装指令获得，点击进入，选择相应参数获得指令
安装yolo8
pip install ultralytics
测试是否安装成功
yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'
yoloV8第2步 準備訓練資料
安装labelimg
pip3 install labelimg
运行:
lableimg
yoloV8第3步 模型訓練
yolov8第4步 使用模型
YOLOv8 tracking
yolov5的安装与使用
相比于Yolov4 ,v5的模型更多，适用配置的设备更广泛。
window环境下，首先安装anaconda，便于创建pytorch环境。安装直接百度。
第一步：从github下载压缩包
https://github.com/ultralytics/yolov5
如果英语看着费劲，可以参考这个博主的汉化版 ：https://github.com/wudashuo/yolov5
下载好zip压缩包，解压之后放入一个工程目录，准备开始第二步。
创建环境名 比如叫yolov5
conda create -n yolov5
进入环境
activate yolov5
开始下载环境所需的依赖了。
然后输入命令
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple，
等待pip自动下载所需要的依赖。-i 参数是从清华镜像中下载依赖包，如果不加，则从国外源下载，不仅速度慢，还容易下载失败。
当所有依赖下载完成，可以开始第三步了。
第三步：下载权重文件
在https://github.com/ultralytics/yolov5/releases中下载4个权重文件，放到工程路径下的weights文件夹中。
一般这四个就够用了，s是最小的，速度最快，但是精度不高。
第四步 测试detect.py
在工程文件在运行cmd。
然后输入python detect.py --source 0 --weights=“weights/yolov5s.pt” (如果设备有摄像头）
或者python detect.py --source=“data/images/bus.jpg” --weights=“weights/yolov5s.pt”(设备没有摄像头）
前者会打开摄像头并实时探测物品，后者将用工程自带的一张测试图片进行测试。运行结束后，会打印结果文件的位置。在这个位置中可以找到测试结果。
一般这四个就够用了，s是最小的，速度最快，但是精度不高。
第五步 制作自己的数据集–下载LabelImg
任意位置运行cmd,然后 pip install LabelImg -i https://pypi.tuna.tsinghua.edu.cn/simple
下载安装完成后运行cmd，输入LabelImg，打开程序。
第六步 制作自己的数据集–打标签
把准备好的图片放到一个文件夹中，在LabelImg中打开这个文件夹。然后设置标签文件输出位置（change save Dir)。不要放在与图片相同的位置就行。然后对每张图片画框打标签。按w键可以画框，画完框后，就会弹出对话框，然后在对话框上写上标签名就行（这步工作就是说明图片上这个位置是什么东西）。打完标签后，你就得到两个文件夹。图片和标签。在标签文件夹中，你还得到了一个classes.txt文件。这个文件记录了数据集中所有类别。标签文件中记录的是引索。需要通过这个classes.txt文件才能知道对应的物品名称。图片和标签两个文件夹中的文件一一对应，它们名字相同，后缀名不同。然后你需要把数据分为训练集和测试集，比例要适中。
此时，你拥有4个文件夹和一个class.txt文件。
train图片
train标签（与train 图片一一对应，名字相同，后缀不同）
test图片
test标签 （与test 图片一一对应，名字相同，后缀不同)
第七步 把自己的数据集转移到yolov5工程目录
在工程目录下找到data文件夹，在这个文件夹里新建一个文件夹。可以任意命名（为方便说明，这里用命名为mydataset。在mydataset下新建两个文件夹。一个命名为images,另一个命名为labels。这两个文件夹名字是规定的，不能随意。然后分别在这两个文件夹下都新建两个文件夹，命名为train,test。
然后把第六步得到的4个文件夹中的文件转移到对应目录中
train图片->images/train
train标签->labels/train
test图片->images/test
test标签->labels/test
第七步 调整配置文件
1. 打开工程目录/models/yolov5s.yaml文件（如果训练的是其他模型则打开其他模型的yaml文件），然后把nc改为第六步中classes.txt中类别的数量。（你数据集中标签了多少样东西，这个数字就是几）
2. 打开工程目录/data/coco128.yaml文件。
把train:设置为第六步的train图片的存放位置
把val:设置为第六步的test图片的存放位置
程序会自动搜索labels文件的位置。这也就是第六步为什么要规定图片与标签文件夹名字的原因。这个搜索是通过简单字符串替换实现的
把nc:改为数据集的类别数目（1中的一样）
把names改为类别名称，顺序要和第六步得到的classes.txt中的一样。
第七步 训练权重
命令行切换到工程目录下。运行命令（运行之前确保修改的配置文件都保存好了）
python train.py --img 640 --data data/coco128.yaml --cfg models/yolov5s.yaml --weights weights/yolov5s.pt --batch-size 8 --epochs 50
这些参数根据实际情况进行调整。–cfg 指示用到的模型的配置文件的位置。–weights 指示对应模型权重文件的位置。
在开始训练前。会打印输出的位置。我们会得到训练指标，训练后的两个权重文件（一个是最佳权重，一个是最后一轮训练得到的权重）。
训练完成后，就可以去那个目录查看结果。
第八步 用训练得到的权重进行预测
与第四步一样，不同的是权重文件的位置变了
python detect.py --source 0 --weights=“weights/yolov5s.pt”。改一下权重路径就行。
=>python detect.py --source 0 --weights=“runs\train\exp3\weights\best.pt”
source 参数说明
如果是0，则打开摄像头
如果是图片路径，则对图片进行预测。结果路径会打印
如果是文件夹，则对文件夹中的图片和视频进行预测。
如果是视频，则对视频进行预测。
————————————————
快速上手yolov8进行目标检测，顺便读一读yolo的源码
安装：
Clone repo and install requirements.txt in a Python>=3.8.0 environment, including PyTorch>=1.8.
git clone https://github.com/ultralytics/yolov5 # clone
cd yolov5
pip install -r requirements.txt # install
开源基于yolov8，训练一个安全帽识别的目标检测模型
yolovX,X为版本
YOLO：简史
YOLO (You Only Look Once)，由华盛顿大学的Joseph Redmon和Ali Farhadi开发的流行目标检测和图像分割模型，于2015年推出，由于其高速和准确性而迅速流行。
YOLOv2 在2016年发布，通过引入批量归一化、锚框和维度聚类来改进了原始模型。
YOLOv3 在2018年推出，进一步增强了模型的性能，使用了更高效的主干网络、多个锚点和空间金字塔池化。
YOLOv4 在2020年发布，引入了Mosaic数据增强、新的无锚检测头和新的损失函数等创新功能。
YOLOv5 进一步改进了模型的性能，并增加了新功能，如超参数优化、集成实验跟踪和自动导出到常用的导出格式。
YOLOv6 在2022年由美团开源，现在正在该公司的许多自动送货机器人中使用。
YOLOv7 在COCO关键点数据集上添加了额外的任务，如姿态估计。
YOLOv8 是Ultralytics的YOLO的最新版本。作为一种前沿、最先进(SOTA)的模型，YOLOv8在之前版本的成功基础上引入了新功能和改进，以提高性能、灵活性和效率。YOLOv8支持全范围的视觉AI任务，包括检测, 分割, 姿态估计, 跟踪, 和分类。这种多功能性使用户能够利用YOLOv8的功能应对多种应用和领域的需求。
Labelimg是一款开源的数据标注工具，可以标注三种格式。
VOC标签格式，保存为xml文件。
yolo标签格式，保存为txt文件。
createML标签格式，保存为json格式。
yolov5的比较简单，就是图片和标签分别两个文件夹中，并且自己分类，将图片与标签按照一定的比例区分成训练集和验证集。
txt的标签如下图所示：
第一列为目标类别，后面四个数字为[x_center, y_center, w, h]，可以看到都是小于1的数字，是因为对应的整张图片的比例，所以就算图像被拉伸放缩，这种txt格式的标签也可以找到相应的目标。
创建环境并安装python: conda create -n safehot python=3.10
激活环境:ctiveate safehat
安装YOLO:pip install ultralytics
yaml 配置文件
训练模型
运行学习训练
Python yolo_train.py
weights下不保存了模型
用bsest.pt进行测试
python yolo_test.py
识别输出
只选择识别戴和未戴安全帽
yolo训练工具详细使用教程，全面讲解训练AI目标检测模型。终于把功能完善了，头好痒
yolo工具下载链接：https://pan.baidu.com/s/1NRp8J-4lrOuY07o3CaaV4g
提取码：r1vn
练手小游戏下载链接：https://pan.baidu.com/s/1xKujcTPixYZRCeMgMryTHw
提取码：cwus
Python程式設計實務應用: YOLOv8模型訓練
基于YOLOv8深度学习的行人跌倒检测系统
通过网络上搜集关于跌倒的各类图片，并使用LabelMe标注工具对每张图片中的跌倒目标边框（Bounding Box）进行标注。一共包含1428张图片，其中训练集包含1142张图片，验证集包含286张图片
我们需要新建一个data.yaml文件，用于存储训练数据的路径及模型需要进行检测的类别。YOLOv8在进行模型训练时，会读取该文件的信息，用于进行模型的训练与验证。data.yaml的具体内容如下：
train: E:\MyCVProgram\Fallyolov8Detection\datasets\FallData\train # train images (relative to 'path') 128 images
val: E:\MyCVProgram\Fallyolov8Detection\datasets\FallData\val # val images (relative to 'path') 128 images
test: # val images (optional)
# number of classes
nc: 1
# Classes
names: ['Fall']
注：train与val后面表示需要训练图片的路径，建议直接写自己文件的绝对路径。 数据准备完成后，通过调用train.py文件进行模型训练，epochs参数用于调整训练的轮数，batch参数用于调整训练的批次大小【根据内存大小调整，最小为1】，代码如下：
# 加载模型
model = YOLO("yolov8n.pt") # 加载预训练模型
# Use the model
if __name__ == '__main__':
# Use the model
results = model.train(data='datasets/FallData/data.yaml', epochs=250, batch=4) # 训练模型
# 将模型转为onnx格式
# success = model.export(format='onnx')
模型训练完成后，我们可以得到一个最佳的训练结果模型best.pt文件，在runs/trian/weights目录下。我们可以使用该文件进行后续的推理检测。 图片检测代码如下：
# 所需加载的模型目录
path = 'models/best.pt'
# 需要检测的图片地址
img_path = "TestFiles/fall_9.jpg"
# 加载预训练模型
# conf 0.25 object confidence threshold for detection
# iou 0.7 intersection over union (IoU) threshold for NMS
model = YOLO(path, task='detect')
# model = YOLO(path, task='detect',conf=0.5)
# 检测图片
results = model(img_path)
res = results[0].plot()
cv2.imshow("YOLOv8 Detection", res)
cv2.waitKey(0)
执行上述代码后，会将执行的结果直接标注在图片上，结果如下：
深度学习之基于Yolov5的车流或人流量密度统计
一项目简介
YOLOv5 DeepSort 车流/人流量密度统计介绍
深度学习在计算机视觉领域的应用日益广泛，其中基于 YOLOv5 和 DeepSort 的车流/人流量密度统计是一个重要的应用场景。以下是对这一技术的简要介绍：
YOLOv5
YOLOv5（You Only Look Once，只看一次）是目标检测的一种深度学习模型。相比之前的版本，YOLOv5 以更高的精度和更快的速度进行实时目标检测。该模型采用单一神经网络，在一次前向传递中直接预测图像中的多个对象边界框和类别。
YOLOv5 的特点包括：
实时性： 相较于其他目标检测模型，YOLOv5 在保持高精度的同时实现了更快的实时性能。
轻量级： 模型结构相对较简单，便于在不同环境中进行部署和应用。
多类别检测： 能够同时检测多个类别的对象。
DeepSort
DeepSort 是一种目标跟踪算法，通常与目标检测模型（如 YOLOv5）配合使用，以实现在视频流中追踪目标的位置。DeepSort 的特性包括：
目标关联： 通过处理检测到的对象，DeepSort 能够在连续帧之间关联目标，实现目标的跟踪。
轨迹分析： 提供对目标运动轨迹的分析，包括速度、方向等信息。
多目标追踪： 能够同时追踪多个目标，适用于车流和人流等场景。
车流/人流量密度统计
将 YOLOv5 和 DeepSort 结合起来，可以实现对车流或人流的密度统计。该应用场景通常包括以下步骤：
目标检测： 使用 YOLOv5 对图像或视频帧进行目标检测，识别出车辆或行人等目标。
目标跟踪： 利用 DeepSort 对检测到的目标进行跟踪，维护目标的唯一标识符，并在连续帧之间关联目标。
密度统计： 分析跟踪到的目标在特定区域内的分布，从而实现车流或人流的密度统计。可以通过轨迹信息、目标数量等指标进行统计和分析。
二、功能
环境：Python3.8、OpenCV4.7、torch1.8.1、PyCharm
简介：实现了统计画面中经过的物体数量的功能，包括车流、人群等。
检测原理：Yolov5_DeepSort会跟踪画面上检测出来的物体，并给每个框标上了序号，当有一个方框跨过检测线时，计数器就会+1
用户可以指定检测线的画法，可以指定框沿哪个方向跨过检测线时计数器+1，也可以指定框的四个顶点中的哪一个顶点跨过线时计数器+1
具体的参数设定见第3点
在count.py中，设置以下参数
source_dir : 要打开的视频文件。若要调用摄像头，需要设置为字符串’0’，而不是数字0，按q退出播放
output_dir : 要保存到的文件夹
show_video : 运行时是否显示
save_video : 是否保存运行结果视频
save_text : 是否保存结果数据到txt文件中，将会保存两个文本文件：result.txt和number.txt。result.txt的格式是(帧序号,框序号,框到左边距离,框到顶上距离,框横长,框竖高,-1,-1,-1,-1)，number.txt的格式是(帧序号，直至当前帧跨过线的框数)
class_list : 要检测的类别序号，在coco_classes.txt中查看（注意是序号不是行号），可以有一个或多个类别
line : 检测线的两个端点的xy坐标，总共4个数
big_to_small : 0表示从比线小的一侧往大的一侧，1反之。（靠近坐原点或坐标轴的一侧是小的）
point_idx : 要检测的方框顶点号(0, 1, 2, 3)，看下边的图，当方框的顶点顺着big_to_small指定的方向跨过检测线时，计数
检测线的画法：给出两个端点的坐标，确定一条检测线，画布的坐标方向如下
|——-> x轴
|
|
V
y轴
方框的顶点编号：当方框的指定顶点跨过检测线时，计数器会+1，顶点的编号如下
0 1
|————–|
| |
| |
|————–|
3 2
设置好参数后，python运行count.py文件即可
python count.py
三、系统
四. 总结
这种深度学习技术的应用可以在交通监控、人流管理等场景中发挥重要作用，为城市规划和安全管理提供有力支持。
YOLOv8 目标跟踪、车速检测、车流量统计
import cv2
import pandas as pd
import numpy as np
from ultralytics import YOLO
import ultralytics
from track import *
from deep_sort.deep_sort import DeepSort
import time
model = YOLO('yolov8_visdrone.pt')
# cap=cv2.VideoCapture('veh2.mp4')
cap = cv2.VideoCapture('b.mov')
# cap=cv2.VideoCapture('test_traffic.mp4')
w, h = int(cap.get(3)), int(cap.get(4))
fps = cap.get(cv2.CAP_PROP_FPS)
print("fps: ", cap.get(cv2.CAP_PROP_FPS))
# video write
fourcc = cv2.VideoWriter_fourcc(*'MJPG')
# out = cv2.VideoWriter('out.avi',fourcc, fps, (w,h))
out = cv2.VideoWriter('out2.avi',fourcc, 20, (w,h))
class_list = ['pedestrain', 'people', 'bicycle', 'car', 'van', 'truck', 'tricycle', 'awning-tricycle', 'bus', 'motor']
# print(class_list)
count = 0
tracker=Tracker()
cy1 = 222
cy2 = 368
offset = 10 # 6
vh_down = {}
counter = []
vh_up = {}
counter1 = []
while True:
ret, frame = cap.read()
if not ret:
break
count += 1
if count % 3 != 0:
continue
frame = cv2.resize(frame, (1020, 500))
mytracker = Tracker()
im, pred_boxes, bbox_id = mytracker.track(frame)
for bbox in bbox_id:
x3, y3, x4, y4, id = bbox
x3, y3, x4, y4 = int(x3), int(y3), int(x4), int(y4)
# print(x3, y3, x4, y4)
cx = int(x3 + x4) // 2
cy = int(y3 + y4) // 2
cv2.rectangle(frame,(x3,y3),(x4,y4),(0,0,255),2)
#####going DOWN#####
if cy1 < (cy + offset) and cy1 > (cy - offset):
vh_down[id] = time.time()
if id in vh_down:
if cy2 < (cy + offset) and cy2 > (cy - offset):
elapsed_time = time.time() - vh_down[id]
if counter.count(id) == 0:
counter.append(id)
distance = 10 # meters
a_speed_ms = distance / elapsed_time
a_speed_kh = a_speed_ms * 3.6
cv2.circle(frame, (cx, cy), 4, (0, 0, 255), -1)
cv2.putText(frame, str(id), (x3, y3), cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255), 1)
cv2.putText(frame, str(int(a_speed_kh)) + 'Km/h', (x4, y4), cv2.FONT_HERSHEY_COMPLEX, 0.8,
(0, 0, 255), 3)
#####going UP#####
if cy2 < (cy + offset) and cy2 > (cy - offset):
vh_up[id] = time.time()
if id in vh_up:
if cy1 < (cy + offset) and cy1 > (cy - offset):
elapsed1_time = time.time() - vh_up[id]
if counter1.count(id) == 0:
counter1.append(id)
distance1 = 10 # meters
a_speed_ms1 = distance1 / elapsed1_time
a_speed_kh1 = a_speed_ms1 * 3.6
cv2.circle(frame, (cx, cy), 4, (0, 0, 255), -1)
cv2.putText(frame, str(id), (x3, y3), cv2.FONT_HERSHEY_COMPLEX, 0.6, (0, 0, 255), 1)
cv2.putText(frame, str(int(a_speed_kh1)) + 'Km/h', (x4, y4), cv2.FONT_HERSHEY_COMPLEX, 0.8,
(0, 0, 255), 2)
cv2.line(frame, (176, cy1), (880, cy1), (0, 0, 255), 3)
cv2.putText(frame, ('L1'), (182, cy1), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0, 255, 0), 2)
cv2.line(frame, (177, cy2), (880, cy2), (0, 0, 255), 3)
cv2.putText(frame, ('L2'), (182, cy2), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0, 255, 0), 2)
d = (len(counter))
u = (len(counter1))
cv2.putText(frame, ('goingdown:-') + str(d), (60, 90), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0, 255, 0), 2)
cv2.putText(frame, ('goingup:-') + str(u), (60, 130), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0, 255, 0), 2)
cv2.imshow("RGB", frame)
frame = cv2.resize(frame, (w, h))
out.write(frame)
if cv2.waitKey(1) & 0xFF == 27:
break
cap.release()
cv2.destroyAllWindows()
物体追踪例子
Python示例
持续追踪循环
这是一个使用OpenCV（cv2）和YOLOv8在视频帧上运行物体追踪的Python脚本。此脚本假设您已经安装了必要的包（opencv-python和ultralytics）。参数persist=True告诉追踪器当前的图像或帧是序列中的下一个，并且期望在当前图像中从上一个图像中获得追踪路径。
带追踪功能的流循环
import cv2
from ultralytics import YOLO
# 加载YOLOv8模型
model = YOLO('yolov8n.pt')
# 打开视频文件
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# 循环遍历视频帧
while cap.isOpened():
# 从视频读取一帧
success, frame = cap.read()
if success:
# 在帧上运行YOLOv8追踪，持续追踪帧间的物体
results = model.track(frame, persist=True)
# 在帧上展示结果
annotated_frame = results[0].plot()
# 展示带注释的帧
cv2.imshow("YOLOv8 Tracking", annotated_frame)
# 如果按下'q'则退出循环
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# 如果视频结束则退出循环
break
# 释放视频捕获对象并关闭显示窗口
cap.release()
cv2.destroyAllWindows()
随时间绘制追踪路径
在连续帧上可视化物体追踪路径可以提供有关视频中检测到的物体的运动模式和行为的有价值的洞见。使用Ultralytics YOLOv8，绘制这些路径是一个无缝且高效的过程。
在以下示例中，我们演示了如何利用YOLOv8的追踪功能在多个视频帧上绘制检测物体的移动。这个脚本涉及打开视频文件、逐帧读取，并使用YOLO模型识别并追踪各种物体。通过保留检测到的边界框的中心点并连接它们，我们可以绘制表示跟踪物体路径的线条。
在多个视频帧上绘制追踪路径
from collections import defaultdict
import cv2
import numpy as np
from ultralytics import YOLO
# 加载YOLOv8模型
model = YOLO('yolov8n.pt')
# 打开视频文件
video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)
# 存储追踪历史
track_history = defaultdict(lambda: [])
# 循环遍历视频帧
while cap.isOpened():
# 从视频读取一帧
success, frame = cap.read()
if success:
# 在帧上运行YOLOv8追踪，持续追踪帧间的物体
results = model.track(frame, persist=True)
# 获取框和追踪ID
boxes = results[0].boxes.xywh.cpu()
track_ids = results[0].boxes.id.int().cpu().tolist()
# 在帧上展示结果
annotated_frame = results[0].plot()
# 绘制追踪路径
for box, track_id in zip(boxes, track_ids):
x, y, w, h = box
track = track_history[track_id]
track.append((float(x), float(y))) # x, y中心点
if len(track) > 30: # 在90帧中保留90个追踪点
track.pop(0)
# 绘制追踪线
points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)
# 展示带注释的帧
cv2.imshow("YOLOv8 Tracking", annotated_frame)
# 如果按下'q'则退出循环
if cv2.waitKey(1) & 0xFF == ord("q"):
break
else:
# 如果视频结束则退出循环
break
# 释放视频捕获对象并关闭显示窗口
cap.release()
cv2.destroyAllWindows()
多线程追踪
多线程追踪提供了同时在多个视频流上运行物体追踪的能力。当处理多个视频输入，例如来自多个监控摄像头时，这一功能特别有用，其中并发处理可以大大提高效率和性能。
在提供的Python脚本中，我们利用Python的threading模块来同时运行多个追踪器实例。每个线程负责在一个视频文件上运行追踪器，所有线程在后台同时运行。
为了确保每个线程接收到正确的参数（视频文件、要使用的模型和文件索引），我们定义了一个函数run_tracker_in_thread，它接受这些参数并包含主追踪循环。此函数逐帧读取视频，运行追踪器，并显示结果。
在这个例子中，两个不同的模型被使用：yolov8n.pt和yolov8n-seg.pt，每个模型都在不同的视频文件中追踪物体。视频文件分别指定在video_file1和video_file2中。
在threading.Thread中参数daemon=True表示，这些线程会在主程序结束时关闭。然后我们用start()来开始线程，并使用join()来使主线程等待，直到两个追踪线程都结束。
最后，在所有线程完成任务后，使用cv2.destroyAllWindows()关闭显示结果的窗口
YOLOv5车辆测距实践：利用目标检测技术实现车辆距离估算
YOLOv5目标检测技术进行车辆测距。相信大家对YOLOv5已经有所了解，它是一种快速且准确的目标检测算法。接下来，让我们一起探讨如何通过YOLOv5实现车辆距离估算。这次的实践将分为以下几个步骤：
安装所需库和工具
数据准备
模型训练
距离估算
可视化结果
优化
1. 安装所需库和工具
首先，我们需要确保已经安装了YOLOv5的依赖库。这里我们使用Python作为开发语言，需要安装PyTorch、torchvision、OpenCV等库。可以使用以下命令进行安装：
pip install torch torchvision opencv-python
接着，我们需要克隆YOLOv5的官方GitHub仓库，并进入项目目录：
git clone https://github.com/ultralytics/yolov5.git
cd yolov5
2. 数据准备
在本次实践中，我们使用一个包含车辆图片及其对应标签的数据集。为了训练YOLOv5，我们需要将数据集转换为适合YOLOv5训练的格式。具体来说，需要将每张图片的标签信息转换为YOLOv5所需的txt文件。
数据集应该按照以下结构进行组织：
dataset/
├── images/
│ ├── train/
│ └── val/
└── labels/├── train/└── val/
确保你已经准备好了相应的数据集，然后开始下一步。
3. 模型训练
首先，我们需要为YOLOv5配置训练参数。在项目目录下找到yolov5s.yaml文件，根据自己的需求修改相应的参数。例如，调整类别数、训练轮数等。
接下来，我们开始训练YOLOv5模型。在终端运行以下命令：
python train.py --img 640 --batch 16 --epochs 100 --data dataset.yaml --cfg yolov5s.yaml --weights yolov5s.pt --name yolov5s_vehicle
训练完成后，训练好的模型权重将保存在runs/train/yolov5s_vehicle/weights/best.pt路径下。
4. 距离估算
我们将使用以下公式估算距
距离 = (已知物体实际宽度 × 焦距) / 物体在图像中的像素宽度
在实际应用中，我们需要先通过已知距离的物体获取相机的焦距。焦距是固定的，这样我们可以将其用于计算其他车辆与相机的距离。
首先，我们需要加载训练好的YOLOv5模型：
import torch
from pathlib import Path
model = torch.hub.load('ultralytics/yolov5', 'custom', path=Path('runs/train/yolov5s_vehicle/weights/best.pt'))
model.conf = 0.25 # 置信度阈值
接着，我们定义一个用于计算距离的函数：
import cv2
def estimate_distance(image_path, focal_length, known_width):
image = cv2.imread(image_path)
results = model(image) # YOLOv5检测
for *box, conf, cls in results.xyxy[0]:
x1, y1, x2, y2 = boxwidth = x2 - x1
distance = (known_width * focal_length) / width
print(f"距离估计：{distance:.2f}米")接着，我们定义一个用于计算距离的函数：
import cv2
def estimate_distance(image_path, focal_length, known_width):
image = cv2.imread(image_path)results = model(image) # YOLOv5检测
for *box, conf, cls in results.xyxy[0]:
x1, y1, x2, y2 = box
width = x2 - x1
distance = (known_width * focal_length) / width
print(f"距离估计：{distance:.2f}米")
需要注意的是，focal_length和known_width的值需要事先获取。如果已知某个物体的实际宽度以及该物体在图像中的像素宽度，可以通过测量该物体与相机的实际距离来计算相机的焦距。
5. 可视化结果
我们可以使用OpenCV将结果可视化，为此我们需要修改estimate_distance函数：
def estimate_distance_viz(image_path, focal_length, known_width):
image = cv2.imread(image_path)
results = model(image) # YOLOv5检测
for *box, conf, cls in results.xyxy[0]:
x1, y1, x2, y2 = boxwidth = x2 - x1
distance = (known_width * focal_length) / width
cv2.rectangle(image, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
cv2.putText(image, f"{distance:.2f}米", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.imshow("Distance Estimation", image)
cv2.waitKey(0)
cv2.destroyAllWindows()
现在，我们可以使用estimate_distance_viz函数计算车辆距离并将结果可视化。
image_path = 'test.jpg'
focal_length = 700 # 示例值，需要根据实际情况进行调整
known_width = 1.8 # 示例值，车辆的实际宽度，根据实际情况进行调整visualize_distance(image_path, focal_length, known_width)
优化
在实际应用中，我们可以对算法进行优化以提高性能和准确性。以下是一些建议：
相机标定：在当前的实现中，我们直接使用了焦距作为参数。为了获得更准确的结果，可以通过相机标定来获取更多的相机内参，例如畸变系数。这将有助于提高距离估算的准确性。使用OpenCV中的cv2.calibrateCamera()函数可以实现相机标定。
多帧融合：为了提高测距的稳定性，可以使用多帧融合技术。通过收集连续多帧图像的检测结果，计算车辆距离的平均值或加权平均值。这可以降低误差并提高稳定性。
自适应阈值调整：在不同的场景和光照条件下，检测结果可能会受到影响。可以尝试根据图像的亮度、对比度等特征自适应调整置信度阈值，以提高检测的准确性。
结果平滑：在距离估算中，可能会出现噪声或突变。我们可以应用一些滤波算法（例如卡尔曼滤波器或移动平均滤波器）对结果进行平滑处理，以提高估算稳定性。
要实施这些建议，我们需要对visualize_distance函数进行相应的修改。以下是一个修改后的示例，展示了如何将多帧融合技术应用于测距：
import cv2
import numpy as np
def visualize_distance_multiframe(image_paths, focal_length, known_width, num_frames=5):
distances = []
for image_path in image_paths:
image = cv2.imread(image_path)
results = model(image)
for *box, conf, cls in results.xyxy[0]:
x1, y1, x2, y2 = box
width = x2 - x1
distance = (known_width * focal_length) / width
distances.append(distance)
if len(distances) > num_frames:
distances.pop(0)
avg_distance = np.mean(distances)
cv2.rectangle(image, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
cv2.putText(image, f"{avg_distance:.2f}米", (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
cv2.imshow("Distance Estimation", image)
cv2.waitKey(0)
cv2.destroyAllWindows()
现在，我们可以调用visualize_distance_multiframe函数并提供一系列连续的图像来计算车辆距离并将结果可视化。这将使得距离估计更加稳定。现在，我们可以调用visualize_distance_multiframe函数并提供一系列连续的图像来计算车辆距离并将结果可视化。这将使得距离估计更加稳定。
image_paths = ['test1.jpg', 'test2.jpg', 'test3.jpg', 'test4.jpg', 'test5.jpg']
focal_length = 700 # 示例值，需要根据实际情况进行调整
known_width = 1.8 # 示例值，车辆的实际宽度，根据实际情况进行调整visualize_distance_multiframe(image_paths, focal_length, known_width)
实施多帧融合技术后，算法将能够更好地应对光照变化、遮挡等问题。同时，这种方法也可以降低单帧噪声对距离估计的影响。
需要注意的是，在实际应用中，我们可能需要根据具体场景和需求对算法进行不同程度的优化。例如，如果处理实时视频流，可以考虑在连续帧之间应用光流法以跟踪检测到的车辆，从而进一步提高测距的稳定性。此外，对于不同类型的车辆，可以考虑根据车辆类型设置不同的已知宽度，以提高估算准确性。
这样，我们就完成了使用YOLOv5进行车辆测距的实践。希望这篇博客对你们有所帮助！如果有任何疑问或者建议，请随时在评论区留言。下次见！
上一篇：AI人工智能应用编程
下一篇：AI硬件