YOLOv8从0到改，环境搭建，预测，训练，改网络结构

Caesar_566

已于 2023-09-13 21:20:16 修改

阅读量1.6k

点赞数 6

文章标签： YOLO python yolov8

于 2023-09-09 19:44:56 首次发布

本文链接：https://blog.csdn.net/weixin_62098402/article/details/132778285

版权

YOLOv8从0到改

为了论文水改yolo
设备不行，还未测试改进

环境搭建

1. anaconda

本来觉得虚拟环境会消耗没必要的资源，一直用的apt来装，然后之前因为搞roop，之前的python包环境直接全废，还因为这把系统搞废了一次。

sudo apt install python3-whatever

所以，不得不屈服下载了anaconda
anaconda下载链接

下载的bash脚本，直接回车就好，最后有一个启终端自启conda的选项，我觉得不好看就没选，选了之后觉得不好也可以去 .bashrc 里去改

装好后记得source .bashrc

source ~/.bashrc

然后看下有没有版本号，有了就行了，没有就寄了，重新装也可

conda --version

版本号显示

2. 包安装

创建虚拟环境

conda create -n env_name

进入虚拟环境

conda activate env_name

可以用conda install 也可用 pip install，我觉得conda install 不如 pip install 可配置性高，我就先在虚拟环境里装了pip，然后由于我怕它调用原来的pip，把包搞乱，就把虚拟环境的pip 叫做 cpip，.bashrc填一句就好，然后再source下

alias = cpip='your_env_pip_path'

去clone下yolov8的代码，没有git的同学，可以直接去下载zip

ps ：ssh 配好 git clone 是真的快

git clone git@github.com:/ultralytics/ultralytics,git

然后用之前的cpip下载requirements.txt

cpip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
#改了名的

pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
#没改的

后面可能会报错，XXX包没找到，继续cpip install XXX

cpip install -r XXX -i https://pypi.tuna.tsinghua.edu.cn/simple
#改了名的

pip install -r XXX -i https://pypi.tuna.tsinghua.edu.cn/simple
#没改的

至此，yolov8运行环境就ok了

开始运行

1.预测

yolov8给了CLI和python API的两种方式，因为习惯之前的yolov5，我还是选择了的python的API，并且我还能直面他的代码

新建一个python文件

from ultralytics import YOLO

model = YOLO('yolov8n.pt')
model.predict(source = '0',show = True)

运行之后，他会让你下载yolov8n.pt ，慢一些（开始摸鱼），着急的话就直接搜搜资源就好了，
下完后就可以看到，他调用了你的摄像头，告诉你你是个人，而且不是百分百确定

如果报错如下，即打不开摄像头

ConnectionError: 1/1: 1... Failed to open 0

就改上面那个文件代码

model.predict(source = '0',show = True)
#改为
model.predict()

这回看runs里的俩图片是不是被标注上了，到这就说明预测的成功了，也可以说是环境搭好了
如果不想训练，去git 上找自己想要的pt文件，就能嫖权重啦

2.训练

不是所有的权重文件都适合自己，这时就要自己去训练了

1. 数据集准备

这东西门道多，数据决定最后的训练的效果，数据集包括照片和标签，如果自己拍得话可能就要自己标，这是个大工程。标的话使用labelimg，在之前的虚拟环境下

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

装好后运行(I记得大写，是labelImg 不是labelimg)

labelImg

照片拍摄代码如下：

import cv2
cap = cv2.VideoCapture(0)

flag = cap.isOpened()
index = 1

while (flag):
    ret, frame = cap.read()
    cv2.imshow("Capture", frame)
    k = cv2.waitKey(1) & 0xFF

    if k == ord('s'):  # 按下s键，进入下面的保存图片操作
        cv2.imwrite(str(index) + ".jpg", frame)
        print("save" + str(index) + ".jpg successfuly!")
        index += 1
    elif k == ord('q'):  # 按下q键，程序退出
        break

cap.release() # 释放摄像头
cv2.destroyAllWindows()# 释放并销毁窗口

然后选择你的照片，再选择标签存放的位置，开始标注吧！

为了膨胀数据量，我还写了图片和标签共同反转和镜像的，这样就让数据量由大了四倍
照片反转

# -*- coding: UTF-8 -*-
import os
import glob
from PIL import Image
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True

path = 'images/train2017/'
#对图像读取，进行旋转和翻转处理
filelist = os.listdir(path)
filelist.sort()

imageNum = glob.glob(path)
print(len(imageNum))


for file in filelist:
    im = Image.open(path + file)
    im_rotate_90 = im.rotate(90)
    im_rotate_180 = im.rotate(180)
    im_rotate_transpose_LEFT_RIGHT= im.transpose(Image.FLIP_LEFT_RIGHT)
    im_rotate_transpose_TOP_BOTTOM = im.transpose(Image.FLIP_TOP_BOTTOM)
    
    im_rotate_90.save('./pro_90/'+ file)
    im_rotate_180.save('./pro_180/'+ file)
    im_rotate_transpose_LEFT_RIGHT.save('./pro_LR/'+ file)

标签反转

from bs4 import BeautifulSoup
import os

path = '/home/caesar/Documents/doc/test/zyx/ultralytics/tests/datasets/data_fire/labels/train2017/'#xml文件中的对应图像路径

def left(xmin, xmax, ymin, ymax):
    xmin, ymin = ymin, xmin   #向左90
    xmax, ymax = ymax, xmax
    xmin = int(xmin) + 80
    xmax = int(xmax) + 80
    ymin = 480 - (int(ymin) - 80)
    ymax = 480 - (int(ymax) - 80)
    return str(xmin), str(xmax), str(ymin), str(ymax)

def right(xmin, xmax, ymin, ymax):
    xmin = 640 - int(xmin)      #180
    xmax = 640 - int(xmax)
    ymin = 480 - (int(ymin))
    ymax = 480 - (int(ymax))
    return str(xmin), str(xmax), str(ymin), str(ymax)

def mir(xmin, xmax, ymin, ymax):
    xmin = 640 - int(xmin)      #镜像
    xmax = 640 - int(xmax)
    return str(xmin), str(xmax), str(ymin), str(ymax)


def run(filename, way):
    # print(filename)
    with open(filename , 'r') as file:
        file_str = file.read()
    filename = filename.replace('xml', 'jpg')  
    # print(file_str)
    bs = BeautifulSoup(file_str, 'lxml')
    

    bs.filename.string = filename
    bs.path.string = path
    for object in bs.find_all('object'):
        obbs = BeautifulSoup(str(object), 'lxml')
        if way == 0:
            object.xmin.string, object.xmax.string, object.ymin.string, object.ymax.string = obbs.xmin.string, obbs.xmax.string, obbs.ymin.string, obbs.ymax.string
        elif way == 1:
            object.xmin.string, object.xmax.string, object.ymin.string, object.ymax.string = left(obbs.xmin.string, obbs.xmax.string, obbs.ymin.string, obbs.ymax.string)
        elif way == 2:
            object.xmin.string, object.xmax.string, object.ymin.string, object.ymax.string = right(obbs.xmin.string, obbs.xmax.string, obbs.ymin.string, obbs.ymax.string)
        elif way == 3:
            object.xmin.string, object.xmax.string, object.ymin.string, object.ymax.string = mir(obbs.xmin.string, obbs.xmax.string, obbs.ymin.string, obbs.ymax.string)
    bs = str(bs).replace('<html><body>', '')
    bs = str(bs).replace('</body></html>', '')
    return bs


filelist = os.listdir(path)
filelist.sort()

print(filelist)
print(len(filelist))

for way in range(4):
    for file in filelist:
        bs = run(path + file, way)
        last_file = int(filelist[-1].replace('.xml', ''))
        file = str(int(file.replace('.xml', '')) + (way * last_file)) + '.xml'
        print(file,end=' ')

        xml_file = open(file,'w')
        xml_file.write(bs)
        xml_file.close()

也可去github自行拉取

git clone git@github.com:Caesar566/yolo-dataset-processing.git

标注完成后然后就得到了数据集

2.标签转化与数据集划分

这里需要将我们之前标注的xml文件转化为与yolo相适配的txt文件，我自己没写过，搜一下标签转化与数据集划分的代码放进去运行即可，就不在此粘贴，这样就得到了txt后缀的文件和划分后的训练集与验证集

3.开始训练

新建文件yolo_train.py

from ultralytics import YOLO

model = YOLO('yolov8n.yaml').load('yolov8n.pt') 
model.train(data='coco128.yaml', epochs = 300, batch = 16)

在train函数中其他常用的参数如下

参数	作用
data	数据路径
epochs	训练轮数
batch	每训练多少轮生成一次权重文件
device	使用什么设备进行训练，默认cpu，使用显卡时需要装CUDA
imgsz	图像压缩尺寸，默认640

然后不要着急运行，data 的yaml文件我们还没有，新建yaml文件

path: ../datasets/coco8-seg  # dataset root dir
train: images/train  # train images (relative to 'path') 4 images
val: images/val  # val images (relative to 'path') 4 images
test:  # test images (optional)

#Classes
names:   
  0: person
  1: bicycle
  2: car

names 里的类根据自己的数据集种类来，路径名称自己随意来
文件树如下：

ultralytics/
datasets/
└── coco128-seg
    ├── images
    │   └── train2017
    └── labels
        └── train2017
            └── coco128-seg.yaml

如果不出意外的话，应该就可以开始训练了，如果报错出现列表超出范围就需要找到yolov8n.yaml的路径

ultralytics/ultralytics/cfg/models/v8/yolov8.yaml

将里面的nc后的数量改为自己的数据集的数量，然后训练最后会得到best.pt和last.pt，把这两个的其中一个权重文件放入之前的预测文件中，即把yolov8n 改为 best.pt，就可以进行验证了。（注意路径）

3. 改网络结构

yolov8 改结构是比较方便的，但是改好就有点难了，水一水还是可以的，这个无非就是排列组合的问题，在如下路径下的模块已经备好了，如果自己填的话也相应填在对应的部分

test/ultralytics/ultralytics/nn/modules

在主目录下新建default.yaml

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80  # number of classes 数据集类别数
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  #  本层的输入（-1代表上层输出作为输入）    本层的重复次     数   本层的名称   本层的参数
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2 64代表输出的通道 3代表卷积核的大小 2代表步长
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f, [256]]  # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 21 (P5/32-large)

  - [[15, 18, 21], 1, Detect, [nc]]  # Detect(P3, P4, P5)

然后去随意的替换其中的网络就算改啦，其中的各个结构要对应好

改好后在再训练，即运行这个

from ultralytics import YOLO

model = YOLO('default.yaml').load('yolov8n.pt') 
model.train(data='coco128.yaml', epochs = 300, batch = 16)

训练后去看网络结构是不是变化了

netron的使用

对于网络结构的变化，使用netron能够清楚地看出来，但是它对onnx格式的文件的处理比较友好，所以我们需要将pt格式的文件转化为onnx的文件

首先装包

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

然后运行文件

from ultralytics import YOLO

model = YOLO('yolov8n.pt')
model.export(format='onnx')

输出onnx格式的文件，导入到netron网站中

netron网址

即可看到网络结构
yolov8n基本网络结构