0


(笔记)ubuntu20.04下 yolov5学习与使用

1项目的克隆和必要的环境依赖

1.1:目前暂时下载yolov5下的7.0分支并解压至自己的工程目录(~/Yolov5_Study)里:官网 GitHub - ultralytics/yolov5 at v7.0

tree -L 1 yolov5-7.0/

这里通过tree的1级别可以看到的目录一层结构:

data:配置文件,训练集、测试集、验证集的路径 还包含目标检测的种类数及种类的名称,和官方提供测试的图片. 如要自己训练数据集是要修改其中的yaml文件。自己的数据集放到yolov5项目的同级目录下面。

models:网络构建的配置文件和函数,包含该项目四个版本,为s、m、l、x。体积从小至大,对应版本检测速度从快到慢,精确度则从低到高。如训练自己的数据集,需改对应yaml文件训练自己模型。

utils:存放的是工具类的函数,里面有loss函数,metrics函数,plots函数等等。

weights:放置训练好的权重参数。

detect.py:利用训练好的权重参数进行目标检测,可以进行图像、视频和摄像头的检测。

train.py:训练自己的数据集的函数。

test.py:测试训练的结果的函数。

requirements.txt:是文本文件,写有yolov5项目的依赖包对应版本,可用该导入相应版本的包。

以上是yolov5项目代码的整体介绍。我们训练和测试自己的数据集基本就是利用到如上的代码。

1.2:在pycharm(或ubuntu系统)的命令终端(上篇笔记conda创建pytorch里),进入上面yolov5.7目录执行命令安装相关依赖:(如有中断,多试几次)

pip install -r requirements.txt
或
pip install -r requirements.txt -i http://pypi.douban.com/simple --trusted-host pypi.douban.com

2 数据集和预训练权重的准备

2.1:labelimg制作自己的深度学习目标检测数据集

自己的数据集放到yolov5项目的同级目录下面且按如下目录结构创建:

VOC_data/
├── EndTestData_JPEGImages #存放验证集的图片
├── EndTestData_YoloLabel #存放验证集标注的标签(yolo格式)
├── predefined_classes.txt #定义自己要标注的所有类别名单
├── Source_JPEGImages #存放需要打标签的图片源素材文件夹
├── Source_YoloLabel #存放 voc格式数据 转 yolo格式数据的文件夹
├── toolkit #必备工具箱
│ ├── create_EndTestData.py #创建验证集和对应标签的脚本
│ ├── voc_to_yolo.py #将VOC格式数据标签 转换为yolo的脚本
│ └── yolo_to_voc.py #将yolo格式数据标签 转换为voc的脚本
└── VOC_Label #存放最初标注的标签文件夹,VOC的xml格式,优点好读

项目数据训练素材收集源:

网上公开的资源:百度,AI Studio,抖音...

非公开资源(如没有合适的):自己录制,公司内部获取...

labelimg 安装:

pip install labelimg -i https://pypi.tuna.tsinghua.edu.cn/simple

切记请进入自己数据集的根目录(本文:~/Yolov5_Study/VOC_data)再运行labelimg:

cd ~/Yolov5_Study/VOC_data

labelImg Source_JPEGImages predefined_classes.txt

如你所见下图:三个都勾选和点选专家模式

常用快捷键如下:

w:调出并一直悬浮标注十字架(仅专家模式下可用)

a:切换到上一张图片

d:切换到下一张图片

del :删除标注框框

Ctrl+u:选择标注的图片文件夹

Ctrl+r:选择标注好的label标签存在的文件夹

按快捷键w,按住鼠标左键拖出框框就可以了。如下图所示,当我们选定目标以后,就会加载出来predefined_classes.txt 定义自己要标注的所有类别(如果类别多,是真方便)。然后界面最右边会出现打好的类别标签。打好一张照片以后,快捷键D,就会进入下一张,这时候就会自动保存标签文件

下图同一张图里标注多个目标右中显示 :car, lidar.

voc格式数据与yolo格式数据互转:

需注要意的是一定要将代码中 类别名字及顺序 与predefined_classes.txt里的 保持一致!

voc格式 转 yolo格式的python代码:

      VOC格式文件保存时:是采用对应图像名称 加xml后缀的文件。

      (当然可省去这步内容:在标注数据时将PascalVOC改为yolo格式。代价是yolo难以阅读)
import xml.etree.ElementTree as ET
import pickle
import os
from os import listdir, getcwd
from os.path import join

"""
This is a conversion script from voc data format to yolo data format
"""

def convert(size, box):
    x_center = (box[0] + box[1]) / 2.0
    y_center = (box[2] + box[3]) / 2.0
    x = x_center / size[0]
    y = y_center / size[1]
    w = (box[1] - box[0]) / size[0]
    h = (box[3] - box[2]) / size[1]
    return (x, y, w, h)
 
 
def convert_annotation(xml_files_path, save_txt_files_path, classes):
    xml_files = os.listdir(xml_files_path)
    print(xml_files)
    for xml_name in xml_files:
        print(xml_name)
        xml_file = os.path.join(xml_files_path, xml_name)
        out_txt_path = os.path.join(save_txt_files_path, xml_name.split('.')[0] + '.txt')
        out_txt_f = open(out_txt_path, 'w')
        tree = ET.parse(xml_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))
            # b=(xmin, xmax, ymin, ymax)
            print(w, h, b)
            bb = convert((w, h), b)
            out_txt_f.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
 
 
if __name__ == "__main__":
    # 需要转换的类别,需要一一对应
    classes1 = ['person', 'dog']
    # 2、voc格式的xml标签文件路径
    xml_files1 = r'/home/t/Yolov5_Study/VOC_data/VOC_Label'
    # 3、转化为yolo格式的txt标签文件存储路径
    save_txt_files1 = r'/home/t/Yolov5_Study/VOC_data/Source_YoloLabel'
 
    convert_annotation(xml_files1, save_txt_files1, classes1)

yolo 转 voc 代码:(未用暂未改路径)

from xml.dom.minidom import Document
import os
import cv2

"""
This is a conversion script from yolo data format to voc data format
"""

# def makexml(txtPath, xmlPath, picPath):  # txt所在文件夹路径,xml文件保存路径,图片所在文件夹路径
def makexml(picPath, txtPath, xmlPath):  # txt所在文件夹路径,xml文件保存路径,图片所在文件夹路径
    """此函数用于将yolo格式txt标注文件转换为voc格式xml标注文件
    在自己的标注图片文件夹下建三个子文件夹,分别命名为picture、txt、xml
    """
    dic = {'0': "boat",  # 创建字典用来对类型进行转换
           '1': "cat",  # 此处的字典要与自己的classes.txt文件中的类对应,且顺序要一致
           }
    files = os.listdir(txtPath)
    for i, name in enumerate(files):
        xmlBuilder = Document()
        annotation = xmlBuilder.createElement("annotation")  # 创建annotation标签
        xmlBuilder.appendChild(annotation)
        txtFile = open(txtPath + name)
        txtList = txtFile.readlines()
        img = cv2.imread(picPath + name[0:-4] + ".jpg")
        Pheight, Pwidth, Pdepth = img.shape
 
        folder = xmlBuilder.createElement("folder")  # folder标签
        foldercontent = xmlBuilder.createTextNode("driving_annotation_dataset")
        folder.appendChild(foldercontent)
        annotation.appendChild(folder)  # folder标签结束
 
        filename = xmlBuilder.createElement("filename")  # filename标签
        filenamecontent = xmlBuilder.createTextNode(name[0:-4] + ".jpg")
        filename.appendChild(filenamecontent)
        annotation.appendChild(filename)  # filename标签结束
 
        size = xmlBuilder.createElement("size")  # size标签
        width = xmlBuilder.createElement("width")  # size子标签width
        widthcontent = xmlBuilder.createTextNode(str(Pwidth))
        width.appendChild(widthcontent)
        size.appendChild(width)  # size子标签width结束
 
        height = xmlBuilder.createElement("height")  # size子标签height
        heightcontent = xmlBuilder.createTextNode(str(Pheight))
        height.appendChild(heightcontent)
        size.appendChild(height)  # size子标签height结束
 
        depth = xmlBuilder.createElement("depth")  # size子标签depth
        depthcontent = xmlBuilder.createTextNode(str(Pdepth))
        depth.appendChild(depthcontent)
        size.appendChild(depth)  # size子标签depth结束
 
        annotation.appendChild(size)  # size标签结束
 
        for j in txtList:
            oneline = j.strip().split(" ")
            object = xmlBuilder.createElement("object")  # object 标签
            picname = xmlBuilder.createElement("name")  # name标签
            namecontent = xmlBuilder.createTextNode(dic[oneline[0]])
            picname.appendChild(namecontent)
            object.appendChild(picname)  # name标签结束
 
            pose = xmlBuilder.createElement("pose")  # pose标签
            posecontent = xmlBuilder.createTextNode("Unspecified")
            pose.appendChild(posecontent)
            object.appendChild(pose)  # pose标签结束
 
            truncated = xmlBuilder.createElement("truncated")  # truncated标签
            truncatedContent = xmlBuilder.createTextNode("0")
            truncated.appendChild(truncatedContent)
            object.appendChild(truncated)  # truncated标签结束
 
            difficult = xmlBuilder.createElement("difficult")  # difficult标签
            difficultcontent = xmlBuilder.createTextNode("0")
            difficult.appendChild(difficultcontent)
            object.appendChild(difficult)  # difficult标签结束
 
            bndbox = xmlBuilder.createElement("bndbox")  # bndbox标签
            xmin = xmlBuilder.createElement("xmin")  # xmin标签
            mathData = int(((float(oneline[1])) * Pwidth + 1) - (float(oneline[3])) * 0.5 * Pwidth)
            xminContent = xmlBuilder.createTextNode(str(mathData))
            xmin.appendChild(xminContent)
            bndbox.appendChild(xmin)  # xmin标签结束
 
            ymin = xmlBuilder.createElement("ymin")  # ymin标签
            mathData = int(((float(oneline[2])) * Pheight + 1) - (float(oneline[4])) * 0.5 * Pheight)
            yminContent = xmlBuilder.createTextNode(str(mathData))
            ymin.appendChild(yminContent)
            bndbox.appendChild(ymin)  # ymin标签结束
 
            xmax = xmlBuilder.createElement("xmax")  # xmax标签
            mathData = int(((float(oneline[1])) * Pwidth + 1) + (float(oneline[3])) * 0.5 * Pwidth)
            xmaxContent = xmlBuilder.createTextNode(str(mathData))
            xmax.appendChild(xmaxContent)
            bndbox.appendChild(xmax)  # xmax标签结束
 
            ymax = xmlBuilder.createElement("ymax")  # ymax标签
            mathData = int(((float(oneline[2])) * Pheight + 1) + (float(oneline[4])) * 0.5 * Pheight)
            ymaxContent = xmlBuilder.createTextNode(str(mathData))
            ymax.appendChild(ymaxContent)
            bndbox.appendChild(ymax)  # ymax标签结束
 
            object.appendChild(bndbox)  # bndbox标签结束
 
            annotation.appendChild(object)  # object标签结束
 
        f = open(xmlPath + name[0:-4] + ".xml", 'w')
        xmlBuilder.writexml(f, indent='\t', newl='\n', addindent='\t', encoding='utf-8')
        f.close()
 
if __name__ == "__main__":
    picPath = "C:/Users/86159/Desktop/VOC2007/JPEGImage/"  # 图片所在文件夹路径,后面的/一定要带上
    txtPath = "C:/Users/86159/Desktop/VOC2007/yolo/"  # txt所在文件夹路径,后面的/一定要带上
    xmlPath = "C:/Users/86159/Desktop/VOC2007/Annotations1/"  # xml文件保存路径,后面的/一定要带上
    makexml(picPath, txtPath, xmlPath)
 

将数据集划分为训练集和验证集:

在做深度学习目标检测模型训练时,首先获取数据集,然后对数据集进行标注,然后再把标注完的数据集划分为训练集和验证集,这样更加方便模型的训练和测试。以下是划分数据集的代码。

(当然也可以省去这步内容:训练数据同时也作为测试数据用)

import os, random, shutil
 
 
def moveimg(fileDir, tarDir):
    pathDir = os.listdir(fileDir)  # 取图片的原始路径
    filenumber = len(pathDir)
    rate = 0.1  # 自定义抽取图片的比例,比方说100张抽10张,那就是0.1
    picknumber = int(filenumber * rate)  # 按照rate比例从文件夹中取一定数量图片
    sample = random.sample(pathDir, picknumber)  # 随机选取picknumber数量的样本图片
    print(sample)
    for name in sample:
        shutil.move(fileDir + name, tarDir + "/" + name)
    return
 
def movelabel(file_list, file_label_train, file_label_val):
    for i in file_list:
        if i.endswith('.jpg'):
            filename = file_label_train + "/" + i[:-4] + '.txt'  # 可以改成xml文件将’.txt‘改成'.xml'就可以了
            if os.path.exists(filename):
                shutil.move(filename, file_label_val)
                print(i + "处理成功!")
 
 
 
if __name__ == '__main__':
    fileDir = r"/home/t/Yolov5_Study/VOC_data/Source_JPEGImages/"  #源图片文件夹路径
    tarDir = r'/home/t/Yolov5_Study/VOC_data/EndTestData_JPEGImages'  # 图片移动到新的文件夹路径
    moveimg(fileDir, tarDir)
    file_list = os.listdir(tarDir)
    file_label_train = r"/home/t/Yolov5_Study/VOC_data/Source_YoloLabel/"  # 源图片标签路径
    file_label_val = r"/home/t/Yolov5_Study/VOC_data/EndTestData_YoloLabel"  # 标签
      # 移动到新的文件路径
    movelabel(file_list, file_label_train, file_label_val)

如上代码原理:按比例(自行修改第7行中rate值)将抽取源照片 及其对应的源标签文件 分别放入到它俩新建的文件夹中(该俩文件夹需要新建)。这样源文件夹就变成了训练集,新建的为验证集及其标签文件。方便测试用。

此时将训练集和验证集的图片和标签文件分别复制到yolov5根目录 新建的my_data文件夹里images,labels

2.2下载权重文件:

要缩短训练时间和更好的精度,应加载预训练权重进行网络的训练。下图权重的名字和大小信息,可知,权重越大,训练出来的精度就越高,但其检测的速度就越慢。

https://github.com/ultralytics/yolov5/releases/download/v6.2/yolov5s.pt

https://github.com/ultralytics/yolov5/releases/download/v6.2/yolov5x.pt

将下载的yolov5*.pt复制到yolov5的根目录里

​​

3训练自己的模型

3.1修改数据配置文件

要修改data和model两个目录下对应yaml文件中的参数。

   在data目录下新建yaml文件:根据自个项目为其命名为dog.yaml。该项目是对狗的识别。

   然后复制如下的代码在dog.yaml
# train and val data as 1) directory: path/images/, 2) file: path/images.txt, or 3) list: [path1/images/, path2/images/]
train: my_data/images/  # 16551 images # # 训练集图片路径
val: my_data/images/  # 4952 images  ##验证集图片路径

# number of classes
nc: 1  ##标记类的个数

# class names
names: [ 'dog' ]  ##标记类的名称

按ctrl+o 回车保存 再ctrl+x退出nano编辑器

上面填写需要识别的类别的名字(必须是英文,否则会乱码识别不出来)

3.2修改模型配置文件

本次用yolov5s.pt这个预训练权重,修改models目录下的yolov5s.yaml文件中的相应参数(因为不同的预训练权重对应着不同的网络层数,所以用错预训练权重会报错)。将yolov5s.yaml文件复制一份,重命名为yolov5s_dog.yaml。

打开yolov5s_dog.yaml文件只需要修改如图中nc的数字就好了,这里是识别一个类别

3.3训练自己的模型

yolov5根目录里找到train.py这个py文件修改几个参数

然后找到主函数的入口,这里面有模型的主要参数。模型的主要参数解析如下所示

if __name__ == '__main__':
"""
    opt模型主要参数解析:
    --weights:初始化的权重文件的路径地址
    --cfg:模型yaml文件的路径地址
    --data:数据yaml文件的路径地址
    --hyp:超参数文件路径地址
    --epochs:训练轮次
    --batch-size:喂入批次文件的多少
    --img-size:输入图片尺寸
    --rect:是否采用矩形训练,默认False
    --resume:接着打断训练上次的结果接着训练
    --nosave:不保存模型,默认False
    --notest:不进行test,默认False
    --noautoanchor:不自动调整anchor,默认False
    --evolve:是否进行超参数进化,默认False
    --bucket:谷歌云盘bucket,一般不会用到
    --cache-images:是否提前缓存图片到内存,以加快训练速度,默认False
    --image-weights:使用加权图像选择进行训练
    --device:训练的设备,cpu;0(表示一个gpu设备cuda:0);0,1,2,3(多个gpu设备)
    --multi-scale:是否进行多尺度训练,默认False
    --single-cls:数据集是否只有一个类别,默认False
    --adam:是否使用adam优化器
    --sync-bn:是否使用跨卡同步BN,在DDP模式使用
    --local_rank:DDP参数,请勿修改
    --workers:最大工作核心数
    --project:训练模型的保存位置
    --name:模型保存的目录名称
    --exist-ok:模型目录是否存在,不存在就创建
"""
    parser = argparse.ArgumentParser()
    parser.add_argument('--weights', type=str, default='yolov5s.pt', help='initial weights path')
    parser.add_argument('--cfg', type=str, default='', help='model.yaml path')
    parser.add_argument('--data', type=str, default='data/coco128.yaml', help='data.yaml path')
    parser.add_argument('--hyp', type=str, default='data/hyp.scratch.yaml', help='hyperparameters path')
    parser.add_argument('--epochs', type=int, default=300)
    parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs')
    parser.add_argument('--img-size', nargs='+', type=int, default=[640, 640], help='[train, test] image sizes')
    parser.add_argument('--rect', action='store_true', help='rectangular training')
    parser.add_argument('--resume', nargs='?', const=True, default=False, help='resume most recent training')
    parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')
    parser.add_argument('--notest', action='store_true', help='only test final epoch')
    parser.add_argument('--noautoanchor', action='store_true', help='disable autoanchor check')
    parser.add_argument('--evolve', action='store_true', help='evolve hyperparameters')
    parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')
    parser.add_argument('--cache-images', action='store_true', help='cache images for faster training')
    parser.add_argument('--image-weights', action='store_true', help='use weighted image selection for training')
    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    parser.add_argument('--multi-scale', action='store_true', help='vary img-size +/- 50%%')
    parser.add_argument('--single-cls', action='store_true', help='train multi-class data as single-class')
    parser.add_argument('--adam', action='store_true', help='use torch.optim.Adam() optimizer')
    parser.add_argument('--sync-bn', action='store_true', help='use SyncBatchNorm, only available in DDP mode')
    parser.add_argument('--local_rank', type=int, default=-1, help='DDP parameter, do not modify')
    parser.add_argument('--workers', type=int, default=8, help='maximum number of dataloader workers')
    parser.add_argument('--project', default='runs/train', help='save to project/name')
    parser.add_argument('--entity', default=None, help='W&B entity')
    parser.add_argument('--name', default='exp', help='save to project/name')
    parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
    parser.add_argument('--quad', action='store_true', help='quad dataloader')
    parser.add_argument('--linear-lr', action='store_true', help='linear LR')
    parser.add_argument('--label-smoothing', type=float, default=0.0, help='Label smoothing epsilon')
    parser.add_argument('--upload_dataset', action='store_true', help='Upload dataset as W&B artifact table')
    parser.add_argument('--bbox_interval', type=int, default=-1, help='Set bounding-box image logging interval for W&B')
    parser.add_argument('--save_period', type=int, default=-1, help='Log model after every "save_period" epoch')
    parser.add_argument('--artifact_alias', type=str, default="latest", help='version of dataset artifact to be used')
    opt = parser.parse_args()

将weights权重的对应路径,yolov5s_dog.yaml文件路径,data数据的dog.yaml文件路径分别填写到相应的参数里面。

    parser.add_argument('--weights', type=str, default='yolov5s.pt', help='initial weights path')
    parser.add_argument('--cfg', type=str, default='models/yolov5s_dog.yaml', help='model.yaml path')
    parser.add_argument('--data', type=str, default='data/dog.yaml', help='data.yaml path')

还有几个需要根据自己的需求来更改的参数:

模型的训练轮次,如训练的300轮。

parser.add_argument('--epochs', type=int, default=300)

其次是输入图片的数量和工作的核心数,这里每个人的电脑的性能都不一样,我的配置低这里就调低:4

parser.add_argument('--batch-size', type=int, default=4, help='total batch size for all GPUs')
parser.add_argument('--workers', type=int, default=4, help='maximum number of dataloader workers')

终端进入yolov5.7目录下执行:

python3.8 train.py

这里遇到四个报错,而yolov5.5的没这么多就一个

此时报错1:

ModuleNotFoundError: No module named 'IPython'
解决:conda install -c anaconda ipython

报错2:

ModuleNotFoundError: No module named 'psutil'

解决:编辑yolov5-7/models/common.py

 找到class SPP这一行,在上面添加class SPPF,代码如下:
class SPPF(nn.Module):
    def __init__(self, c1, c2, k=5):
        super().__init__()
        c_ = c1 // 2
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)
 
    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))

报错3:

ModuleNotFoundError: No module named 'psutil'

解决:conda install psutil

报错4:

export GIT_PYTHON_REFRESH=quiet

解决:

sudo vim /etc/profile
添加 :export GIT_PYTHON_REFRESH=quiet
wq 保存
source /etc/profile

此时不要关闭窗口直接运行 python3.8 train.py 进行训练自己的模型

等到数据训练好了以后,就会在主目录下产生一个run文件夹,在run/train/exp/weights目录下会产生两个权重文件,一个是最后一轮的权重文件,一个是最好的权重文件,一会我们就要利用这个最好的权重文件来做推理测试。除此以外还会产生一些验证文件的图片等一些文件。

另外一个执行方式:
python3 train.py --img 600 --batch 50 --epochs 300 --data data/dog.yaml --weights yolov5s.pt --cache --batch-size 4

3.4启用tensorbord查看参数

运行这段指令后,将那行网址复制下来到浏览器打开就可以看到训练的过程了

tensorboard --logdir=runs/train

3.5用自己权重模型进行推理

找到主目录下的detect.py文件,打开该文件

然后找到主函数的入口,这里面有模型的主要参数。模型的主要参数解析如下所示。

if __name__ == '__main__':
"""
--weights:权重的路径地址
--source:测试数据,可以是图片/视频路径,也可以是'0'(电脑自带摄像头),也可以是rtsp等视频流
--output:网络预测之后的图片/视频的保存路径
--img-size:网络输入图片大小
--conf-thres:置信度阈值
--iou-thres:做nms的iou阈值
--device:是用GPU还是CPU做推理
--view-img:是否展示预测之后的图片/视频,默认False
--save-txt:是否将预测的框坐标以txt文件形式保存,默认False
--classes:设置只保留某一部分类别,形如0或者0 2 3
--agnostic-nms:进行nms是否也去除不同类别之间的框,默认False
--augment:推理的时候进行多尺度,翻转等操作(TTA)推理
--update:如果为True,则对所有模型进行strip_optimizer操作,去除pt文件中的优化器等信息,默认为False
--project:推理的结果保存在runs/detect目录下
--name:结果保存的文件夹名称
"""
    parser = argparse.ArgumentParser()
    parser.add_argument('--weights', nargs='+', type=str, default='yolov5s.pt', help='model.pt path(s)')
    parser.add_argument('--source', type=str, default='data/images', help='source')  # file/folder, 0 for webcam
    parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
    parser.add_argument('--conf-thres', type=float, default=0.25, help='object confidence threshold')
    parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
    parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
    parser.add_argument('--view-img', action='store_true', help='display results')
    parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
    parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
    parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
    parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
    parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
    parser.add_argument('--augment', action='store_true', help='augmented inference')
    parser.add_argument('--update', action='store_true', help='update all models')
    parser.add_argument('--project', default='runs/detect', help='save results to project/name')
    parser.add_argument('--name', default='exp', help='save results to project/name')
    parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
    opt = parser.parse_args()

这里需要将刚刚训练好的最好的权重传入到推理函数中去。然后就可以对图像视频进行推理了。

parser.add_argument('--weights', nargs='+', type=str, default='runs/train/exp/weights/best.pt', help='model.pt path(s)')
     对图片进行测试推理,将如下参数修改成单张图片/一个图片文件夹的路径,然后运行detect.py就可以进行测试了。
 parser.add_argument('--source', type=str, default='my_data/images/', help='source') 
    推理测试结束以后,在run下面会生成一个detect目录,推理结果会保存在exp目录下。

对视频进行测试,和如上的图片的测试是一样的,只不过是将图片的路径改为视频的路径而已。利用摄像头进行测试只需将路径改写为0就好了。但是好像还是会报错,这一点卡了我很久。报错如下。

解决方法:首先在utils 下找到datasets.py这个py文件

打开文件,找到第279行代码,给两个url参数加上str就可以了,如图所示,就可以完美运行电脑的摄像头了。

学习 yolov5.7 完结 <<<<<<<<<<<<

END 本文的学习来自于:

目标检测---教你利用yolov5训练自己的目标检测模型

Yolov5-7.0机器视觉应用教程 - 哔哩哔哩

一步真实解决RuntimeError: result type Float can‘t be cast to the desired output type long int_蓝胖胖▸的博客-CSDN博客

报错ModuleNotFoundError: No module named ‘IPython‘_SpaceVision的技术博客_51CTO博客

运行YOLOv5出现报错找不到SPPF错误,进行解决AttributeError: Can‘t get attribute ‘SPPF‘ on <module ‘models.common‘ from_TT花下人的博客-CSDN博客


本文转载自: https://blog.csdn.net/ID_user_name/article/details/127955404
版权归原作者 小白菜的笔记 所有, 如有侵权,请联系我们删除。

“(笔记)ubuntu20.04下 yolov5学习与使用”的评论:

还没有评论