• YOLOV7训练TT100K交通标识符数据集

                                                             《临江仙》

                                                            作者：缠中说禅

                    浊水倾波三万里，愀然独坐孤峰。龙潜狮睡候飙风。无情皆竖子，有泪亦英雄。
                    长剑倚天星斗烂，古今过眼成空。乾坤俯仰任穷通。半轮沧海上，一苇大江东。

    一、yolov7环境搭建

    参见我的其他博客文章，还有个下载文档，免费的

    二、TT100K数据集处理

    2.1 数据集下载19多个G

    https://bj.bcebos.com/ai-studio-online/11d4aa5b64674c399ae4a092dd2c99a1be48927a53ba41f09659040497f7ad23?authorization=bce-auth-v1%2F5cfe9a5e1454405eb2a975c43eace6ec%2F2022-09-04T15%3A26%3A20Z%2F-1%2F%2Fb6ad292a7a8dea9aaaa342f6c29ddf7f238f17f4b0de359440ad2ecffd88196d&responseContentDisposition=attachment%3B%20filename%3Dtt100k_2021.zip

    解压后的目录：

    2.2 代码用法说明

    我是在如下文章指导下进行的数据处理，把他的代码做了一些改动，参考时候请注意。

    参考链接：

    win下YOLOv7训练自己的数据集（交通标志TT100K识别）_tt100k数据集_我宿孤栈的博客-CSDN博客

    tt100k.class_statistics()#对TT100K中的数据集进行预处理，代码中是只保留包含图片数超过100的类别；

    tt100k.original_datasets2object_datasets_re()#对TT100K数据集的训练集、验证集和测试集进行比例划分；7：2：1=train:val:test.然后我加了一些代码，顺便把分类好的数据图片进行了转移，也就是把保留包含图片数超过100的类别的图片换了个地方保存。

    tt100k.coco_json2yolo_txt('val')#将CoCo格式的标签json文件（3个json文件）转换为YOLO格式的txt（注意此处需要分别调用三次，train、val和test，对应生成其3个.txt文件）；

    2.3 代码

    2.3.1 如下是整体代码

    1. import os
    2. import json
    3. from random import random
    4. import cv2
    5. import shutil
    6. import json
    7. import xml.dom.minidom
    8. from tqdm import tqdm
    9. import argparse
    10.  
    11.  
    12. # from jinxSkills.jinx_opencv.datasets_transform.dataset_transform import DataSets_transform
    13.  
    14.  
    15. class TT100K2COCO:
    16.     def __init__(self):
    17.         self.original_datasets = 'tt100k'
    18.         self.to_datasets = 'coco'
    19.  
    20.     def class_statistics(self):
    21.         # os.makedirs('annotations', exist_ok=True)
    22.         # 存放数据的父路径
    23.         parent_path = 'E:/WorkSpace/YOLO/data/data'
    24.         #print(parent_path)
    25.         # 读TT100K原始数据集标注文件
    26.         with open(os.path.join(parent_path, 'annotations.json')) as origin_json:
    27.             origin_dict = json.load(origin_json)
    28.             classes = origin_dict['types']
    29.         # 建立统计每个类别包含的图片的字典
    30.         sta = {}
    31.         for i in classes:
    32.             sta[i] = []
    33.  
    34.         images_dic = origin_dict['imgs']
    35.  
    36.         # 记录所有保留的图片
    37.         saved_images = []
    38.         # 遍历TT100K的imgs
    39.         for image_id in images_dic:
    40.             image_element = images_dic[image_id]##
    41.             image_path = 'E:/WorkSpace/YOLO/data/data/'+image_element['path']
    42.             #print(image_path)
    43.             # 添加图像的信息到dataset中
    44.             image_path = image_path.split('/')[-1]
    45.             obj_list = image_element['objects']
    46.             #print(image_path)
    47.             # 遍历每张图片的标注信息
    48.             for anno_dic in obj_list:
    49.                 label_key = anno_dic['category']
    50.                 # 防止一个图片多次加入一个标签类别
    51.                 if image_path not in sta[label_key]:
    52.                     sta[label_key].append(image_path)
    53.  
    54.         # 只保留包含图片数超过100的类别（重新划分，阈值100可根据需求修改）
    55.         result = {k: v for k, v in sta.items() if len(v) >= 100}
    56.  
    57.         for i in result:
    58.             #print("the type of {} includes {} images".format(i, len(result[i])))
    59.             saved_images.extend(result[i])
    60.  
    61.         saved_images = list(set(saved_images))
    62.         #print("total types is {}".format(len(result)))
    63.  
    64.         type_list = list(result.keys())
    65.         result = {"type": type_list, "details": result, "images": saved_images}
    66.         print(type_list)
    67.         # 保存结果
    68.         json_name = os.path.join(parent_path, 'statistics.json')
    69.         with open(json_name, 'w', encoding="utf-8") as f:
    70.             json.dump(result, f, ensure_ascii=False, indent=1)
    71.  
    72.  
    73.     def original_datasets2object_datasets_re(self):
    74.         '''
    75.         重新划分数据集
    76.         :return:
    77.         '''
    78.         # os.makedirs('annotations2', exist_ok=True)
    79.         # 存放数据的父路径
    80.         parent_path = 'E:/WorkSpace/YOLO/data/data/'
    81.         # 读TT100K原始数据集标注文件
    82.         with open(os.path.join(parent_path, 'annotations.json')) as origin_json:
    83.             origin_dict = json.load(origin_json)
    84.         with open(os.path.join(parent_path, 'statistics.json')) as select_json:
    85.             select_dict = json.load(select_json)
    86.             classes = select_dict['type']
    87.  
    88.         train_dataset = {'info': {}, 'licenses': [], 'categories': [], 'images': [], 'annotations': []}
    89.         val_dataset = {'info': {}, 'licenses': [], 'categories': [], 'images': [], 'annotations': []}
    90.         test_dataset = {'info': {}, 'licenses': [], 'categories': [], 'images': [], 'annotations': []}
    91.         label = {}  # 记录每个标志类别的id
    92.         count = {}  # 记录每个类别的图片数
    93.         owntype_sum = {}
    94.         info = {
    95.             "year": 2021,  # 年份
    96.             "version": '1.0',  # 版本
    97.             "description": "TT100k_to_coco",  # 数据集描述
    98.             "contributor": "Tecent&Tsinghua",  # 提供者
    99.             "url": 'https://cg.cs.tsinghua.edu.cn/traffic-sign/',  # 下载地址
    100.             "date_created": 2021 - 1 - 15
    101.         }
    102.         licenses = {
    103.             "id": 1,
    104.             "name": "null",
    105.             "url": "null",
    106.         }
    107.  
    108.         train_dataset['info'] = info
    109.         val_dataset['info'] = info
    110.         test_dataset['info'] = info
    111.         train_dataset['licenses'] = licenses
    112.         val_dataset['licenses'] = licenses
    113.         test_dataset['licenses'] = licenses
    114.  
    115.         # 建立类别和id的关系
    116.         for i, cls in enumerate(classes):
    117.             train_dataset['categories'].append({'id': i, 'name': cls, 'supercategory': 'traffic_sign'})
    118.             val_dataset['categories'].append({'id': i, 'name': cls, 'supercategory': 'traffic_sign'})
    119.             test_dataset['categories'].append({'id': i, 'name': cls, 'supercategory': 'traffic_sign'})
    120.             label[cls] = i
    121.             count[cls] = 0
    122.             owntype_sum[cls] = 0
    123.  
    124.         images_dic = origin_dict['imgs']#源annotations.json
    125.  
    126.         obj_id = 1
    127.  
    128.         # 计算出每个类别共‘包含’的图片数
    129.         for image_id in images_dic:
    130.             image_element = images_dic[image_id]
    131.             image_path = image_element['path']
    132.             image_name = image_path.split('/')[-1]
    133.             #print(image_name)#32770.jpg
    134.             # 在所选的类别图片中
    135.             if image_name not in select_dict['images']:
    136.                 continue
    137.             else:
    138.                 #加一个赋值图片的语句
    139.                 i=0
    140.             # 处理TT100K中的标注信息
    141.             obj_list = image_element['objects']
    142.             # 记录图片中包含最多的实例所属的type
    143.             includes_type = {}
    144.             for anno_dic in obj_list:
    145.                 if anno_dic["category"] not in select_dict["type"]:
    146.                     continue
    147.                 # print(anno_dic["category"])
    148.                 if anno_dic["category"] in includes_type:
    149.                     includes_type[anno_dic["category"]] += 1
    150.                 else:
    151.                     includes_type[anno_dic["category"]] = 1
    152.             # print(includes_type)
    153.             own_type = max(includes_type, key=includes_type.get)
    154.             owntype_sum[own_type] += 1
    155.  
    156.         # TT100K的annotation转换成coco的
    157.         for image_id in images_dic:
    158.             image_element = images_dic[image_id]
    159.             image_path = image_element['path']
    160.             image_name = image_path.split('/')[-1]
    161.             # 在所选的类别图片中
    162.             if image_name not in select_dict['images']:
    163.                 continue
    164.             ##print("dealing with {} image".format(image_path))
    165.             # shutil.copy(os.path.join(parent_path,image_path),os.path.join(parent_path,"dataset/JPEGImages"))
    166.  
    167.             # 处理TT100K中的标注信息
    168.             obj_list = image_element['objects']
    169.             # 记录图片中包含最多的实例所属的type
    170.             includes_type = {}
    171.             for anno_dic in obj_list:
    172.                 if anno_dic["category"] not in select_dict["type"]:
    173.                     continue
    174.                 # print(anno_dic["category"])
    175.                 if anno_dic["category"] in includes_type:
    176.                     includes_type[anno_dic["category"]] += 1
    177.                 else:
    178.                     includes_type[anno_dic["category"]] = 1
    179.             # print(includes_type)
    180.             own_type = max(includes_type, key=includes_type.get)
    181.             count[own_type] += 1
    182.             num_rate = count[own_type] / owntype_sum[own_type]
    183.  
    184.             # 切换dataset的引用对象，从而划分数据集根据每个类别类别的总数量按7：2：1分为了train_set,val_set,test_set。
    185.             # 其中每个图片所属类别根据该图片包含的类别的数量决定（归属为含有类别最多的类别）
    186.            target = 'E:/WorkSpace/YOLO/data/'
    187.  
    188.             if num_rate < 0.7:
    189.                 dataset = train_dataset
    190.                 #print(image_path)
    191.                 shutil.copyfile(parent_path + image_path, target + '/train/' + image_path.split("/")[1])
    192.             elif num_rate < 0.9:
    193.                 dataset = val_dataset
    194.                 shutil.copyfile(parent_path + image_path, target + '/val/' + image_path.split("/")[1])
    195.                 #print(image_path)
    196.             else:
    197.                 #print("dataset=test_dataset")
    198.                 dataset = test_dataset
    199.                 #print(image_path)
    200.                 shutil.copyfile(parent_path + image_path, target + '/test/' + image_path.split("/")[1])
    201.  
    202.             for anno_dic in obj_list:
    203.                 if anno_dic["category"] not in select_dict["type"]:
    204.                     continue
    205.                 x = anno_dic['bbox']['xmin']
    206.                 y = anno_dic['bbox']['ymin']
    207.                 width = anno_dic['bbox']['xmax'] - anno_dic['bbox']['xmin']
    208.                 height = anno_dic['bbox']['ymax'] - anno_dic['bbox']['ymin']
    209.                 label_key = anno_dic['category']
    210.  
    211.                 dataset['annotations'].append({
    212.                     'area': width * height,
    213.                     'bbox': [x, y, width, height],
    214.                     'category_id': label[label_key],
    215.                     'id': obj_id,
    216.                     'image_id': image_id,
    217.                     'iscrowd': 0,
    218.                     # mask, 矩形是从左上角点按顺时针的四个顶点
    219.                     'segmentation': [[x, y, x + width, y, x + width, y + height, x, y + height]]
    220.                 })
    221.                 # 每个标注的对象id唯一
    222.                 obj_id += 1
    223.  
    224.             # 用opencv读取图片，得到图像的宽和高
    225.             im = cv2.imread(os.path.join(parent_path, image_path))
    226.             #####---------------------------------------------
    227.             ##print(image_path)  #test  other train
    228.             prefix = image_path.split("/")[0]
    229.  
    230.  
    231.             H,W,_ = im.shape
    232.             # 添加图像的信息到dataset中
    233.             dataset['images'].append({'file_name': image_name,
    234.                                       'id': image_id,
    235.                                       'width': W,
    236.                                       'height': H})
    237.  
    238.         # 保存结果
    239.         for phase in ['train', 'val', 'test']:
    240.             json_name = os.path.join(parent_path, 'dataset/annotations/{}.json'.format(phase))
    241.             with open(json_name, 'w', encoding="utf-8") as f:
    242.                 if phase == 'train':
    243.                     shutil.copyfile(parent_path + image_path, target + '/train/' + image_path.split("/")[1])
    244.                     json.dump(train_dataset, f, ensure_ascii=False, indent=1)
    245.                 if phase == 'val':
    246.                     json.dump(val_dataset, f, ensure_ascii=False, indent=1)
    247.                 if phase == 'test':
    248.                     json.dump(test_dataset, f, ensure_ascii=False, indent=1)
    249.  
    250.     def coco_json2yolo_txt(self, class_json):
    251.         # COCO 格式的数据集转化为 YOLO 格式的数据集
    252.         # --json_path 输入的json文件路径
    253.         # --save_path 保存的文件夹名字，默认为当前目录下的labels。
    254.  
    255.         def convert(size, box):
    256.             dw = 1. / (size[0])
    257.             dh = 1. / (size[1])
    258.             x = box[0] + box[2] / 2.0
    259.             y = box[1] + box[3] / 2.0
    260.             w = box[2]
    261.             h = box[3]
    262.             # round函数确定(xmin, ymin, xmax, ymax)的小数位数
    263.             x = round(x * dw, 6)
    264.             w = round(w * dw, 6)
    265.             y = round(y * dh, 6)
    266.             h = round(h * dh, 6)
    267.             return (x, y, w, h)
    268.  
    269.         # class_json = 'train'
    270.         json_file = os.path.join(
    271.             'E:/WorkSpace/YOLO/data/data/dataset/annotations/%s.json' % class_json)  # COCO Object Instance 类型的标注
    272.         #E:/WorkSpace/YOLO/data/data/dataset/annotations/val.json
    273.         #print(json_file)
    274.         # ana_txt_save_path = 'D:/jinxData/TT100K/data/dataset/annotations/train'  # 保存的路径
    275.         ana_txt_save_path = os.path.join('E:/WorkSpace/YOLO/data/data/dataset/annotations/', class_json)  # 保存的路径
    276.         #print(class_json)#val
    277.         #print(ana_txt_save_path)#E:/WorkSpace/YOLO/data/data/dataset/annotations\val
    278.         data = json.load(open(json_file, 'r'))
    279.         if not os.path.exists(ana_txt_save_path):
    280.             os.makedirs(ana_txt_save_path)
    281.  
    282.         id_map = {}  # coco数据集的id不连续！重新映射一下再输出！
    283.         with open(os.path.join(ana_txt_save_path, 'classes.txt'), 'w') as f:
    284.             # 写入classes.txt
    285.             for i, category in enumerate(data['categories']):
    286.                 f.write(f"{category['name']}\n")
    287.                 id_map[category['id']] = i
    288.         # print(id_map)
    289.         # 这里需要根据自己的需要，更改写入图像相对路径的文件位置。
    290.         list_file = open(os.path.join(ana_txt_save_path, '%s.txt' % class_json.format()), 'w')
    291.  
    292.         for img in tqdm(data['images']):
    293.             filename = img["file_name"]
    294.             img_width = img["width"]
    295.             img_height = img["height"]
    296.             img_id = img["id"]
    297.             head, tail = os.path.splitext(filename)
    298.             ana_txt_name = head + ".txt"  # 对应的txt名字，与jpg一致
    299.             f_txt = open(os.path.join(ana_txt_save_path, ana_txt_name), 'w')
    300.             for ann in data['annotations']:
    301.                 if ann['image_id'] == img_id:
    302.                     box = convert((img_width, img_height), ann["bbox"])
    303.                     f_txt.write("%s %s %s %s %s\n" % (id_map[ann["category_id"]], box[0], box[1], box[2], box[3]))
    304.             f_txt.close()
    305.             #将图片的相对路径写入train2017或val2017的路径  'E:/WorkSpace/YOLO/yolov7-main/yolov7-main/dataset/TT100K/images/'
    306.             #list_file.write('%s/%s/%s.jpg\n' % ('E:/WorkSpace/YOLO/data/data/',class_json.format(), head))
    307.             list_file.write('%s/%s/%s.jpg\n' % ('E:/WorkSpace/YOLO/yolov7-main/yolov7-main/data/TT100K/images/', class_json.format(), head))
    308.         list_file.close()
    309.  
    310.    
    311.  
    312. if __name__ == '__main__':
    313.     tt100k = TT100K2COCO()
    314.     #tt100k.class_statistics()
    315.     #tt100k.original_datasets2object_datasets_re()
    316.     tt100k.coco_json2yolo_txt('val')
    317.     tt100k.coco_json2yolo_txt('test')
    318.     tt100k.coco_json2yolo_txt('train')
    319.

    2.3.2 如下是每个函数的代码以及我的注释

    class_statistics(self)函数：把data1看成data把，因为我已经有了个data文件夹，为了写教程又重新解压了一份。

    parent_path = 'E:/WorkSpace/YOLO/data/data'

    这一块可以不用加上'E:/WorkSpace/YOLO/data/data/'+  
直接为image_path  = image_element['path']就可以了
image_path = 'E:/WorkSpace/YOLO/data/data/'+image_element['path']

    改完上述两个部分后，运行该函数，会生成一个statistics.json文件。

    1.     def class_statistics(self):
    2.         # os.makedirs('annotations', exist_ok=True)
    3.         # 存放数据的父路径
    4.         parent_path = 'E:/WorkSpace/YOLO/data/data'
    5.         #print(parent_path)
    6.         # 读TT100K原始数据集标注文件
    7.         with open(os.path.join(parent_path, 'annotations.json')) as origin_json:
    8.             origin_dict = json.load(origin_json)
    9.             classes = origin_dict['types']
    10.         # 建立统计每个类别包含的图片的字典
    11.         sta = {}
    12.         for i in classes:
    13.             sta[i] = []
    14.  
    15.         images_dic = origin_dict['imgs']
    16.  
    17.         # 记录所有保留的图片
    18.         saved_images = []
    19.         # 遍历TT100K的imgs
    20.         for image_id in images_dic:
    21.             image_element = images_dic[image_id]##
    22.             image_path = 'E:/WorkSpace/YOLO/data/data/'+image_element['path']
    23.             #print(image_path)
    24.             # 添加图像的信息到dataset中
    25.             image_path = image_path.split('/')[-1]
    26.             obj_list = image_element['objects']
    27.             #print(image_path)
    28.             # 遍历每张图片的标注信息
    29.             for anno_dic in obj_list:
    30.                 label_key = anno_dic['category']
    31.                 # 防止一个图片多次加入一个标签类别
    32.                 if image_path not in sta[label_key]:
    33.                     sta[label_key].append(image_path)
    34.  
    35.         # 只保留包含图片数超过100的类别（重新划分，阈值100可根据需求修改）
    36.         result = {k: v for k, v in sta.items() if len(v) >= 100}
    37.  
    38.         for i in result:
    39.             #print("the type of {} includes {} images".format(i, len(result[i])))
    40.             saved_images.extend(result[i])
    41.  
    42.         saved_images = list(set(saved_images))
    43.         #print("total types is {}".format(len(result)))
    44.  
    45.         type_list = list(result.keys())
    46.         result = {"type": type_list, "details": result, "images": saved_images}
    47.         print(type_list)
    48.         # 保存结果
    49.         json_name = os.path.join(parent_path, 'statistics.json')
    50.         with open(json_name, 'w', encoding="utf-8") as f:
    51.             json.dump(result, f, ensure_ascii=False, indent=1)
    original_datasets2object_datasets_re函数

    改动比较多注意。

    1.parent_path = 'E:/WorkSpace/YOLO/data/data/'  不用说了吧

    2.加一句target = 'E:/WorkSpace/YOLO/data/'，就是一个你最后要用的test  train  val图片的目录，可以自己指定。

    3.3个复制函数，我最后生成的三个文件夹

    4.运行函数，会很慢，最后会生成3的三个文件夹，已经3个json文件，还有label文件

     

    1.     def original_datasets2object_datasets_re(self):
    2.         '''
    3.         重新划分数据集
    4.         :return:
    5.         '''
    6.         # os.makedirs('annotations2', exist_ok=True)
    7.         # 存放数据的父路径
    8.         parent_path = 'E:/WorkSpace/YOLO/data/data/'
    9.         # 读TT100K原始数据集标注文件
    10.         with open(os.path.join(parent_path, 'annotations.json')) as origin_json:
    11.             origin_dict = json.load(origin_json)
    12.         with open(os.path.join(parent_path, 'statistics.json')) as select_json:
    13.             select_dict = json.load(select_json)
    14.             classes = select_dict['type']
    15.  
    16.         train_dataset = {'info': {}, 'licenses': [], 'categories': [], 'images': [], 'annotations': []}
    17.         val_dataset = {'info': {}, 'licenses': [], 'categories': [], 'images': [], 'annotations': []}
    18.         test_dataset = {'info': {}, 'licenses': [], 'categories': [], 'images': [], 'annotations': []}
    19.         label = {}  # 记录每个标志类别的id
    20.         count = {}  # 记录每个类别的图片数
    21.         owntype_sum = {}
    22.         info = {
    23.             "year": 2021,  # 年份
    24.             "version": '1.0',  # 版本
    25.             "description": "TT100k_to_coco",  # 数据集描述
    26.             "contributor": "Tecent&Tsinghua",  # 提供者
    27.             "url": 'https://cg.cs.tsinghua.edu.cn/traffic-sign/',  # 下载地址
    28.             "date_created": 2021 - 1 - 15
    29.         }
    30.         licenses = {
    31.             "id": 1,
    32.             "name": "null",
    33.             "url": "null",
    34.         }
    35.  
    36.         train_dataset['info'] = info
    37.         val_dataset['info'] = info
    38.         test_dataset['info'] = info
    39.         train_dataset['licenses'] = licenses
    40.         val_dataset['licenses'] = licenses
    41.         test_dataset['licenses'] = licenses
    42.  
    43.         # 建立类别和id的关系
    44.         for i, cls in enumerate(classes):
    45.             train_dataset['categories'].append({'id': i, 'name': cls, 'supercategory': 'traffic_sign'})
    46.             val_dataset['categories'].append({'id': i, 'name': cls, 'supercategory': 'traffic_sign'})
    47.             test_dataset['categories'].append({'id': i, 'name': cls, 'supercategory': 'traffic_sign'})
    48.             label[cls] = i
    49.             count[cls] = 0
    50.             owntype_sum[cls] = 0
    51.  
    52.         images_dic = origin_dict['imgs']#源annotations.json
    53.  
    54.         obj_id = 1
    55.  
    56.         # 计算出每个类别共‘包含’的图片数
    57.         for image_id in images_dic:
    58.             image_element = images_dic[image_id]
    59.             image_path = image_element['path']
    60.             image_name = image_path.split('/')[-1]
    61.             #print(image_name)#32770.jpg
    62.             # 在所选的类别图片中
    63.             if image_name not in select_dict['images']:
    64.                 continue
    65.             else:
    66.                 #加一个赋值图片的语句
    67.                 i=0
    68.             # 处理TT100K中的标注信息
    69.             obj_list = image_element['objects']
    70.             # 记录图片中包含最多的实例所属的type
    71.             includes_type = {}
    72.             for anno_dic in obj_list:
    73.                 if anno_dic["category"] not in select_dict["type"]:
    74.                     continue
    75.                 # print(anno_dic["category"])
    76.                 if anno_dic["category"] in includes_type:
    77.                     includes_type[anno_dic["category"]] += 1
    78.                 else:
    79.                     includes_type[anno_dic["category"]] = 1
    80.             # print(includes_type)
    81.             own_type = max(includes_type, key=includes_type.get)
    82.             owntype_sum[own_type] += 1
    83.  
    84.         # TT100K的annotation转换成coco的
    85.         for image_id in images_dic:
    86.             image_element = images_dic[image_id]
    87.             image_path = image_element['path']
    88.             image_name = image_path.split('/')[-1]
    89.             # 在所选的类别图片中
    90.             if image_name not in select_dict['images']:
    91.                 continue
    92.             ##print("dealing with {} image".format(image_path))
    93.             # shutil.copy(os.path.join(parent_path,image_path),os.path.join(parent_path,"dataset/JPEGImages"))
    94.  
    95.             # 处理TT100K中的标注信息
    96.             obj_list = image_element['objects']
    97.             # 记录图片中包含最多的实例所属的type
    98.             includes_type = {}
    99.             for anno_dic in obj_list:
    100.                 if anno_dic["category"] not in select_dict["type"]:
    101.                     continue
    102.                 # print(anno_dic["category"])
    103.                 if anno_dic["category"] in includes_type:
    104.                     includes_type[anno_dic["category"]] += 1
    105.                 else:
    106.                     includes_type[anno_dic["category"]] = 1
    107.             # print(includes_type)
    108.             own_type = max(includes_type, key=includes_type.get)
    109.             count[own_type] += 1
    110.             num_rate = count[own_type] / owntype_sum[own_type]
    111.  
    112.             # 切换dataset的引用对象，从而划分数据集根据每个类别类别的总数量按7：2：1分为了train_set,val_set,test_set。
    113.             # 其中每个图片所属类别根据该图片包含的类别的数量决定（归属为含有类别最多的类别）
    114.            target = 'E:/WorkSpace/YOLO/data/'
    115.  
    116.             if num_rate < 0.7:
    117.                 dataset = train_dataset
    118.                 #print(image_path)
    119.                 shutil.copyfile(parent_path + image_path, target + '/train/' + image_path.split("/")[1])
    120.             elif num_rate < 0.9:
    121.                 dataset = val_dataset
    122.                 shutil.copyfile(parent_path + image_path, target + '/val/' + image_path.split("/")[1])
    123.                 #print(image_path)
    124.             else:
    125.                 #print("dataset=test_dataset")
    126.                 dataset = test_dataset
    127.                 #print(image_path)
    128.                 shutil.copyfile(parent_path + image_path, target + '/test/' + image_path.split("/")[1])
    129.  
    130.             for anno_dic in obj_list:
    131.                 if anno_dic["category"] not in select_dict["type"]:
    132.                     continue
    133.                 x = anno_dic['bbox']['xmin']
    134.                 y = anno_dic['bbox']['ymin']
    135.                 width = anno_dic['bbox']['xmax'] - anno_dic['bbox']['xmin']
    136.                 height = anno_dic['bbox']['ymax'] - anno_dic['bbox']['ymin']
    137.                 label_key = anno_dic['category']
    138.  
    139.                 dataset['annotations'].append({
    140.                     'area': width * height,
    141.                     'bbox': [x, y, width, height],
    142.                     'category_id': label[label_key],
    143.                     'id': obj_id,
    144.                     'image_id': image_id,
    145.                     'iscrowd': 0,
    146.                     # mask, 矩形是从左上角点按顺时针的四个顶点
    147.                     'segmentation': [[x, y, x + width, y, x + width, y + height, x, y + height]]
    148.                 })
    149.                 # 每个标注的对象id唯一
    150.                 obj_id += 1
    151.  
    152.             # 用opencv读取图片，得到图像的宽和高
    153.             im = cv2.imread(os.path.join(parent_path, image_path))
    154.             #####---------------------------------------------
    155.             ##print(image_path)  #test  other train
    156.             prefix = image_path.split("/")[0]
    157.  
    158.  
    159.             H,W,_ = im.shape
    160.             # 添加图像的信息到dataset中
    161.             dataset['images'].append({'file_name': image_name,
    162.                                       'id': image_id,
    163.                                       'width': W,
    164.                                       'height': H})
    165.  
    166.         # 保存结果
    167.         for phase in ['train', 'val', 'test']:
    168.             json_name = os.path.join(parent_path, 'dataset/annotations/{}.json'.format(phase))
    169.             with open(json_name, 'w', encoding="utf-8") as f:
    170.                 if phase == 'train':
    171.                     json.dump(train_dataset, f, ensure_ascii=False, indent=1)
    172.                 if phase == 'val':
    173.                     json.dump(val_dataset, f, ensure_ascii=False, indent=1)
    174.                 if phase == 'test':
    175.                     json.dump(test_dataset, f, ensure_ascii=False, indent=1)

    coco_json2yolo_txt(self, class_json)函数：生成路径txt

    第一个框是你的 如下三个文件路径，第二个框是你要生成的txt文件保存路径，可以自己定

    这个地方是yolo源码文件里面的一个路径，可以先看看我后面的yolo数据集文件夹的建立了，再来确认这个路径

    1.     def coco_json2yolo_txt(self, class_json):
    2.         # COCO 格式的数据集转化为 YOLO 格式的数据集
    3.         # --json_path 输入的json文件路径
    4.         # --save_path 保存的文件夹名字，默认为当前目录下的labels。
    5.  
    6.         def convert(size, box):
    7.             dw = 1. / (size[0])
    8.             dh = 1. / (size[1])
    9.             x = box[0] + box[2] / 2.0
    10.             y = box[1] + box[3] / 2.0
    11.             w = box[2]
    12.             h = box[3]
    13.             # round函数确定(xmin, ymin, xmax, ymax)的小数位数
    14.             x = round(x * dw, 6)
    15.             w = round(w * dw, 6)
    16.             y = round(y * dh, 6)
    17.             h = round(h * dh, 6)
    18.             return (x, y, w, h)
    19.  
    20.         # class_json = 'train'
    21.         json_file = os.path.join(
    22.             'E:/WorkSpace/YOLO/data/data/dataset/annotations/%s.json' % class_json)  # COCO Object Instance 类型的标注
    23.         #E:/WorkSpace/YOLO/data/data/dataset/annotations/val.json
    24.         #print(json_file)
    25.         # ana_txt_save_path = 'D:/jinxData/TT100K/data/dataset/annotations/train'  # 保存的路径
    26.         ana_txt_save_path = os.path.join('E:/WorkSpace/YOLO/data/data/dataset/annotations/', class_json)  # 保存的路径
    27.         #print(class_json)#val
    28.         #print(ana_txt_save_path)#E:/WorkSpace/YOLO/data/data/dataset/annotations\val
    29.         data = json.load(open(json_file, 'r'))
    30.         if not os.path.exists(ana_txt_save_path):
    31.             os.makedirs(ana_txt_save_path)
    32.  
    33.         id_map = {}  # coco数据集的id不连续！重新映射一下再输出！
    34.         with open(os.path.join(ana_txt_save_path, 'classes.txt'), 'w') as f:
    35.             # 写入classes.txt
    36.             for i, category in enumerate(data['categories']):
    37.                 f.write(f"{category['name']}\n")
    38.                 id_map[category['id']] = i
    39.         # print(id_map)
    40.         # 这里需要根据自己的需要，更改写入图像相对路径的文件位置。
    41.         list_file = open(os.path.join(ana_txt_save_path, '%s.txt' % class_json.format()), 'w')
    42.  
    43.         for img in tqdm(data['images']):
    44.             filename = img["file_name"]
    45.             img_width = img["width"]
    46.             img_height = img["height"]
    47.             img_id = img["id"]
    48.             head, tail = os.path.splitext(filename)
    49.             ana_txt_name = head + ".txt"  # 对应的txt名字，与jpg一致
    50.             f_txt = open(os.path.join(ana_txt_save_path, ana_txt_name), 'w')
    51.             for ann in data['annotations']:
    52.                 if ann['image_id'] == img_id:
    53.                     box = convert((img_width, img_height), ann["bbox"])
    54.                     f_txt.write("%s %s %s %s %s\n" % (id_map[ann["category_id"]], box[0], box[1], box[2], box[3]))
    55.             f_txt.close()
    56.             #将图片的相对路径写入train2017或val2017的路径  'E:/WorkSpace/YOLO/yolov7-main/yolov7-main/dataset/TT100K/images/'
    57.             #list_file.write('%s/%s/%s.jpg\n' % ('E:/WorkSpace/YOLO/data/data/',class_json.format(), head))
    58.             list_file.write('%s/%s/%s.jpg\n' % ('E:/WorkSpace/YOLO/yolov7-main/yolov7-main/data/TT100K/images/', class_json.format(), head))
    59.         list_file.close()

    以上部分是对数据集处理部分代码的修改，每个函数可以单独运行。且我丢弃了原作者的几个函数。

    三、开始训练

    参考链接：yolov7训练自己的数据集_我把把C的博客-CSDN博客

    3.1数据集准备

    创建目录，把生成的相关文件移动到对应目录，上面说到的这个路径就知道怎么改了

     3.2 创建yaml文件

    1. train: E:/WorkSpace/YOLO/yolov7-main/yolov7-main/data/TT100K/train.txt
    2. val: E:/WorkSpace/YOLO/yolov7-main/yolov7-main/data/TT100K/val.txt
    3. test: E:/WorkSpace/YOLO/yolov7-main/yolov7-main/data/TT100K/test.txt
    4. nc: 42
    5. names: ['i2','i4','i5','il100','il60','il80','io','ip','p10','p11',
    6.         'p12','p19','p23','p26','p27','p3','p5','p6','pg','ph4',
    7.         'ph4.5','pl100','pl120','pl20','pl30','pl40','pl5','pl50','pl60','pl70',
    8.         'pl80','pm20','pm30','pm55','pn','pne','po','pr40','w13','w55',
    9.         'w57','w59'
    10. ]

    3.3 修改yolov7.yaml文件

     3.4 修改训练文件参数

     大功告成，训练中出现的问题，网上都能找到，我就不列举了

  • 相关阅读:
    2022年全球市场抹茶巧克力总体规模、主要生产商、主要地区、产品和应用细分研究报告
    【妙】IP，域名，爬虫，这三个关键词之间的微关系
    java计算机毕业设计科大学生党员之家设计源码+数据库+lw文档+系统
    js语法(es6)
    MySQL-HMA 高可用故障切换
    OC-run loop
    纵目科技冲刺科创板上市：拟募资20亿元，股东阵容强大
    鸿蒙APP开发页面组件之间的属性关系
    [多媒体] 多媒体封装格式 —— MP4 vs MKV
    Flutter组件--SizeBox、FittedBox(子组件超出父组件缩放和对齐)
  • 原文地址：https://blog.csdn.net/qq_42475191/article/details/130901963