Python Yolo1:YOLOV5安装使用

0. 虚拟环境准备

安装参考：

Python Notes22:Anaconda、Miniconda

使用

1. 查看现有的虚拟环境

1. 创建虚拟环境

PS D:\Cumtb_Code> conda create --prefix=D:\Cumtb_Code\yolo5demo python=3.8

1. 启动

# 切换到CMD下使用
PS D:\Cumtb_Code> cmd

# 启动虚拟环境
D:\Cumtb_Code>conda activate D:\Cumtb_Code\yolo5demo

# 查看虚拟环境下的pip库
(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code>pip list

# 退出
(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code>conda deactivate

1. 下载YOLO5

1. Clone项目

1. 解压项目

• data_gen.py，转换vico格式数据

• detect.py做可视化

• export和hubconf没用

• licence声明版权

• requirement：项目运行需要安装的依赖包，在代码运行前就先通过cmd安装好

• train.py：训练用到的

• val.py：验证用到的

• window.py：运行可视化界面用到的

1. 将项目移动到虚拟环境的目录（我这里创建的是yolo5demo）

2. 安装环境依赖

# 1.切换到虚拟环境目录
D:\Cumtb_Code>cd yolo5demo

# 2.启动虚拟环境
D:\Cumtb_Code\yolo5demo>conda activate D:\Cumtb_Code\yolo5demo

# 3.切换到yolov5-master项目目录
(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo>cd yolov5-master

2.1 使用CPU版本

# 4.安装相应的环境依赖（建议使用清华源安装）
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -U -r requirements.txt

2.2 使用GPU版本（强烈建议使用）

2.2.1 检查GPU

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>nvidia-smi
Tue Jun 21 22:11:38 2022       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 512.15       Driver Version: 512.15       CUDA Version: 11.6     |
|-------------------------------+----------------------+----------------------+
| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Quadro RTX 4000    WDDM  | 00000000:73:00.0  On |                  N/A |
| 30%   43C    P8    13W / 125W |   2097MiB /  8192MiB |     10%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

PyTorch

Select your preferences and run the install command. Stable represents the most currently tested and supported version of PyTorch. This should be suitable for many users. Preview is available if you want the latest, not fully tested and supported, 1.12 builds that are generated nightly.

https://pytorch.org/get-started/locally/

conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch

python
#输入库
import torch
# 查看版本
print(torch.__version__)
# 查看gpu是否可用
torch.cuda.is_available()
#返回设备gpu个数
torch.cuda.device_count()
#退出python
quit()

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>python      
Python 3.8.13 (default, Mar 28 2022, 06:59:08) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> torch.cuda.is_available()
True
>>> torch.cuda.device_count()
1

• 注释掉torch和torchvision。

# torch>=1.7.0
# torchvision>=0.8.1

2.2 安装依赖

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple -U -r requirements.txt

3. 运行官方例子测试

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>python detect.py --source data/images/bus.jpg --weights pretrained/yolov5s.pt

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>python detect.py --source data/images/bus.jpg --weights pretrained/yolov5s.pt

1. 权重文件：weights=[‘pretrained/yolov5s.pt’]

2. 要检测的图片：source=data/images/bus.jpg

3. 图片输入的大小640*640

4. 置信度大小：0.5（当有50%的信心认为该图片里面有检测的目标时，就输出）

5. 交并比：0.45

6. 设备信息：torch版本1.11.0

7. 检测结果放置的位置：Results saved to runs\detect\exp2

4. 自定义训练集

• 这里记录一下以后的训练
1. 标签
2. 修改dnf.yaml中的nc、names
3. 修改yolo5s.yaml中的nc
4. 运行命令

python train.py --data ./data/dnf.yaml --cfg ./models/yolov5s.yaml --weights '' --epoch 100 --device 0

python train.py --data ./data/dnf.yaml --cfg ./models/yolov5m.yaml --weights '' --epoch 300 --device 0

4.1 数据标注

• labelImg：

• Make Sense：

4.1.1 安装

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>pip install labelImg

4.1.2 使用labelImg

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>labelImg

Ctrl + s   | 保存                                      |
+------------+--------------------------------------------+
| Ctrl + d   | Copy the current label and rect box        |
+------------+--------------------------------------------+
| Space      | 标记当前图片已标记        |
+------------+--------------------------------------------+
| w          | 创建一个矩形                        |
+------------+--------------------------------------------+
| d          | 下一张图片                              |
+------------+--------------------------------------------+
| a          | 上一张图片                             |

YOLOv5简易使用教程

前言： 这篇博客只是简单记录下YOLOv5的使用方式，并不会详细介绍代码含义之类的。 从Github上下载解压好最新的YOLOv5文件后的目录如下图 data文件夹里面放着 yaml 文件，就是数据集的一些配置，是比较重要的，在训练自己数据集的时候会用到这个文件夹。 model文件夹里面放着一些官方的参数模型，里面有4个 yaml 文件分别对应着不同的模型参数，在自己训练的时候会用到这4个文件。 detect.py 这个是用来测试模型效果的。 train.py 这个是用来训练自己模型的。 自己进行训练或检测模型后还会多一个 run 文件夹，这个里面会存放检测模型的效果和训练的模型。 首先介绍一下train.py。我们自己可以使用这个py文件来训练自己的模型。 其中需要了解的是 parse_opt 函数，这个是重点。 def parse_opt(known=False): parser = argparse.ArgumentParser() # 模型选择 不填表示从头开始训练 也可以指定模型进行训练 parser.add_argument('--weights', type=str, default='', help='initial weights path') # 配置模型 parser.add_argument('--cfg', type=str, default='models/yolov5s.yaml', help='model.yaml path') # 指定训练数据集 parser.add_argument('--data', type=str, default='data/mytrain.yaml', help='dataset.yaml path') #

https://lightningleader.github.io/posts/15.html

把LabelImg标注的YOLO格式标签转化为VOC格式标签 和 把VOC格式标签转化为YOLO格式标签_点亮～黑夜的博客-CSDN博客_labelimg转voc

VOC数据格式，会直接把每张图片标注的标签信息保存到一个 xml文件中 例如：我们上面标注的 JPEGImage/000001.jpg图片，标注的标签信息会保存到 Annotation/000001.xml文件中， 000001.xml 中的信息如下： xml中的关键信息说明： YOLO数据格式，会直接把每张图片标注的标签信息保存到一个 txt文件中 例如：我们上面标注的 JPEGImage/000001.jpg图片，标注的标签信息会保存到 Annotation/000001.txt文件中（同时会生成一个classes.txt文件，也保存到Annotation/classes.txt）， 000001.txt 中的信息如下： txt中信息说明： 每一行代表标注的一个目标 第一个数代表标注目标的标签，第一目标circle_red，对应数字就是0 后面的四个数代表标注框的中心坐标和标注框的相对宽和高（进行了归一化，如何归一化可以参考我的这篇博客中的介绍） 五个数据从左到右以此为：。（后面的四个数据都是归一化的） 同时会生成一个 Annotation/classes.txt实际类别文件 classes.txt ，里面的内容如下： circle_red circle_gray rectangle_red rectangle_gray fingeprint_red fingeprint_gray other 标注好的 VOC格式的标签xml文件 ，存储的主要信息为： 例如下图代表的是一样图片： 红框代表的是原图大小：height=8，width=8 蓝框代表的是标注物体的框：左上角坐标为 (xmin, ymin)=(2,2)，右下角的坐标为 (xmax, ymax)=(6,6) 而voc_label.py目的就是把标注为VOC格式数据转化为标注为yolo格式数据： VOC格式标签：图片的实际宽和高，标注框的左上角和右下角坐标 YOLO格式标签：标注框的中心坐标（归一化的），标注框的宽和高（归一化的） VOC格式标签转换为 YOLO格式标签 计算公式： 框中心的实际坐标（x, y）：（一般可能还会在后面减去1） voc中保存的坐标信息为：

https://shliang.blog.csdn.net/article/details/107175968

4.2 建立对应文件夹

• 在data目录下images下新建train、valid、test文件夹

• 在data目录下新建labels文件夹，labels中新建train、valid、test文件夹

images
	--train   # 放入训练图片
	--valid   # 放入验证图片
	--test    # 放入测试图片
labels
	--train   # 放入训练文件txt
	--valid   # 放入验证文件txt
	--test    # 放入测试文件txt

4.3 新建yaml文件

train: images/train  # train images (relative to 'path') 128 images
val: images/valid  # val images (relative to 'path') 128 images
test:  # test images (optional)

# Classes
nc: 1  # number of classes
names: ['jianying']

• train：数据集的train的地址

• val：数据集的val的地址

• names：数组代表两个类的名字

• nc：表示几个类

4.4 运行训练

• 可以有两种训练方式
1. 修改train.py文件里的参数，直接运行train.py文件
2. 运行train.py，后面添加对应的参数

# 方式1. 修改train.py后直接运行
python train.py
# 方式2. 添加参数的方式（使用运行的 时候关闭一些应用，保证GPU够用，我这里是8G显卡）
python train.py --data ./data/dnf.yaml --cfg ./models/yolov5s.yaml --weights '' --epoch 300 --device 0
python train.py --data dnf.yaml --cfg yolov5s.yaml --weights pretrained/yolov5s.pt --epoch 100 --batch-size 4 --device cpu
python train.py --data dnf.yaml --cfg yolov5l.yaml --weights pretrained/yolov5l.pt --epoch 100 --batch-size 4
python train.py --data dnf.yaml --cfg yolov5m.yaml --weights pretrained/yolov5m.pt --epoch 100 --batch-size 4

• -epochs：训练的epoch，默认值300

• -batch-size：默认值16 一次放入训练的数量，4就是一次放4张图去训练。

• -cfg：模型的配置文件，默认为yolov5s.yaml

• -data：数据集的配置文件，默认为data/coco128.yaml

• -img-size：训练和测试输入大小，默认为[640, 640]

• -rect：rectangular training，布尔值

• -resume：是否从最新的last.pt中恢复训练，布尔值

• -nosave：仅仅保存最后的checkpoint，布尔值

• -notest：仅仅在最后的epoch上测试，布尔值

• -evolve：进化超参数（evolve hyperparameters），布尔值

• -bucket：gsutil bucket，默认值''

• -cache-images：缓存图片可以更快的开始训练，布尔值

• -weights：初始化参数路径，默认值''
• --weights ''：从头开始训练
• --weights yolov5s.pt：从预训练的模型加载开始训练

• -name：如果提供，将results.txt重命名为results_name.txt

• -device：cuda设备，例如：0或0,1,2,3或cpu，默认'' ，
• 0：指定单个GPU不会报错
• 0，1，2，3：当使用两个以上的GPU会报错

• -adam：使用adam优化器，布尔值

• -multi-scale：改变图片尺寸img-size +/0- 50%，布尔值

• -single-cls：训练单个类别的数据集，布尔值

4.5 运行结果

• best.pt：保存的是中间比较好的模型

• last.pt：训练结束后保存的最后模型

4.6 使用训练好的模型测试

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>python detect.py --source data/images/bus.jpg --weights pretrained/yolov5s.pt

# 检测单个图片
python detect.py --source data/images/dnf-00378.jpg --weights runs/train/exp/weights/best.pt

# 检测文件夹
python detect.py --source data/images/test --weights runs/train/exp/weights/best.pt

# 检测视频
python detect.py --source data/images/test/test202206211.mp4 --weights runs/train/exp/weights/best.pt

python detect.py --source data/images/test/2022-06-25 --weights runs/train/exp6/weights/best.pt
# 监测

4.7 图形化界面验证

4.8 查看指标

tensorboard --logdir=runs

tensorboard --logdir=runs/train/exp

5. 推理测试

• 图像

• 目录

• 视频

• 网络摄像头

• http流

• rtsp流

python detect.py -h

• -weights ：预训练模型.pt的路径，默认值为：weights/yolov5s.pt

• -source：输入的数据源，可以是：图片、目录、视频、网络摄像头、http和rtsp流，默认值为：interence/images

• -output： 输出检测结果的路径，默认值为：inference/output

• -img-size ：用于推理图片的大小（pixels），默认值为：640

• -conf-thres：对象的置信度阈值（object confidence threshold），默认值为：0.4

• -iou-thres ：NMS的IOU阈值（ IOU threshold for NMS），默认值为：0.5

• -fourcc：输出视频的编码格式（必须是ffmepeg支持的），例如：H264格式，默认格式为：mp4v

• -half： 使用版精度F16推理（half precision FP16 inference），布尔值，默认为true

• -device：cuda设备，例如：0或0,1,2,3或cpu，默认''

• -view-img ：显示结果，‘布尔值，默认为true’

• -save-txt ：把结果保存到.txt文件中

• -classes：过滤类别 CLASSES [CLASSES …]，filter by class

• -agnostic-nms：类不可知 NMS

• -augment：增强推理（augmented inference）

# 示例语法（不要运行此单元格）
python detect.py --source ./file.jpg  # 图片 
                          ./file.mp4  # 视频
                          ./dir  # 目录
                          0  # 网络摄像头
      'rtsp://170.93.143.139/rtplive/470011e600ef003a004ee33696235daa' # rtsp流
      'http://112.50.243.8/PLTV/88888888/224/3221225900/1.m3u8'  # http流

5.1 图像推理

(D:\Cumtb_Code\yolo5demo) D:\Cumtb_Code\yolo5demo\yolov5-master>python detect.py --source data/images/bus.jpg --weights pretrained/yolov5s.pt

# 检测单个图片
python detect.py --source data/images/dnf-00378.jpg --weights runs/train/exp/weights/best.pt

5.2 目录推理

# 检测文件夹
python detect.py --source data/images/test --weights runs/train/exp/weights/best.pt

# 检测视频
python detect.py --source data/images/test/test202206211.mp4 --weights runs/train/exp/weights/best.pt

5.3 视频推理

# 检测视频
python detect.py --source data/images/test/test202206211.mp4 --weights runs/train/exp/weights/best.pt

5.4 网络摄像头推理

python detect.py --source 0

5.4 HTTP流推理

python detect.py --source 'https://www.bilibili.com/video/BV1vK4y1e7d3?spm_id_from=333.337.search-card.all.click&vd_source=e94b718496f013abafaf9202e5e97c96' --weights pretrained/yolov5s.pt

5.4 rtsp流推理

Demo

思路

1. 抓取屏幕

2. 实现抓取图像

import cv2
import numpy as np
import win32gui
import win32ui
import win32con
import win32api
 
 
def grab_screen(region=None):
 
    hwin = win32gui.GetDesktopWindow()
 
    if region:
        left, top, x2, y2 = region
        width = x2 - left + 1
        height = y2 - top + 1
    else:
        width = win32api.GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)
        height = win32api.GetSystemMetrics(win32con.SM_CYVIRTUALSCREEN)
        left = win32api.GetSystemMetrics(win32con.SM_XVIRTUALSCREEN)
        top = win32api.GetSystemMetrics(win32con.SM_YVIRTUALSCREEN)
 
 
    hwindc = win32gui.GetWindowDC(hwin)
    srcdc = win32ui.CreateDCFromHandle(hwindc)
    memdc = srcdc.CreateCompatibleDC()
    bmp = win32ui.CreateBitmap()
    bmp.CreateCompatibleBitmap(srcdc, width, height)
    memdc.SelectObject(bmp)
    memdc.BitBlt((0, 0), (width, height), srcdc, (left, top), win32con.SRCCOPY)
 
    signedIntsArray = bmp.GetBitmapBits(True)
    img = np.fromstring(signedIntsArray, dtype='uint8')
    img.shape = (height, width, 4)
 
    srcdc.DeleteDC()
    memdc.DeleteDC()
    win32gui.ReleaseDC(hwin, hwindc)
    win32gui.DeleteObject(bmp.GetHandle())
 
    return cv2.cvtColor(img, cv2.COLOR_BGRA2RGB)

手机案例

scrcpy简介

注意：拼写是scrcpy，非Python爬虫框架Scrapy。

scrcpy--Android投屏神器(使用教程)

注意：拼写是scrcpy，非Python爬虫框架Scrapy。 简单地来说，scrcpy就是通过adb调试的方式来将手机屏幕投到电脑上，并可以通过电脑控制您的Android设备。它可以通过USB连接，也可以通过Wifi连接（类似于隔空投屏），而且不需要任何root权限，不需要在手机里安装任何程序。scrcpy同时适用于GNU / Linux，Windows和macOS。 它的一些特性： 亮度（原生，仅显示设备屏幕） 性能（30~60fps） 质量（1920×1080或以上） 低延迟（35~70ms） 启动时间短（显示第一张图像约1秒） 非侵入性（设备上没有安装任何东西） 此项目为开源项目，Github地址： Genymobile/scrcpy: Display and control your Android device Android设备至少需要API 21（Android 5.0以上版本）; 确保在您的设备上启用了adb调试; 在某些设备上，您还需要启用其他选项以使用键盘和鼠标控制它。 adb调试的开启一般是多次点击手机系统版本，如我用的是MIUI10，开启方法是 "设置"->"我的设备"->"全部参数"->点击7下MIUI版本，开启"开发者选项"。然后在 "设置"->"更多设置"->"开发者选项" 中同时开启 USB调试 和 USB调试(安全设置) 。 注意： USB调试(安全设置) 必须开启，否则不可以使用电脑控制手机，即上述要求的第三条。 在Android手机中打开了USB调试后，我们即可在电脑中使用adb进行调试。 我使用的是Windows10系统，以下以Windows为例，MacOS或Linux请 点击这里 。 程序使用了Java语言，我们需要在电脑中搭建Java运行环境，参考： Windows10 配置 Java 开发环境 首先下载scrcpy，可去 releases下载最新版本，目前最新版本为 v1.10 。 下载地址：https://github.com/Genymobile/scrcpy/releases 解压后的目录：

https://blog.csdn.net/was172/article/details/99705855

6. 报错

AttributeError: ‘NoneType‘ object has no attribute ‘_free_weak_ref‘

原因

• pytorch版本问题，如果你pytorch是比较高的版本，那么需要降低版本。

解决方法

pip install torch==1.10.0+cu113 torchvision==0.11.1+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html  -i https://pypi.tuna.tsinghua.edu.cn/simple

YOLOv5的详细使用教程，以及使用yolov5训练自己的数据集_普通网友的博客-CSDN博客_yolov5如何运行自己的数据集

本人环境声明： 自定义数据集： git clone https://github.com/ultralytics/yolov5 # clone repo 如果下载比较慢，建议使用下面的镜像下载： git clone https://github.com.cnpmjs.org/ultralytics/yolov5 # clone repo 官方给出的要求是： python>=3.7、 PyTorch>=1.5 ，安装依赖： cd yolov5 pip install -U -r requirements.txt requirements.txt # pip install -U -r requirements.txt Cython numpy==1.17 opencv-python torch>=1.5 matplotlib pillow tensorboard PyYAML>=5.3 torchvision scipy tqdm git+https://github.com/cocodataset/cocoapi.git#subdirectory=PythonAPI # Nvidia Apex (optional) for mixed precision training -------------------------- # git clone https://github.com/NVIDIA/apex && cd apex && pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" .

https://blog.csdn.net/sinat_28371057/article/details/120598220

7. 工具

7.1 XML转YOLO格式

import xml.etree.ElementTree as ET
import pickle
import os
from os import listdir, getcwd
from os.path import join
import random
from shutil import copyfile

classes = ["car", "van", 'bus', 'others']
# classes=["ball"]

TRAIN_RATIO = 80


def clear_hidden_files(path):
    dir_list = os.listdir(path)
    for i in dir_list:
        abspath = os.path.join(os.path.abspath(path), i)
        if os.path.isfile(abspath):
            if i.startswith("._"):
                os.remove(abspath)
        else:
            clear_hidden_files(abspath)


def convert(size, box):
    dw = 1. / size[0]
    dh = 1. / size[1]
    x = (box[0] + box[1]) / 2.0
    y = (box[2] + box[3]) / 2.0
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x * dw
    w = w * dw
    y = y * dh
    h = h * dh
    return (x, y, w, h)


def convert_annotation(image_id):
    in_file = open('./VOC2007/Annotations/%s.xml' % image_id)
    out_file = open('./VOC2007/YOLOLabels/%s.txt' % image_id, 'w')
    tree = ET.parse(in_file)
    root = tree.getroot()
    size = root.find('size')
    w = int(size.find('width').text)
    h = int(size.find('height').text)

    for obj in root.iter('object'):
        difficult = obj.find('difficult').text
        cls = obj.find('name').text
        if cls not in classes or int(difficult) == 1:
            continue
        cls_id = classes.index(cls)
        xmlbox = obj.find('bndbox')
        b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
             float(xmlbox.find('ymax').text))
        bb = convert((w, h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    in_file.close()
    out_file.close()


wd = os.getcwd()
data_base_dir = os.path.join(wd)
if not os.path.isdir(data_base_dir):
    os.mkdir(data_base_dir)
work_sapce_dir = os.path.join(data_base_dir, "VOC2007/")
if not os.path.isdir(work_sapce_dir):
    os.mkdir(work_sapce_dir)
annotation_dir = os.path.join(work_sapce_dir, "Annotations/")
if not os.path.isdir(annotation_dir):
    os.mkdir(annotation_dir)
clear_hidden_files(annotation_dir)
image_dir = os.path.join(work_sapce_dir, "JPEGImages/")
if not os.path.isdir(image_dir):
    os.mkdir(image_dir)
clear_hidden_files(image_dir)
yolo_labels_dir = os.path.join(work_sapce_dir, "YOLOLabels/")
if not os.path.isdir(yolo_labels_dir):
    os.mkdir(yolo_labels_dir)
clear_hidden_files(yolo_labels_dir)
yolov5_images_dir = os.path.join(data_base_dir, "images/")
if not os.path.isdir(yolov5_images_dir):
    os.mkdir(yolov5_images_dir)
clear_hidden_files(yolov5_images_dir)
yolov5_labels_dir = os.path.join(data_base_dir, "labels/")
if not os.path.isdir(yolov5_labels_dir):
    os.mkdir(yolov5_labels_dir)
clear_hidden_files(yolov5_labels_dir)
yolov5_images_train_dir = os.path.join(yolov5_images_dir, "train/")
if not os.path.isdir(yolov5_images_train_dir):
    os.mkdir(yolov5_images_train_dir)
clear_hidden_files(yolov5_images_train_dir)
yolov5_images_test_dir = os.path.join(yolov5_images_dir, "val/")
if not os.path.isdir(yolov5_images_test_dir):
    os.mkdir(yolov5_images_test_dir)
clear_hidden_files(yolov5_images_test_dir)
yolov5_labels_train_dir = os.path.join(yolov5_labels_dir, "train/")
if not os.path.isdir(yolov5_labels_train_dir):
    os.mkdir(yolov5_labels_train_dir)
clear_hidden_files(yolov5_labels_train_dir)
yolov5_labels_test_dir = os.path.join(yolov5_labels_dir, "val/")
if not os.path.isdir(yolov5_labels_test_dir):
    os.mkdir(yolov5_labels_test_dir)
clear_hidden_files(yolov5_labels_test_dir)

train_file = open(os.path.join(wd, "yolov5_train.txt"), 'w')
test_file = open(os.path.join(wd, "yolov5_val.txt"), 'w')
train_file.close()
test_file.close()
train_file = open(os.path.join(wd, "yolov5_train.txt"), 'a')
test_file = open(os.path.join(wd, "yolov5_val.txt"), 'a')
list_imgs = os.listdir(image_dir)  # list image files
prob = random.randint(1, 100)
print("Probability: %d" % prob)
for i in range(0, len(list_imgs)):
    path = os.path.join(image_dir, list_imgs[i])
    if os.path.isfile(path):
        image_path = image_dir + list_imgs[i]
        voc_path = list_imgs[i]
        (nameWithoutExtention, extention) = os.path.splitext(os.path.basename(image_path))
        (voc_nameWithoutExtention, voc_extention) = os.path.splitext(os.path.basename(voc_path))
        annotation_name = nameWithoutExtention + '.xml'
        annotation_path = os.path.join(annotation_dir, annotation_name)
        label_name = nameWithoutExtention + '.txt'
        label_path = os.path.join(yolo_labels_dir, label_name)
    prob = random.randint(1, 100)
    print("Probability: %d" % prob)
    if (prob < TRAIN_RATIO):  # train dataset
        if os.path.exists(annotation_path):
            train_file.write(image_path + '\n')
            convert_annotation(nameWithoutExtention)  # convert label
            copyfile(image_path, yolov5_images_train_dir + voc_path)
            copyfile(label_path, yolov5_labels_train_dir + label_name)
    else:  # test dataset
        if os.path.exists(annotation_path):
            test_file.write(image_path + '\n')
            convert_annotation(nameWithoutExtention)  # convert label
            copyfile(image_path, yolov5_images_test_dir + voc_path)
            copyfile(label_path, yolov5_labels_test_dir + label_name)
train_file.close()
test_file.close()

【YOLO V5 目标检测】 Pytorch官网代码实现 | 图文教程 | 标注数据集 | 训练自己的数据集 |推理预测

目前YOLO V5一共有5个版本，Yolov5n、Yolov5s、Yolov5m、Yolov5l和Yolov5x ，如上图所示在。表现非常出色，在工业和科研上取得了广泛的应用，本文只是简单介绍YoloV5的模型和实现官网pytorch代码训练自己的目标任务。 1.1 主要分为：Backbone、Neck和Prediction三部分。 1.1.1 Backbone ：在不同细粒度的图像上提取特征的卷积神经网络。 1.1.2 Neck：混合和组合图像特征的网络层，并将图像特征传递到预测层，Neck结构借鉴PAN结构。 1.1.3 Prediction： 对图像特征进行预测，生成边界框和预测类别。 1.2 YOLO V5 网络结构细节图 这里提供 Windows 10 和 Ubuntu 深度学习环境搭建。 根据官网给的表，选择自己需要的模型权重，下载后保存在weights目录下，yolov5s.

https://zhuanlan.zhihu.com/p/497678933