YOLOv8 ultralytics使用笔记----labelme标记数据，训练模型、追踪目标。

Ultralytics是一个Python库，它是为执行高级计算机视觉任务而创建的，如对象检测、实例分割、图像分类等。Ultralytics为YOLO模型发布了一个全新的存储库，它被构建为用于机器视觉统一框架。

1.创建虚拟环境

这里先利用 Anaconda创建虚拟环境，并激活。

conda create -n yolov8 python==3.9.0
conda activate yolov8

2.加载模块

下载模块ultralytics模块

pip install ultralytics
pip install onnx

下载labelme相关模块

pip install labelme
conda install pyqt
conda install pillow

3.利用labelme标记数据

这里参考了如下文章

labelme的安装

运用labelme标记YOLOv8所需要的分隔数据

启动labelme

labelme

如下

按OpenDir ,并选择图片所在文件夹（注意路径不要出现中文）

按file  ->  change output Dir 保存标记的json文件保存地址

这里展示如何标记分隔数据

所有右击 -> create ploygons，或者直接ctrl+n

这里训练可以切割目标的模型故使用create polygons，如果只是目标检测画框即可。

通过连续点击，标记出要切割的区域，区域是闭合的（最后一个点与第一个点重合）

可以标记多个目标，他会自动变幻标记的颜色

标记完后，ctrl+s保存，按 D 按键 跳转到下一张图片，反复上述操作直到标记完所有数据

数据保存完后，每一张标记的图片都会出现与其同名的JSON文件，json文件包含了图片的类型、对应标记点坐标，图片的宽和高等数据

这里可以通过脚本将该json文件中,需要的数据提取出来并保存为YOLO需要的txt文件数据

脚本代码如下

  改好你的JSON文件路径，txt文件路径，并设置label类型,用“,”分隔。

import json 
import os 
import argparse
from tqdm import tqdm
import glob
import cv2 
import numpy as np

def convert_label_json(json_dir,save_dir,classes):
    files=os.listdir(json_dir)
    #删选出json文件
    jsonFiles=[]
    for file in files:
        if os.path.splitext(file)[1]==".json":
            jsonFiles.append(file)
    #获取类型        
    classes=classes.split(',')
    
    #获取json对应中对应元素
    for json_path in tqdm(jsonFiles):
        path=os.path.join(json_dir,json_path)
        with open(path,'r') as loadFile:
            print(loadFile)
            json_dict=json.load(loadFile)
        h,w=json_dict['imageHeight'],json_dict['imageWidth']
        txt_path=os.path.join(save_dir,json_path.replace('json','txt'))
        txt_file=open(txt_path,'w')
        
        for shape_dict in json_dict['shapes']:
            label=shape_dict['label'] 
            label_index=classes.index(label)
            points=shape_dict['points']
            points_nor_list=[]
            for point in points:
                points_nor_list.append(point[0]/w)
                points_nor_list.append(point[1]/h)
            points_nor_list=list(map(lambda x:str(x),points_nor_list))
            points_nor_str=' '.join(points_nor_list)
            label_str=str(label_index)+' '+points_nor_str+'\n'
            txt_file.writelines(label_str)
            
            
if __name__=="__main__":
    parser=argparse.ArgumentParser(description="json convert to txt params")
    #设json文件所在地址
    parser.add_argument('-json',type=str,default='your//jsonFile//path',help='json path')
    #设置txt文件保存地址
    parser.add_argument('-save',type=str,default='your//txtFile//path',help='save path')
    #设置label类型,用“,”分隔
    parser.add_argument('-classes',type=str,default='class1,class2',help='classes')
    args=parser.parse_args()
    print(args.json,args.save,args.classes)
    convert_label_json(args.json,args.save,args.classes)

运行结果如下

4.ultralytics的使用

训练数据

创建训练集测试集的yaml配置文件

注意：路径中一定要包含images文件夹，yolo会将images字符串修改成labels去找你标记的txt数据

例如

train: F:\File\AI\Object\yolov8_test\data\images  
val: F:\File\AI\Object\yolov8_test\data\images 

# number classes
nc: 1

# class names
names: ['licensePlate']

利用ultralytics训练模型

提示：这里最好联网如果你没有yolov8n-seg.pt模型，程序会自动从官网上下载

名字有“-seg”的模型代表为分割模型，没有就是一般的分类模型。

from ultralytics import YOLO

# 从头开始创建一个新的YOLO模型
model = YOLO('yolov8n.yaml')

# 加载预训练的YOLO模型（推荐用于训练）
model = YOLO('yolov8n-seg.pt')

# 使用数据集训练模型epochs个周期
results = model.train(data='F:\File\AI\Object\yolov8_test\dataset\licensePlate.yaml', epochs=100,batch=4)

# 评估模型在验证集上的性能
results = model.val()

# 使用模型对图片进行目标检测
results = model('01.jpeg')

# 将模型导出为ONNX格式
success = model.export(format='onnx')

运行结果

测试效果

利用训练的模型追踪目标，并切割目标。代码如下

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

# 加载YOLOv8模型
model = YOLO('\\train6\\weights\\best.pt')

# 打开视频文件
#video_path = "path/to/video.mp4"
cap = cv2.VideoCapture("01.mp4")

# 存储追踪历史
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 = (int)(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)

        # 展示带注释的帧
        annotated_frame=cv2.resize(annotated_frame,(640,480))
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        # 如果按下'q'则退出循环
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # 如果视频结束则退出循环
        break

# 释放视频捕获对象并关闭显示窗口
cap.release()
cv2.destroyAllWindows()

效果如下

5.其他内容积累

ultralytics加载pt和onnx模型方法一置，onnx的预测速度在实际使用中会快一点，但准确率会相对降低。

model = YOLO('model_path')  # 加载预训练模型（推荐用于训练）

利用ultralytics预测不同的yolo模型，如对目标检测、分割、关键点可得相应的结果,如下

# 加载模型
model = YOLO('yolov8n.pt')  # 预训练的 YOLOv8n 模型
# 在图片列表上运行批量推理
results = model(['im1.jpg', 'im2.jpg'],iou=0.5)  # 返回 Results 对象列表

或者

# 加载预训练的YOLOv8n模型
model = YOLO('yolov8n.pt')
# 在'bus.jpg'上运行推理，并附加参数
results=model.predict('bus.jpg',iou=0.5, save=True, imgsz=320, conf=0.5)

能够的得到检测框、分割掩码、关键点。

from ultralytics import YOLO

# 加载模型
model = YOLO('yolov8n.pt')  # 预训练的 YOLOv8n 模型

# 在图片列表上运行批量推理
results = model(['im1.jpg', 'im2.jpg'])  # 返回 Results 对象列表

# 处理结果列表
for result in results:
    boxes = result.boxes  # 边界框输出的 Boxes 对象
    masks = result.masks  # 分割掩码输出的 Masks 对象
    keypoints = result.keypoints  # 姿态输出的 Keypoints 对象
    probs = result.probs  # 分类输出的 Probs 对象

这里用print(boxes)输出Boxes对象后，可以看到它有如下内容。

cls: tensor([0., 0., 0.])
conf: tensor([0.6821, 0.5289, 0.4618])
data: tensor([[386.0858, 210.6645, 459.9648, 234.9087,   0.6821,   0.0000],
        [272.0839,  92.2477, 314.7049, 110.0637,   0.5289,   0.0000],
        [ 44.7859, 201.9768, 145.9270, 244.3890,   0.4618,   0.0000]])
id: None
is_track: False
orig_shape: (320, 800)
shape: torch.Size([3, 6])
xywh: tensor([[423.0253, 222.7866,  73.8789,  24.2442],
        [293.3944, 101.1557,  42.6210,  17.8159],
        [ 95.3564, 223.1829, 101.1411,  42.4122]])
xywhn: tensor([[0.5288, 0.6962, 0.0923, 0.0758],
        [0.3667, 0.3161, 0.0533, 0.0557],
        [0.1192, 0.6974, 0.1264, 0.1325]])
xyxy: tensor([[386.0858, 210.6645, 459.9648, 234.9087],
        [272.0839,  92.2477, 314.7049, 110.0637],
        [ 44.7859, 201.9768, 145.9270, 244.3890]])
xyxyn: tensor([[0.4826, 0.6583, 0.5750, 0.7341],
        [0.3401, 0.2883, 0.3934, 0.3439],
        [0.0560, 0.6312, 0.1824, 0.7637]])

可以看到其有cls类型、conf置信值、id等等值，为tensor数据结构，获取数据记得将数据转换

.numpy().astype('uint32')

如下

from ultralytics import YOLO 
import cv2
model=YOLO("\\runs\\detect\\train2\\weights\\best.pt")
results=model.predict("01.jpeg",iou=0.5)
img=cv2.imread("01.jpeg")
for result in results:
    boxes=result.boxes
    print(boxes)
    for x1,y1,x2,y2 in boxes.xyxy.numpy().astype('uint32'):
        print(x1,y1,x2,y2)
        cv2.rectangle(img,(x1,y1),(x2,y2),(0,0,255),2)
cv2.imshow("image",img)
cv2.waitKey()

效果

更多详细可上Ultralytics官网，看官方文档

Home - Ultralytics YOLOv8 Docs