• 关键点数据增强

    1.关键点平移数据增强

    1. # 关键点数据增强
    2. from PIL import Image, ImageDraw
    3. import random
    4. import json
    5. from pathlib import Path
    6.  
    7. # 创建一个黑色背景图像
    8. width, height = 5000, 5000  # 图像宽度和高度
    9. background_color = (0, 0, 0)  # 黑色填充
    10.  
    11. # 随机分布图像
    12. num_images = 1  # 要随机分布的图像数量
    13. folder_path = Path("E:/2") # 测试图像目录
    14. output_path = Path("E:/5") # 输出图像目录
    15. for file in folder_path.rglob("*.jpg"):
    16.         # eg: file = "目录名/123.jpg"，file_name = "123.jpg"
    17.         file_name = file.name
    18.         image_origin = Image.open(file)
    19.         width_origin,height_origin = image_origin.size
    20.  
    21.         for _ in range(num_images):
    22.                 #随机选择图像的位置
    23.                 x = random.randint(0, width - width_origin)
    24.                 y = random.randint(0, height - height_origin)
    25.                 print(x,y)
    26.  
    27.                 canvas = Image.new("RGB", (width,height), background_color) #新建一个mask，全黑填充
    28.                 canvas.paste(image_origin, (x,y)) #将原图从(x,y)处粘贴到mask上
    29.  
    30.                 Path.mkdir(output_path, exist_ok=True)
    31.                 img_name = 'a' + '_' + file_name #改变增强后图片的名字
    32.                 canvas.save(output_path / img_name)
    33.                 
    34.                 jsonFile = file.with_suffix(".json")
    35.                 print(jsonFile)
    36.                 if Path.exists(jsonFile): #判断图片是否有对应的json文件
    37.                         print(f"找到{file}的Json文件")
    38.                         with open(jsonFile, "r", encoding="utf-8") as f:
    39.                                 objectDict = json.load(f)
    40.                         objectDict["imageData"] =  None # 清空json文件里加密的imgdata
    41.  
    42.                         objectDict["imageHeight"] = height
    43.                         objectDict["imageWidth"] = width
    44.  
    45.                         json_name = 'a' + '_' + jsonFile.name #改变增强后json文件的名字
    46.  
    47.                         for i in range(len(objectDict["shapes"])):
    48.                                 if objectDict["shapes"][i]["shape_type"] in ["rectangle","line"]: #矩形框、线段
    49.                                         objectDict["shapes"][i]['points'][0][0]+=x
    50.                                         objectDict["shapes"][i]['points'][0][1]+=y
    51.                                         objectDict["shapes"][i]['points'][1][0]+=x
    52.                                         objectDict["shapes"][i]['points'][1][1]+=y
    53.  
    54.                                 if objectDict["shapes"][i]["shape_type"] in ["polygon"]: #多段线
    55.                                         for polygonMat in objectDict["shapes"][i]['points']:
    56.                                                 polygonMat[0]+=x
    57.                                                 polygonMat[1]+=y
    58.                                         
    59.                                 if objectDict["shapes"][i]["shape_type"] in ["point"]: #关键点
    60.                                         objectDict["shapes"][i]['points'][0][0]+=x
    61.                                         objectDict["shapes"][i]['points'][0][1]+=y
    62.  
    63.                         with open(output_path / json_name, 'w',encoding='utf-8') as f:
    64.                                 json.dump(objectDict, f)
    65.                         
    66.                 else:
    67.                         print("没有Json文件")

    2.关键点旋转数据增强

    1. from PIL import Image
    2. import random
    3. import json
    4. from pathlib import Path
    5. import numpy as np
    6.  
    7.  
    8. def calc(center, radius):
    9.     print(center)
    10.     return [[center[0][0] - radius, center[0][1] - radius],
    11.             [center[0][0] + radius, center[0][1] + radius]]
    12.     
    13.  
    14. folder_path = Path("E:/2") # 原图片和json文件夹目录
    15. output_path = Path("E:\dataset1") # 输出目录（包含img和json）
    16.  
    17. centerAnno = '6' # 定义圆心标注点，只能有一个
    18. radius = 1430 # 通过radius和圆心centerAnno生成矩形框
    19.  
    20. for file in folder_path.rglob("*.jpg"):
    21.         file_name = file.name
    22.         file_name1 = 'r9' + '_' + file_name #改变增强后图片的名字
    23.  
    24.         image_origin = Image.open(file)
    25.         width_origin,height_origin = image_origin.size
    26.  
    27.         angle = random.randint(-10, 10) #设置随机旋转范围
    28.         print(angle)
    29.         rotate_img = image_origin.rotate(angle)
    30.  
    31.         Path.mkdir(output_path, exist_ok=True)
    32.         rotate_img.save(output_path / file_name1)
    33.  
    34.         jsonFile = file.with_suffix(".json")
    35.         jsonFile1 =  'r9' + '_' + jsonFile.name #改变增强后json文件的名字
    36.  
    37.         print(jsonFile)
    38.         if Path.exists(jsonFile):
    39.             print(f"找到{file}的Json文件")
    40.             with open(jsonFile, "r", encoding="utf-8") as f:
    41.                 objectDict = json.load(f)
    42.                                 
    43.             objectDict["imageData"] =  None # 清空json文件里加密的imgdata
    44.  
    45.             rad = np.pi / 180 * angle
    46.             print(rad)
    47.  
    48.             rot_matrix = np.array([[np.cos(rad), -np.sin(rad)], 
    49.                                    [np.sin(rad), np.cos(rad)]])
    50.  
    51.             for shape in objectDict["shapes"]:
    52.                 if shape["shape_type"] in ["line"]:
    53.                     x1, y1 = np.dot([shape['points'][0][0] - width_origin /2, shape['points'][0][1] - height_origin /2], rot_matrix)
    54.                     x2, y2 = np.dot([shape['points'][1][0] - width_origin /2, shape['points'][1][1] - height_origin /2], rot_matrix)
    55.  
    56.                     shape['points'][0][0] = x1 + width_origin /2
    57.                     shape['points'][0][1] = y1 + height_origin /2
    58.                     shape['points'][1][0] = x2 + width_origin /2
    59.                     shape['points'][1][1] = y2 + height_origin /2
    60.  
    61.                 if shape["shape_type"] in ["polygon"]:
    62.                     for polygonMat in shape['points']:
    63.                         x1, y1 = np.dot([polygonMat[0] - width_origin /2, polygonMat[1] - height_origin /2], rot_matrix)
    64.                         polygonMat[0] = x1 + width_origin /2
    65.                         polygonMat[1] = y1 + height_origin /2
    66.                 if shape["shape_type"] in ["point"]:
    67.                     x1, y1 = np.dot([shape['points'][0][0] - width_origin /2, shape['points'][0][1] - height_origin /2], rot_matrix)
    68.                     shape['points'][0][0] = x1 + width_origin /2
    69.                     shape['points'][0][1] = y1 + height_origin /2
    70.  
    71.             # 找到圆心标注框，只能有一个
    72.             for shape in objectDict["shapes"]:
    73.                 if shape["label"] == centerAnno:
    74.                     centerPoint = shape["points"]
    75.  
    76.             for shape in objectDict["shapes"]:
    77.                 if shape["shape_type"] == "rectangle":
    78.                     [shape["points"][0], shape["points"][1]] = calc(centerPoint, radius)
    79.                     print(centerPoint)
    80.                     print(shape["points"][0], shape["points"][1])
    81.  
    82.  
    83.             with open(output_path / jsonFile1, 'w',encoding='utf-8') as f:
    84.                 json.dump(objectDict, f)
    85.  
    86.  
    87.         else:
    88.             print("没有Json文件")
    89.

    3.关键点可视化

    1. # 可视化关键点位置
    2. import cv2
    3. from pathlib import Path
    4. import json
    5. import matplotlib.pyplot as plt
    6.  
    7. folder_path = Path("E:/2_1") # 原图及json文件夹
    8. output_path = Path("E:/2_2") # 可视化图片输出文件夹
    9.  
    10. # 载入图像
    11. for img_path in folder_path.rglob("*.jpg"):
    12.     print(img_path)
    13.     file_name = img_path.name
    14.     img_bgr = cv2.imread(str(img_path))
    15.  
    16. # 载入labelme格式的json标注文件
    17.     labelme_path = img_path.with_suffix(".json")
    18.     print(labelme_path)
    19. # labelme_path = 'meter_6_25.json'
    20.  
    21.     with open(labelme_path, 'r', encoding='utf-8') as f:
    22.         labelme = json.load(f)
    23.  
    24. # 查看标注信息  rectangle:矩形  point:点  polygon:多边形
    25. # print(labelme.keys())
    26. # dict_keys(['version', 'flags', 'shapes', 'imagePath', 'imageData', 'imageHeight', 'imageWidth'])
    27. # print(labelme['shapes'])
    28.  
    29.     # <<<<<<<<<<<<<<<<<<可视化框（rectangle）标注>>>>>>>>>>>>>>>>>>>>>
    30.     # 框可视化配置
    31.     bbox_color = (255, 129, 0)           # 框的颜色
    32.     bbox_thickness = 5                   # 框的线宽
    33.  
    34.     # 框类别文字
    35.     bbox_labelstr = {
    36.         'font_size':6,         # 字体大小
    37.         'font_thickness':14,   # 字体粗细
    38.         'offset_x':0,          # X 方向，文字偏移距离，向右为正
    39.         'offset_y':-80,       # Y 方向，文字偏移距离，向下为正
    40.     }
    41.     # 画框
    42.     for each_ann in labelme['shapes']:  # 遍历每一个标注
    43.  
    44.         if each_ann['shape_type'] == 'rectangle':  # 筛选出框标注
    45.  
    46.             # 框的类别
    47.             bbox_label = each_ann['label']
    48.             # 框的两点坐标
    49.             bbox_keypoints = each_ann['points']
    50.             bbox_keypoint_A_xy = bbox_keypoints[0]
    51.             bbox_keypoint_B_xy = bbox_keypoints[1]
    52.             # 左上角坐标
    53.             bbox_top_left_x = int(min(bbox_keypoint_A_xy[0], bbox_keypoint_B_xy[0]))
    54.             bbox_top_left_y = int(min(bbox_keypoint_A_xy[1], bbox_keypoint_B_xy[1]))
    55.             # 右下角坐标
    56.             bbox_bottom_right_x = int(max(bbox_keypoint_A_xy[0], bbox_keypoint_B_xy[0]))
    57.             bbox_bottom_right_y = int(max(bbox_keypoint_A_xy[1], bbox_keypoint_B_xy[1]))
    58.  
    59.             # 画矩形：画框
    60.             img_bgr = cv2.rectangle(img_bgr, (bbox_top_left_x, bbox_top_left_y), (bbox_bottom_right_x, bbox_bottom_right_y),
    61.                                     bbox_color, bbox_thickness)
    62.  
    63.             # 写框类别文字：图片，文字字符串，文字左上角坐标，字体，字体大小，颜色，字体粗细
    64.             img_bgr = cv2.putText(img_bgr, bbox_label, (
    65.                                   bbox_top_left_x + bbox_labelstr['offset_x'],
    66.                                   bbox_top_left_y + bbox_labelstr['offset_y']),
    67.                                   cv2.FONT_HERSHEY_SIMPLEX, bbox_labelstr['font_size'], bbox_color,
    68.                                   bbox_labelstr['font_thickness'])
    69.  
    70.  
    71.     # <<<<<<<<<<<<<<<<<<可视化关键点（keypoint）标注>>>>>>>>>>>>>>>>>>>>>
    72.     # 关键点的可视化配置
    73.     # 关键点配色
    74.     kpt_color_map = {
    75.         '0': {'name': '0', 'color': [0, 0, 255], 'radius': 25, 'thickness':-1},
    76.         '1': {'name': '1', 'color': [255, 0, 0], 'radius': 25, 'thickness':-1},
    77.         '2': {'name': '2', 'color': [255, 0, 0], 'radius': 25, 'thickness':-1},
    78.         '3': {'name': '3', 'color': [0, 255, 0], 'radius': 25, 'thickness':-1},
    79.         '4': {'name': '4', 'color': [0, 255, 0], 'radius': 25, 'thickness':-1},
    80.         '5': {'name': '5', 'color': [193, 182, 255], 'radius': 25, 'thickness':-1},
    81.         '6': {'name': '6', 'color': [193, 182, 255], 'radius': 25, 'thickness':-1},
    82.         # '7': {'name': '7', 'color': [16, 144, 247], 'radius': 25},
    83.         # '8': {'name': '8', 'color': [16, 144, 247], 'radius': 25},
    84.     }
    85.  
    86.     # 点类别文字
    87.     kpt_labelstr = {
    88.         'font_size':4,             # 字体大小
    89.         'font_thickness':12,       # 字体粗细
    90.         'offset_x':30,             # X 方向，文字偏移距离，向右为正
    91.         'offset_y':100,            # Y 方向，文字偏移距离，向下为正
    92.     }
    93.  
    94.     # 画点
    95.     for each_ann in labelme['shapes']:  # 遍历每一个标注
    96.         if each_ann['shape_type'] == 'point':  # 筛选出关键点标注
    97.             kpt_label = each_ann['label']  # 该点的类别
    98.             # 该点的 XY 坐标
    99.             kpt_xy = each_ann['points'][0]
    100.             kpt_x, kpt_y = int(kpt_xy[0]), int(kpt_xy[1])
    101.             # 该点的可视化配置
    102.             kpt_color = kpt_color_map[kpt_label]['color']  # 颜色
    103.             kpt_radius = kpt_color_map[kpt_label]['radius']  # 半径
    104.             kpt_thickness = kpt_color_map[kpt_label]['thickness']  # 线宽（-1代表填充）
    105.             # 画圆：画该关键点
    106.             img_bgr = cv2.circle(img_bgr, (kpt_x, kpt_y), kpt_radius, kpt_color, kpt_thickness)
    107.             # 写该点类别文字：图片，文字字符串，文字左上角坐标，字体，字体大小，颜色，字体粗细
    108.             img_bgr = cv2.putText(img_bgr, kpt_label, (kpt_x + kpt_labelstr['offset_x'], kpt_y + kpt_labelstr['offset_y']),
    109.                                   cv2.FONT_HERSHEY_SIMPLEX, kpt_labelstr['font_size'], kpt_color,
    110.                                   kpt_labelstr['font_thickness'])
    111.  
    112.  
    113.     # # <<<<<<<<<<<<<<<<<<可视化多段线（polygon）标注>>>>>>>>>>>>>>>>>>>>>
    114.     # # 多段线的可视化配置
    115.     # poly_color = (151, 57, 224)
    116.     # poly_thickness = 3
    117.     #
    118.     # poly_labelstr = {
    119.     #     'font_size':4,          # 字体大小
    120.     #     'font_thickness':12,    # 字体粗细
    121.     #     'offset_x':-200,        # X 方向，文字偏移距离，向右为正
    122.     #     'offset_y':0,           # Y 方向，文字偏移距离，向下为正
    123.     # }
    124.     #
    125.     # # 画多段线
    126.     # img_mask = np.ones(img_bgr.shape, np.uint8) #创建一个和img_bgr一样大小的黑色mask
    127.     #
    128.     # for each_ann in labelme['shapes']:  # 遍历每一个标注
    129.     #
    130.     #     if each_ann['shape_type'] == 'polygon':  # 筛选出多段线（polygon）标注
    131.     #
    132.     #         poly_label = each_ann['label']  # 该多段线的类别
    133.     #
    134.     #         poly_points = [np.array(each_ann['points'], np.int32).reshape((-1, 1, 2))]  #reshape后增加一个维度
    135.     #
    136.     #         # 该多段线平均 XY 坐标，用于放置多段线类别文字
    137.     #         x_mean = int(np.mean(poly_points[0][:, 0, :][:, 0])) #取出所有点的x坐标并求平均值
    138.     #         y_mean = int(np.mean(poly_points[0][:, 0, :][:, 1])) #取出所有点的y坐标并求平均值
    139.     #
    140.     #         # 画该多段线轮廓
    141.     #         img_bgr = cv2.polylines(img_bgr, poly_points, isClosed=True, color=poly_color, thickness=poly_thickness)
    142.     #
    143.     #         # 画该多段线内部填充
    144.     #         img_mask = cv2.fillPoly(img_mask, poly_points, color=poly_color) #填充的颜色为color=poly_color
    145.     #
    146.     #         # 写该多段线类别文字：图片，文字字符串，文字左上角坐标，字体，字体大小，颜色，字体粗细
    147.     #         img_bgr = cv2.putText(img_bgr, poly_label,
    148.     #                               (x_mean + poly_labelstr['offset_x'], y_mean + poly_labelstr['offset_y']),
    149.     #                               cv2.FONT_HERSHEY_SIMPLEX, poly_labelstr['font_size'], poly_color,
    150.     #                               poly_labelstr['font_thickness'])
    151.  
    152.     # opacity = 0.8 # 透明度，越大越接近原图
    153.     # img_bgr = cv2.addWeighted(img_bgr, opacity, img_mask, 1-opacity, 0)
    154.  
    155.     # 可视化
    156.     # plt.imshow(img_bgr[:,:,::-1]) # 将bgr通道转换成rgb通道
    157.     # plt.show()
    158.  
    159.     # 可视化多段线填充效果
    160.     # plt.imshow(img_mask[:, :, ::-1])  # 将bgr通道转换成rgb通道
    161.     # plt.show()
    162.  
    163.     # 当前目录下保存可视化结果
    164.     cv2.imwrite(str(output_path) + '/' + file_name, img_bgr)

    4.json2txt（用YOLOV8进行关键点训练）

    1. #将坐标框、关键点、线段的json标注转换为txt
    2. import os
    3. import json
    4. import shutil
    5. import numpy as np
    6. from tqdm import tqdm
    7.  
    8. # 框的类别
    9. bbox_class = {
    10.     'meter3':0
    11. }
    12. # 关键点的类别，注意按顺序写
    13. keypoint_class = ['0','1','2','3','4','5','6','7','8']
    14.  
    15. path = 'E:/6' #json文件存放路径
    16. save_folder='E:/7' #转换后的txt文件存放路径
    17.  
    18. # 定义单个json文件的转换
    19. def process_single_json(labelme_path, save_folder):
    20.     with open(labelme_path, 'r', encoding='utf-8') as f:
    21.         labelme = json.load(f)
    22.  
    23.     img_width = labelme['imageWidth']  # 图像宽度
    24.     img_height = labelme['imageHeight']  # 图像高度
    25.  
    26.     # 生成 YOLO 格式的 txt 文件
    27.     suffix = labelme_path.split('.')[-2]
    28.     # print(suffix)
    29.     yolo_txt_path = suffix + '.txt'
    30.     # print(yolo_txt_path)
    31.  
    32.     with open(yolo_txt_path, 'w', encoding='utf-8') as f:
    33.  
    34.         for each_ann in labelme['shapes']:  # 遍历每个标注
    35.  
    36.             if each_ann['shape_type'] == 'rectangle':  # 每个框，在 txt 里写一行
    37.  
    38.                 yolo_str = ''
    39.  
    40.                 # 框的信息
    41.                 # 框的类别 ID
    42.                 bbox_class_id = bbox_class[each_ann['label']]
    43.                 yolo_str += '{} '.format(bbox_class_id)
    44.                 # 左上角和右下角的 XY 像素坐标
    45.                 bbox_top_left_x = int(min(each_ann['points'][0][0], each_ann['points'][1][0]))
    46.                 bbox_bottom_right_x = int(max(each_ann['points'][0][0], each_ann['points'][1][0]))
    47.                 bbox_top_left_y = int(min(each_ann['points'][0][1], each_ann['points'][1][1]))
    48.                 bbox_bottom_right_y = int(max(each_ann['points'][0][1], each_ann['points'][1][1]))
    49.                 # 框中心点的 XY 像素坐标
    50.                 bbox_center_x = int((bbox_top_left_x + bbox_bottom_right_x) / 2)
    51.                 bbox_center_y = int((bbox_top_left_y + bbox_bottom_right_y) / 2)
    52.                 # 框宽度
    53.                 bbox_width = bbox_bottom_right_x - bbox_top_left_x
    54.                 # 框高度
    55.                 bbox_height = bbox_bottom_right_y - bbox_top_left_y
    56.                 # 框中心点归一化坐标
    57.                 bbox_center_x_norm = bbox_center_x / img_width
    58.                 bbox_center_y_norm = bbox_center_y / img_height
    59.                 # 框归一化宽度
    60.                 bbox_width_norm = bbox_width / img_width
    61.                 # 框归一化高度
    62.                 bbox_height_norm = bbox_height / img_height
    63.  
    64.                 yolo_str += '{:.5f} {:.5f} {:.5f} {:.5f} '.format(bbox_center_x_norm, bbox_center_y_norm,
    65.                                                                   bbox_width_norm, bbox_height_norm)
    66.  
    67.                 ## 找到该框中所有关键点，存在字典 bbox_keypoints_dict 中
    68.                 bbox_keypoints_dict = {}
    69.                 for each_ann in labelme['shapes']:  # 遍历所有标注
    70.                     if each_ann['shape_type'] == 'point':  # 筛选出关键点标注
    71.                         # 关键点XY坐标、类别
    72.                         x = int(each_ann['points'][0][0])
    73.                         y = int(each_ann['points'][0][1])
    74.                         label = each_ann['label']
    75.                         if (x > bbox_top_left_x) & (x < bbox_bottom_right_x) & (y < bbox_bottom_right_y) & \
    76.                                 (y > bbox_top_left_y):  # 筛选出在该个体框中的关键点
    77.                             bbox_keypoints_dict[label] = [x, y]
    78.  
    79.                     if each_ann['shape_type'] == 'line':  # 筛选出线段标注
    80.                         # 起点XY坐标、类别
    81.                         x0 = int(each_ann['points'][0][0])
    82.                         y0 = int(each_ann['points'][0][1])
    83.                         label = each_ann['label']
    84.                         bbox_keypoints_dict[label] = [x0, y0]
    85.                         # 终点XY坐标、类别
    86.                         x1 = int(each_ann['points'][1][0])
    87.                         y1 = int(each_ann['points'][1][1])
    88.                         label = int(each_ann['label']) + 1 #将字符串转为整形，并+1，代表最后一个点
    89.                         label = str(label) #将整型转为字符串
    90.                         bbox_keypoints_dict[label] = [x1, y1]
    91.                 # print(bbox_keypoints_dict)
    92.  
    93.                         # if (x > bbox_top_left_x) & (x < bbox_bottom_right_x) & (y < bbox_bottom_right_y) & \
    94.                         #         (y > bbox_top_left_y):  # 筛选出在该个体框中的关键点
    95.                         #     bbox_keypoints_dict[label] = [x, y]
    96.  
    97.                 ## 把关键点按顺序排好
    98.                 for each_class in keypoint_class:  # 遍历每一类关键点
    99.                     if each_class in bbox_keypoints_dict:
    100.                         keypoint_x_norm = bbox_keypoints_dict[each_class][0] / img_width
    101.                         keypoint_y_norm = bbox_keypoints_dict[each_class][1] / img_height
    102.  
    103.                         yolo_str += '{:.5f} {:.5f} {} '.format(keypoint_x_norm, keypoint_y_norm, 2)  # 2可见不遮挡 1遮挡 0没有点
    104.                     else:  # 不存在的点，一律为0
    105.                         # yolo_str += '0 0 0 '.format(keypoint_x_norm, keypoint_y_norm, 0)
    106.                         yolo_str += '0 0 0 '
    107.                         # yolo_str += ' '
    108.                 # 写入 txt 文件中
    109.                 f.write(yolo_str + '\n')
    110.  
    111.     shutil.move(yolo_txt_path, save_folder) #从yolo_txt_path文件夹中移动到save_folder文件夹中
    112.     # print('{} --> {} 转换完成'.format(labelme_path, yolo_txt_path))
    113.  
    114.  
    115. # json2txt
    116. for labelme_path0 in os.listdir(path):
    117.     labelme_path = path + '/' + labelme_path0
    118.     print(labelme_path)
    119.     process_single_json(labelme_path, save_folder)
    120. print('YOLO格式的txt标注文件已保存至 ', save_folder)

    5.划分训练集和验证集

    1. import os
    2. import random
    3. import shutil
    4.  
    5. # 定义数据目录
    6. data_directory = "E:\dataset_a"  # 图片和标签数据目录
    7. #  dataset_a
    8. #     images
    9. #     labels
    10.  
    11. output_directory = "E:\dataset_b"  # 输出数据目录
    12. train_directory = output_directory + "/images/train"
    13. val_directory = output_directory + "/images/val"
    14. label_train_directory = output_directory + "/labels/train"
    15. label_val_directory = output_directory + "/labels/val"
    16.  
    17. # 创建训练集和验证集目录(图片和标签)
    18. os.makedirs(train_directory, exist_ok=True)
    19. os.makedirs(val_directory, exist_ok=True)
    20. os.makedirs(label_train_directory, exist_ok=True)
    21. os.makedirs(label_val_directory, exist_ok=True)
    22.  
    23. # 定义划分比例（例如，80%训练集，20%验证集）
    24. split_ratio = 0.8
    25.  
    26. # 获取数据文件列表
    27. data_files = os.listdir(data_directory + "/images")
    28.  
    29. # 随机打乱数据文件列表
    30. random.shuffle(data_files)
    31.  
    32. # 计算划分点
    33. split_point = int(len(data_files) * split_ratio)
    34.  
    35. # 分配数据文件到训练集和验证集
    36. train_files = data_files[:split_point]
    37. val_files = data_files[split_point:]
    38.  
    39. # 复制图像文件到相应的目录
    40. for file in train_files:
    41.     src_path = os.path.join(data_directory + "/images", file)
    42.     dest_path = os.path.join(train_directory, file)
    43.     shutil.copy(src_path, dest_path)
    44.  
    45. for file in val_files:
    46.     src_path = os.path.join(data_directory + "/images", file)
    47.     dest_path = os.path.join(val_directory, file)
    48.     shutil.copy(src_path, dest_path)
    49.  
    50. # 复制标签文件到相应的目录
    51. for file in train_files:
    52.     name = file.split(".")[0]
    53.     label_name = name + '.txt'
    54.     src_path = os.path.join(data_directory + "/labels", label_name)
    55.     dest_path = os.path.join(label_train_directory, label_name)
    56.     shutil.copy(src_path, dest_path)
    57.  
    58. for file in val_files:
    59.     name = file.split(".")[0]
    60.     label_name = name + '.txt'
    61.     src_path = os.path.join(data_directory + "/labels", label_name)
    62.     dest_path = os.path.join(label_val_directory, label_name)
    63.     shutil.copy(src_path, dest_path)
    64.  
    65. print(f"划分完成！训练集包含 {len(train_files)} 张图像，验证集包含 {len(val_files)} 张图像。")

  • 相关阅读:
    【Axure教程】中继器联动——二级下拉列表案例
    .net core 和 WPF 开发升讯威在线客服系统：怎样实现拔网线也不丢消息的高可靠通信（附视频）
    Linux内存映射函数mmap与匿名内存块
    MVCC多版本并发控制和幻读问题的解决
    java计算机毕业设计springboot+vue员工管理系统
    Ansys Zemax | 使用 OpticStudio 进行闪光激光雷达系统建模（上）
    杭电多校七 1003-Counting Stickmen（组合数学）
    [运维|数据库] 数据库迁移到金仓数据库时，sys_user表报错原因
    以K近邻算法为例，使用网格搜索GridSearchCV优化模型最佳参数
    IDEA 22.2.3 创建web项目及Tomcat部署与服务器初始界面修改（保姆版)
  • 原文地址：https://blog.csdn.net/m0_56247038/article/details/132783264