YOLO11 目标检测 | 自动标注 | 预标注 | 标签格式转换 | 手动校正标签

本文分享使用YOLO11进行目标检测时，实现模型推理预标注、自动标注、标签格式转换、以及使用Labelme手动校正标签等功能。

目录

1、预训练权重

 2、生成预标注

3、分析YOLO11的目标检测格式

4、分析Labelme标注工具的格式

5、生成json标注文件

6、手动校正标签

7、Labelme的json转为YOLO的txt

8、迭代优化模型（可选）

1、预训练权重

首先我们去官网下载，YOLO11目标检测的预训练权重，如下表格式所示：

下载地址：https://github.com/ultralytics/ultralytics

Modelsize
(pixels)		mAPval
50-95		Speed
CPU ONNX
(ms)		Speed
T4 TensorRT10
(ms)		params
(M)		FLOPs
(B)
YOLO11n64039.556.1 ± 0.81.5 ± 0.02.66.5
YOLO11s64047.090.0 ± 1.22.5 ± 0.09.421.5
YOLO11m64051.5183.2 ± 2.04.7 ± 0.120.168.0
YOLO11l64053.4238.6 ± 1.46.2 ± 0.125.386.9
YOLO11x64054.7462.8 ± 6.711.3 ± 0.256.9194.9

然后基于预训练权重，准备自己的数据集，进行模型训练

最终，得到效果更好的模型权重（xxx.pt或xxx.onnx）

 2、生成预标注

前面得到了效果更好的模型权重，这里用它来对新的图片，进行推理，同时生成目标检测的信息。

模型推理的代码，如下所示：

  1. from ultralytics import YOLO
  2.  
  3. # 加载训练的模型
  4. model = YOLO(r"runs/detect/train/weights/best.pt")
  5.  
  6. # 对指定的图像文件夹进行推理，并设置各种参数
  7. results = model.predict(
  8.     source="datasets/det_20241020/images/",   # 新的图片，待标注的图片
  9.     conf=0.45,                      # 置信度阈值
  10.     iou=0.6,                        # IoU 阈值
  11.     imgsz=640,                      # 图像大小
  12.     half=False,                     # 使用半精度推理
  13.     device=None,                    # 使用设备，None 表示自动选择，比如'cpu','0'
  14.     max_det=300,                    # 最大检测数量
  15.     vid_stride=1,                   # 视频帧跳跃设置
  16.     stream_buffer=False,            # 视频流缓冲
  17.     visualize=False,                # 可视化模型特征
  18.     augment=False,                  # 启用推理时增强
  19.     agnostic_nms=False,             # 启用类无关的NMS
  20.     classes=None,                   # 指定要检测的类别
  21.     retina_masks=False,             # 使用高分辨率分割掩码
  22.     embed=None,                     # 提取特征向量层
  23.     show=False,                     # 是否显示推理图像
  24.     save=True,                      # 保存推理结果
  25.     save_frames=False,              # 保存视频的帧作为图像
  26.     save_txt=True,                  # 保存检测结果到文本文件
  27.     save_conf=False,                # 保存置信度到文本文件
  28.     save_crop=False,                # 保存裁剪的检测对象图像
  29.     show_labels=True,               # 显示检测的标签
  30.     show_conf=True,                 # 显示检测置信度
  31.     show_boxes=True,                # 显示检测框
  32.     line_width=None                 # 设置边界框的线条宽度，比如2，4
  33. )
  • 需要修改model = YOLO(r"runs/detect/train/weights/best.pt")中的权重路径，替换为自己训练的
  • 同时需要修改source="datasets/det_20241020/images/", 这里是指新的图片，即待标注的图片
  • 其他推理参数，根据任务情况，自行修改了；比如：置信度conf、iou、图像大小imgsz等等。

推理完成后，会保留目标检测的结果图像、标签信息文件夹（labels），它们是同一级文件夹的

- runs/detect/predict/

        - labels（这个文件夹是存放YOLO11推理结果，作为预标注的标签信息）

        - picture1.jpg

        - picture2.jpg

                .....

        - pictureN.jpg

3、分析YOLO11的目标检测格式

YOLO11的标签文件是一个包含每行一个标签的txt文件。

每一行的格式是： 。其中：

  • 是类别索引。
  • 和是目标的中心点坐标（归一化到0-1）。
  • 和是目标的宽度和高度（归一化到0-1）。

txt标签示例数据，表示有两个物体：

0 0.5192 0.4512 0.3985 0.7572
3 0.5061 0.5921 0.2631 0.4561

  • 第一行表示物体1，类别为0，0.5192是中心点x坐标，0.4512是中心点y坐标，0.3985是宽度， 0.7572是高度。
  • 第二行表示物体2，类别为3，0.5061是中心点x坐标，0.5921是中心点y坐标，0.2631是宽度， 0.4561是高度。

4、分析Labelme标注工具的格式

在目标检测中，我们使用Labelme工具进行标注，选择“创建矩形”，对物体进行标注。

  • 标注后点击保存，会生成JSON标注文件；
  • 这样能使用Labelme，可视化检查预标注的结果，方便人工手动修正标签

LabelMe使用的是JSON格式，每个标签是一个形状（shape）对象，包含以下信息： 

  • label: 标签的名称。
  • points: 多边形的点列表（包含多边形顶点的坐标）。
  • group_id: （可选）用于将不同形状分组的ID。
  • shape_type: 形状类型（例如rectangle, circle等）。
  • flags: （可选）一些额外的标记信息。

5、生成json标注文件

编写程序，遍历该文件夹中的所有txt文件，然后将生成的Labelme的JSON文件保存到指定的输出文件夹中

  • 定义类别映射：创建一个字典，将YOLO11类别ID映射到相应的类名。

  • 转换函数：定义yolo_to_labelme函数，接收YOLO11格式的txt文件路径和图像尺寸，读取标注数据，计算绝对坐标，并格式化为LabelMe的JSON结构。

  • 主函数实现：

    • 指定输入图像和标签文件夹路径，以及输出JSON文件的路径。
    • 检查输出目录是否存在，如不存在则创建。
    • 遍历标签文件夹中的所有.txt文件，读取相应的图像文件。
    • 使用OpenCV读取图像以获取其高度和宽度。
    • 调用转换函数生成标注数据。
    • 将生成的LabelMe格式数据写入新的JSON文件。

这里会提供源代码，需要根据我们的数据修改以下部分：

  1. import os
  2. import json
  3. import cv2
  4.  
  5. # 自定义类别映射
  6. class_map = {
  7.     0: 'class_name1',   # 类别 0 对应的名称
  8.     1: 'class_name2',   # 类别 1 对应的名称
  9.     2: 'class_name3'    # 类别 2 对应的名称
  10. }
  11.  
  12. # YOLO11的txt标签，转为Labelme的json文件
  13. def yolo_to_labelme(txt_path, img_width, img_height):
  14.     with open(txt_path, 'r') as file:
  15.         lines = file.readlines()
  16.  
  17.     shapes = []
  18.     for line in lines:
  19.         parts = line.strip().split()
  20.         class_id = int(parts[0])
  21.         x_center = float(parts[1])
  22.         y_center = float(parts[2])
  23.         width = float(parts[3])
  24.         height = float(parts[4])
  25.  
  26.         # 转换为绝对坐标
  27.         x_center *= img_width
  28.         y_center *= img_height
  29.         width *= img_width
  30.         height *= img_height
  31.  
  32.         # 计算矩形的四个顶点
  33.         x1 = x_center - width / 2
  34.         y1 = y_center - height / 2
  35.         x2 = x_center + width / 2
  36.         y2 = y_center + height / 2
  37.  
  38.         shapes.append({
  39.             'label': class_map[class_id],
  40.             'points': [[x1, y1], [x2, y2]],
  41.             'group_id': None,
  42.             'shape_type': 'rectangle',
  43.             'flags': {}
  44.         })
  45.  
  46.     return shapes
  47.  
  48. def main():
  49.     # 文件夹路径
  50.     image_folder_path = r"./datasets/seg-datasetsv2/images"     # 这里指定图片的文件夹路径
  51.     txt_folder_path = r"./datasets/seg-datasetsv2/labels"       # 这里指定YOLO的txt_labels的文件夹路径
  52.     json_output_path = r"./datasets/seg-datasetsv2/json_labels" # 这里指定待会生成Labelme的json_labels的文件夹路径
  53.  
  54.     # 检查输出文件夹是否存在，不存在则创建
  55.     if not os.path.exists(json_output_path):
  56.         os.makedirs(json_output_path)
  57.  
  58.     # 遍历所有txt文件并转换
  59.     for txt_file in os.listdir(txt_folder_path):
  60.         if txt_file.endswith('.txt'):
  61.             txt_path = os.path.join(txt_folder_path, txt_file)
  62.  
  63.             # 获取与txt文件同名的图片路径
  64.             img_file = txt_file.replace('.txt', '.jpg')  # 假设图片是jpg格式
  65.             img_path = os.path.join(image_folder_path, img_file)
  66.  
  67.             try:
  68.                 # 使用OpenCV读取图片分辨率
  69.                 img = cv2.imread(img_path)
  70.                 if img is None:
  71.                     raise FileNotFoundError(f"Image file not found: {img_path}")
  72.  
  73.                 img_height, img_width, _ = img.shape
  74.  
  75.                 shapes = yolo_to_labelme(txt_path, img_width, img_height)
  76.  
  77.                 # 创建LabelMe格式的json文件
  78.                 labelme_data = {
  79.                     'version': '4.5.6',
  80.                     'flags': {},
  81.                     'shapes': shapes,
  82.                     'imagePath': img_file,
  83.                     'imageData': None,
  84.                     'imageHeight': img_height,
  85.                     'imageWidth': img_width
  86.                 }
  87.  
  88.                 json_path = os.path.join(json_output_path, txt_file.replace('.txt', '.json'))
  89.                 with open(json_path, 'w') as json_file:
  90.                     json.dump(labelme_data, json_file, indent=2)
  91.  
  92.             except Exception as e:
  93.                 print(f"Error processing {img_file}: {e}")
  94.  
  95. # 主函数入口
  96. if __name__ == "__main__":
  97.     main()

 首先修改类别映射，比如：

  1. # 定义类别标签映射
  2. class_map = {
  3.     0: 'person',    # 类别 0 对应的名称是person
  4.     1: 'bicycle',   # 类别 1 对应的名称是bicycle
  5.     2: 'car'        # 类别 2 对应的名称是car
  6. }

然后修改一下代码中的参数：

  1.     image_folder_path = r"./datasets/seg-datasetsv2/images"     # 这里指定图片的文件夹路径
  2.     txt_folder_path = r"./datasets/seg-datasetsv2/labels"       # 这里指定YOLO的txt_labels的文件夹路径
  3.     json_output_path = r"./datasets/seg-datasetsv2/json_labels" # 这里指定待会生成Labelme的json_labels的文件夹路径

运行代码，会生成用于YOLO11目标检测的JSON标签文件。

6、手动校正标签

生成了JSON文件后，把图像和JSON文件放在同一个文件夹中

然后打开Labelme工具，选择“编辑多边形”，对物体进行标注信息修改

修改完成后，点击“Save"保存修正后的标注信息

7、Labelme的json转为YOLO的txt

这里把Labelme的json转为YOLO的txt，是因为用修正后数据，作为新的数据，加入旧数据中；

重新训练之前的模型权重，这样模型会学得更好，迭代优化模型。

通过下面代码，把Labelme的json转为YOLO的txt

 方案1——单个文件转换

该代码用于将LabelMe格式的JSON标注文件，转换为YOLO11格式的标注文件，函数解析：

convert_labelme_to_yolo(json_path, output_dir):

  • 功能: 将单个LabelMe格式的JSON文件转换为YOLO11格式。
  • 参数:
    • json_path (str): 输入的LabelMe格式JSON文件路径。
    • output_dir (str): 输出的YOLO11格式标注文件夹路径。
  • 操作:
    • 读取JSON文件，获取图像宽度和高度。
    • 遍历所有标注形状，提取标签和坐标，计算YOLO11所需的中心点和宽高。
    • 将结果写入以相同文件名命名的TXT文件中。

示例代码如下所示：

  1. import json
  2. import os
  3.  
  4. # 定义标签映射，将类别名称映射为ID
  5. label_map = {
  6.     "car": 0,  # 汽车
  7.     "bus": 1   # 公交车
  8. }
  9.  
  10. def convert_labelme_to_yolo(json_path, output_dir):
  11.     """
  12.     将LabelMe格式的JSON文件转换为YOLO11格式的标注文件。
  14.     参数：
  15.     json_path (str): 输入的LabelMe格式JSON文件路径。
  16.     output_dir (str): 输出的YOLO11格式标注文件夹路径。
  17.     """
  18.     # 打开LabelMe格式的JSON文件
  19.     with open(json_path, 'r') as f:
  20.         labelme_data = json.load(f)  # 读取JSON数据
  21.  
  22.     # 获取图像的宽度和高度
  23.     image_width = labelme_data['imageWidth']
  24.     image_height = labelme_data['imageHeight']
  25.  
  26.     yolo_annotations = []  # 存储YOLO11格式的标注
  27.  
  28.     # 遍历所有的标注形状
  29.     for shape in labelme_data['shapes']:
  30.         label = shape['label']  # 获取标签名称
  31.         if label not in label_map:
  32.             continue  # 如果标签未定义，则忽略
  33.  
  34.         class_id = label_map[label]  # 获取对应的类别ID
  35.  
  36.         points = shape['points']  # 获取标注的坐标点
  37.         if shape['shape_type'] == 'rectangle':  # 如果是矩形
  38.             (x1, y1), (x2, y2) = points  # 获取矩形的两个顶点
  39.         elif shape['shape_type'] == 'polygon':  # 如果是多边形
  40.             x1, y1 = min(point[0] for point in points), min(point[1] for point in points)  # 计算多边形的左上角
  41.             x2, y2 = max(point[0] for point in points), max(point[1] for point in points)  # 计算多边形的右下角
  42.         else:
  43.             continue  # 其他类型不处理
  44.  
  45.         # 计算YOLO11格式所需的中心点和宽高
  46.         x_center = (x1 + x2) / 2.0 / image_width  # 计算中心点x坐标
  47.         y_center = (y1 + y2) / 2.0 / image_height  # 计算中心点y坐标
  48.         width = (x2 - x1) / image_width  # 计算宽度
  49.         height = (y2 - y1) / image_height  # 计算高度
  50.  
  51.         # 添加YOLO11格式的标注到列表中
  52.         yolo_annotations.append(f"{class_id} {x_center} {y_center} {width} {height}")
  53.  
  54.     # 构建输出文件的路径
  55.     output_file = os.path.join(output_dir, os.path.splitext(os.path.basename(json_path))[0] + '.txt')
  56.     # 将YOLO11格式的标注写入输出文件
  57.     with open(output_file, 'w') as f:
  58.         f.write('\n'.join(yolo_annotations))
  59.  
  60. # 示例使用
  61. convert_labelme_to_yolo('/path/to/labelme_file.json', '/path/to/output_dir')

方案2——多个标签文件转换

读取一个文件夹下所有json文件，然后转为YOLO11的txt标签格

process_folder(input_folder, output_folder):

  • 功能: 处理输入文件夹中的所有JSON文件，转换为YOLO11格式。
  • 参数:
    • input_folder (str): 包含LabelMe格式JSON文件的输入文件夹路径。
    • output_folder (str): 用于保存YOLO11格式标注文件的输出文件夹路径。
  • 操作:
    • 创建输出文件夹（如果不存在）。
    • 遍历输入文件夹，调用转换函数处理每个以.json结尾的文件。

 示例代码如下所示：

  1. import json
  2. import os
  3.  
  4. # 定义标签映射，将类别名称映射为ID
  5. label_map = {
  6.     "car": 0,  # 汽车
  7.     "bus": 1   # 公交车
  8. }
  9.  
  10. def convert_labelme_to_yolo(json_path, output_dir):
  11.     """
  12.     将LabelMe格式的JSON文件转换为YOLO11格式的标注文件。
  14.     参数：
  15.     json_path (str): 输入的LabelMe格式JSON文件路径。
  16.     output_dir (str): 输出的YOLO11格式标注文件夹路径。
  17.     """
  18.     # 打开LabelMe格式的JSON文件
  19.     with open(json_path, 'r') as f:
  20.         labelme_data = json.load(f)  # 读取JSON数据
  21.  
  22.     # 获取图像的宽度和高度
  23.     image_width = labelme_data['imageWidth']
  24.     image_height = labelme_data['imageHeight']
  25.  
  26.     yolo_annotations = []  # 存储YOLO11格式的标注
  27.  
  28.     # 遍历所有的标注形状
  29.     for shape in labelme_data['shapes']:
  30.         label = shape['label']  # 获取标签名称
  31.         if label not in label_map:
  32.             continue  # 如果标签未定义，则忽略
  33.  
  34.         class_id = label_map[label]  # 获取对应的类别ID
  35.  
  36.         points = shape['points']  # 获取标注的坐标点
  37.         if shape['shape_type'] == 'rectangle':  # 如果是矩形
  38.             (x1, y1), (x2, y2) = points  # 获取矩形的两个顶点
  39.         elif shape['shape_type'] == 'polygon':  # 如果是多边形
  40.             x1, y1 = min(point[0] for point in points), min(point[1] for point in points)  # 计算多边形的左上角
  41.             x2, y2 = max(point[0] for point in points), max(point[1] for point in points)  # 计算多边形的右下角
  42.         else:
  43.             continue  # 其他类型不处理
  44.  
  45.         # 计算YOLO11格式所需的中心点和宽高
  46.         x_center = (x1 + x2) / 2.0 / image_width  # 计算中心点x坐标
  47.         y_center = (y1 + y2) / 2.0 / image_height  # 计算中心点y坐标
  48.         width = (x2 - x1) / image_width  # 计算宽度
  49.         height = (y2 - y1) / image_height  # 计算高度
  50.  
  51.         # 添加YOLO11格式的标注到列表中
  52.         yolo_annotations.append(f"{class_id} {x_center} {y_center} {width} {height}")
  53.  
  54.     # 构建输出文件的路径
  55.     output_file = os.path.join(output_dir, os.path.splitext(os.path.basename(json_path))[0] + '.txt')
  56.     # 将YOLO11格式的标注写入输出文件
  57.     with open(output_file, 'w') as f:
  58.         f.write('\n'.join(yolo_annotations))
  59.  
  60. def process_folder(input_folder, output_folder):
  61.     """
  62.     处理输入文件夹中的所有JSON文件，并将其转换为YOLO11格式的标注文件。
  64.     参数：
  65.     input_folder (str): 输入文件夹路径，包含LabelMe格式的JSON文件。
  66.     output_folder (str): 输出文件夹路径，用于保存YOLO11格式的标注文件。
  67.     """
  68.     # 创建输出文件夹（如果不存在）
  69.     os.makedirs(output_folder, exist_ok=True)
  70.     
  71.     # 处理输入文件夹中的每个 JSON 文件
  72.     for filename in os.listdir(input_folder):
  73.         if filename.endswith(".json"):  # 只处理以 .json 结尾的文件
  74.             json_path = os.path.join(input_folder, filename)  # 获取完整的JSON文件路径
  75.             convert_labelme_to_yolo(json_path, output_folder)  # 调用转换函数
  76.  
  77. # 示例使用
  78. input_folder = "/mnt/data/json_labels"  # 输入json_labels文件夹路径
  79. output_folder = "/mnt/data/yolo11_txt_labels"  # 输出txt_labels文件夹路径
  80.  
  81. process_folder(input_folder, output_folder)  # 处理文件夹中的所有JSON文件
  82.  
  83. # 列出输出文件夹中的文件以确认
  84. os.listdir(output_folder)  # 打印输出文件夹中的文件列表

我们使用上面代码时，需要设置输入的json_labels文件夹路径、输出txt_labels文件夹路径：

  1. input_folder = "/mnt/data/json_labels"  # 输入json_labels文件夹路径
  2. output_folder = "/mnt/data/yolo11_txt_labels"  # 输出txt_labels文件夹路径

8、迭代优化模型（可选）

然后，可以迭代优化模型。用修正后数据，作为新的数据，加入旧数据中；

重新训练之前的模型权重，这样模型会学得更好，迭代优化模型。

YOLO11目标检测-训练模型参考我这篇文章：

http://iyenn.com/rec/1657167.html?spm=1001.2014.3001.5501

  YOLO11相关文章推荐：

一篇文章快速认识YOLO11 | 关键改进点 | 安装使用 | 模型训练和推理-CSDN博客

一篇文章快速认识 YOLO11 | 实例分割 | 模型训练 | 自定义数据集-CSDN博客

YOLO11模型推理 | 目标检测与跟踪 | 实例分割 | 关键点估计 | OBB旋转目标检测-CSDN博客

YOLO11模型训练 | 目标检测与跟踪 | 实例分割 | 关键点姿态估计-CSDN博客

YOLO11 实例分割 | 自动标注 | 预标注 | 标签格式转换 | 手动校正标签-CSDN博客

YOLO11 实例分割 | 导出ONNX模型 | ONNX模型推理-CSDN博客

YOLO11 目标检测 | 导出ONNX模型 | ONNX模型推理-CSDN博客

分享完成，欢迎大家多多点赞和收藏，谢谢~

注：本文转载自blog.csdn.net的一颗小树x的文章"https://blog.csdn.net/qq_41204464/article/details/143078464"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！