关于YOLO8学习（二）数据集收集，处理

前文

关于YOLO8学习（一）环境搭建，官方检测模型部署到手机

简介

本文将会讲解：
（1）如何通过三方网站，获取可用于训练的数据源
（2）通过三方网址，选择合适的手机，通过手动标注，转换为可用于训练的数据源

开发环境

win10、python 3.11、cmake、pytorch2.0.1+cu117、pycharm、ultralytics==8.0.134
要特别注意，不要升级到python312，目前onnx还没支持到312，所以转换了，会导致转换模型失效。
对于上述环境如何配置，请看我之前的文章。

数据收集

对于数据收集，正常情况下，只有两种。
（1）使用别人已经标注好的数据进行训练
（2）自己去筛选数据，标注数据，整合数据用于训练。

注意，使用Yolo8进行训练，数据集合有很多种，但是最后，都将会是殊途同归。需要 通过转换数据，然后每个图片，都对应其独一无二的标注文件。标注文件的格式如下：

    # <class_index> <x_center> <y_center> <width> <height>
    # <class_index>：对象的类别索引（从0开始）。
    # <x_center>、<y_center>：对象边界框中心相对于图像宽度和高度的坐标（范围通常在0到1之间）。
    # <width>、<height>：对象边界框的宽度和高度相对于图像宽度和高度的比例（范围通常在0到1之间）。

具体成品文件截图如下：

其中，第一列，就是标签的index，0代表第一个，同样地，1代表第二个。
第二列，就是边框中心点x，相对于宽的百分比，例如有宽度为100，中心点x在50的位置，那么对应的x_center，就是0.5。
第三列和第二列的原理一致，换成y代入。
对于第四，第五列，就是边框的宽度or长度，和整个图片宽度or长度的比值。
以上第二列开始的所以值，都是0-1之间，如果出现其他情况，就是错误的。

---

首先讲解的是第一种情况：

三方网址有很多，这里都列出一些比较常用的数据集合三方网址，有需要可以上去进行下载，排名不分先后：
Kaggle
Open Images Dataset V7
阿里天池
百度飞浆
极市
Mars
上述就是一些比较常见的数据集合平台，通过这些平台，可以下载到相关的训练集合。

以kaggle为例子

打开其官网，然后搜索“Face Detection”（下载人脸检测数据集合），注意！！！这里一般都是英文搜索！！
选择过滤条件为large size，如下图：

这里就有相关的结果了。

注意！！！！

（1）明确一点，如果要模型识别比较稳定，一般都是需要比较大的数据的，不要选择那几十张，几百张的哪些数据集。一般都是5000或者10000张起步比较好。
（2）这里的结果，需要点击进入查看是否合适，而不是一股脑地下载。

博主这里选择了第二个item进入详情，进行查看，核心如下图：

从上面的图片中，可以看到，右侧的目录栏里面，是有三个文件夹，一个是images，一个是labels，最后一个是labels2。现在点击labels，展开看看其中一个文件的内容。

可以看到，这个格式，就是我们需要的标注格式了，所以就可以下载了！

点击DownLoad的黑色按钮，即可下载

---

至此，简单地说明了如何从网上下载已经整理好的数据集合了。这种方式，一般是推荐的，因为数据集需要的量多，如果要人手进行标注，那么工作量非常大，除非有很多labeler进行没日没夜地标注。

----------------分割线-----------------
----------------分割线-----------------
----------------分割线-----------------

接下来讲解的是第二种情况：

第二种，也有细分。
（1）通过三方网址提供的api，进行下载
（2）通过网络数据整理，进行下载
对于方法2，这里不做讲解，具体自行了解。

下面开始方式1的讲解：

以Open Images Dataset V7为例子

统一思路

（1）编写好下载的脚本文件
（2）手动选择/自动选择需要下载的文件
（3）整理下载的文件

思路就是以上三个，下面将会详细说明如何进行数据处理。一共有两种方式。

一，通过DatasetV7提供的下载脚本，进行下载

官方脚本文件链接：官方download.py文件
博主修正后具体代码如下：文件名字：downloaddateset.py

# python3
# coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Open Images image downloader.

This script downloads a subset of Open Images images, given a list of image ids.
Typical uses of this tool might be downloading images:
- That contain a certain category.
- That have been annotated with certain types of annotations (e.g. Localized
Narratives, Exhaustively annotated people, etc.)

The input file IMAGE_LIST should be a text file containing one image per line
with the format <SPLIT>/<IMAGE_ID>, where <SPLIT> is either "train", "test",
"validation", or "challenge2018"; and <IMAGE_ID> is the image ID that uniquely
identifies the image in Open Images. A sample file could be:
  train/f9e0434389a1d4dd
  train/1a007563ebc18664
  test/ea8bfd4e765304db

python downloader.py $IMAGE_LIST_FILE --download_folder=$DOWNLOAD_FOLDER --num_processes=5
python downloaddataset.py data_apple_train.txt --download_folder=fruit/apple --num_processes=5


"""

import os
import re
import sys
from concurrent import futures

import boto3
import botocore
import tqdm

BUCKET_NAME = 'open-images-dataset'
REGEX = r'(test|train|validation|challenge2018)/([a-fA-F0-9]*)'


def check_and_homogenize_one_image(image):
    split, image_id = re.match(REGEX, image).groups()
    yield split, image_id


def check_and_homogenize_image_list(image_list):
    for line_number, image in enumerate(image_list):
        try:
            yield from check_and_homogenize_one_image(image)
        except (ValueError, AttributeError):
            raise ValueError(
                f'ERROR in line {line_number} of the image list. The following image '
                f'string is not recognized: "{image}".')


def read_image_list_file(image_list_file):
    with open(image_list_file, 'r') as f:
        for line in f:
            yield line.strip().replace('.jpg', '')


def download_one_image(bucket, split, image_id, download_folder):
    try:
        target_path = os.path.join(download_folder, split)
        bucket.download_file(f'{split}/{image_id}.jpg',
                             os.path.join(target_path, f'{image_id}.jpg'))
    except botocore.exceptions.ClientError as exception:
        sys.exit(
            f'ERROR when downloading image `{split}/{image_id}`: {str(exception)}')


def download_all_images(args):
    """Downloads all images specified in the input file."""
    bucket = boto3.resource(
        's3', config=botocore.config.Config(
            signature_version=botocore.UNSIGNED)).Bucket(BUCKET_NAME)

    download_folder = args['download_folder'] or os.getcwd()

    if not os.path.exists(download_folder):
        os.makedirs(download_folder)

    try:
        image_list = list(check_and_homogenize_image_list(read_image_list_file(args['image_list'])))
    except ValueError as exception:
        sys.exit(exception)

    # 创建目录
    for dta in image_list:
        if not os.path.exists(os.path.join(download_folder, dta[0])):
            os.makedirs(os.path.join(download_folder, dta[0]))
    progress_bar = tqdm.tqdm(total=len(image_list), desc='Downloading images', leave=True)
    if len(image_list) == 0:
        sys.exit('No images to download.')
    with futures.ThreadPoolExecutor(max_workers=args['num_processes']) as executor:
        all_futures = [
            executor.submit(download_one_image, bucket, split, image_id,
                            download_folder) for (split, image_id) in image_list
        ]
        for future in futures.as_completed(all_futures):
            future.result()
            progress_bar.update(1)
    progress_bar.close()


def start(file_name: str, download_folder: str, num_processes: int):
    download_all_images({
        'image_list': file_name,
        'num_processes': num_processes,
        'download_folder': download_folder
    })


# python downloaddataset.py datalist/data_apple_train.txt --download_folder=fruit/apple --num_processes=5
if __name__ == '__main__':
    start("datalist/data_apple_train.txt", "fruit/apple", 5)
    # parser = argparse.ArgumentParser(
    #     description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    # parser.add_argument(
    #     'image_list',
    #     type=str,
    #     default=None,
    #     help=('Filename that contains the split + image IDs of the images to '
    #           'download. Check the document'))
    # parser.add_argument(
    #     '--num_processes',
    #     type=int,
    #     default=5,
    #     help='Number of parallel processes to use (default is 5).')
    # parser.add_argument(
    #     '--download_folder',
    #     type=str,
    #     default=None,
    #     help='Folder where to download the images.')
    # download_all_images(vars(parser.parse_args()))

那么如何下载呢？博主这里新建了两个文件，一个文件名字叫做：data_apple_test.txt，一个名字叫做data_apple_train.txt。故名思意，就是训练和测试的图片资源，具体内容如下图：

可以看到，结构的格式，是train/xxx和test/xxx开头的，前缀好理解，后面的是什么？请看官网截图：

可以看到，红色头部区域中。
博主选择了"Train"的类型，就是训练的意思，而后面的Type，选择了“Detection”，就是检测的意思。选择完这两个条件以后，点击你想要下载的图片，就会有个图片信息弹窗显示，其中，有个“ID”的关键字（对应上图）。这个id就是我们要下载图片的id。

综上，你现在已经了解了下载的python脚本如何编写，下载的内容结构如何查找。那么接下来，就开始下载！

博主这里自定义了一个下载的脚本，如下图：

 downloaddataset.start("datalist/data_apple_train.txt", "fruit/apple", 5)

//datalist/data_apple_train.txt – 刚才定义的下载id文件路径
//fruit/apple – 下载指定的目录
//5 – 下载线程数

注意，这个方法的调用，是基于博主自己定义的下载脚本，官方的脚本暂不支持，若要实现这个方法，请复制上文中博主提供的下载脚本代码，进行整合。

下面是执行下载方法后，具体的目录数据：

可以看到，下载的资源，有jpg，和json文件，但是，没有txt。那怎么办？

接下来，就要对下载的数据，进行转换！！

这里先Mark一下，当前下载的数据目录，是fruit/apple/test和fruit/apple/train，如下图：

那么，现在正是讲解，如何进行数据转换。
我们先查看方才目录下的某个json文件代码，示例如下图：

{
  "version": "5.4.1",
  "flags": {},
  "shapes": [
    {
      "label": "redapple",
      "points": [
        [
          133.7171717171717,
          57.65151515151514
        ],
        [
          635.7373737373737,
          533.4090909090909
        ]
      ],
      "group_id": null,
      "description": "",
      "shape_type": "rectangle",
      "flags": {},
      "mask": null
    }
  ],
  "imagePath": "4a5e598715686106.jpg",
  "imageData": "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",
  "imageHeight": 685,
  "imageWidth": 1024
}

抓关键字，imageWidth,imageHeight,points[]，这三个参数，就是官方文件提供的标注信息，对应就是图片的宽高，标注点的x1,y1,x2,y2。可以理解为是左上角和右下角。那么有了这些数据，是不是可以通过计算，转换出我们yolo训练需要的数据？好了，下面放出转换数据的python脚本，具体代码如下:

import json
import os
import shutil
from glob import glob
from os import getcwd

import cv2
import numpy as np
from sklearn.model_selection import train_test_split

wd = getcwd()


def get_file(json_path, test):
    files = glob(json_path + "*.json")
    files = [i.replace("\\", "/").split("/")[-1].split(".json")[0] for i in files]
    if test:
        trainval_files, test_files = train_test_split(files, test_size=0.1, random_state=55)
    else:
        trainval_files = files
        test_files = []

    return trainval_files, test_files


def convert(size, box):
    dw = 1. / (size[0])
    dh = 1. / (size[1])
    x = (box[0] + box[1]) / 2.0 - 1
    y = (box[2] + box[3]) / 2.0 - 1
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x * dw
    w = w * dw
    y = y * dh
    h = h * dh
    return (x, y, w, h)


#
# print(wd)

def json_to_txt(json_path, files, txt_name, classes):
    if not os.path.exists('cache-tmp/'):
        os.makedirs('cache-tmp/')
    list_file = open('cache-tmp/%s.txt' % (txt_name), 'w')
    for json_file_ in files:
        # print(json_file_)
        json_filename = json_path + json_file_ + ".json"
        imagePath = json_path + json_file_ + ".jpg"
        list_file.write('%s/%s\n' % (wd, imagePath))
        out_file = open('%s/%s.txt' % (json_path, json_file_), 'w')
        json_file = json.load(open(json_filename, "r", encoding="utf-8"))
        height, width, channels = cv2.imread(json_path + json_file_ + ".jpg").shape
        for multi in json_file["shapes"]:
            points = np.array(multi["points"])
            xmin = min(points[:, 0]) if min(points[:, 0]) > 0 else 0
            xmax = max(points[:, 0]) if max(points[:, 0]) > 0 else 0
            ymin = min(points[:, 1]) if min(points[:, 1]) > 0 else 0
            ymax = max(points[:, 1]) if max(points[:, 1]) > 0 else 0
            label = multi["label"]

            if xmax <= xmin:
                pass
            elif ymax <= ymin:
                pass
            else:
                cls_id = classes.index(label)
                # print(json_file_)
                b = (float(xmin), float(xmax), float(ymin), float(ymax))
                bb = convert((width, height), b)
                out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
                # print(json_filename, xmin, ymin, xmax, ymax, cls_id)


def search_file_by_format(dir_path, extension):
    """
    查找指定目录及其所有子目录下具有指定扩展名的文件，并返回它们的完整路径列表。

    参数:
        dir_path (str): 目标目录路径。
        extension (str): 指定的文件扩展名，包括前导点（如 '.txt' 或 '.jpg'）。

    返回:
        list[str]: 包含符合要求文件的完整路径的列表。
    """

    result = []
    for root, dirs, files in os.walk(dir_path):
        for file in files:
            if file.endswith(extension):
                file_path = os.path.join(root, file)
                result.append(file_path)
    return result


def create_path(path: str):
    if not os.path.exists(path):
        os.makedirs(path)


def copy_file_to_dir(src_path, target_dir):
    """
    复制文件 `src_path` 到指定 `target_dir`，同时保留文件元数据。
    目标文件将保持与源文件相同的名称。
    参数:
        src_path (str): 源文件的完整路径。
        target_dir (str): 目标目录的完整路径。
    """
    # 获取源文件名（包括扩展名）
    src_filename = os.path.basename(src_path)
    # 构建目标文件的完整路径（源文件名与目标目录拼接）
    dest_path = os.path.join(target_dir, src_filename)
    shutil.copy2(src_path, dest_path)


# 转换苹果
def train_data(path: str, classes_name: list):
    train_file, test_file = get_file(path, False)
    json_to_txt(path, train_file, "train", classes_name)


def copy_data(path: str, copy_path: str, cus_extra_path: str):
    jpg_file = search_file_by_format(path, ".jpg")
    json_file = search_file_by_format(path, ".json")
    txt_file = search_file_by_format(path, ".txt")
    create_path(os.path.join(copy_path, "images", cus_extra_path))
    create_path(os.path.join(copy_path, "json", cus_extra_path))
    create_path(os.path.join(copy_path, "labels", cus_extra_path))
    for i in jpg_file:
        copy_file_to_dir(i, os.path.join(copy_path, "images", cus_extra_path))
    for i in json_file:
        copy_file_to_dir(i, os.path.join(copy_path, "json", cus_extra_path))
    for i in txt_file:
        copy_file_to_dir(i, os.path.join(copy_path, "labels", cus_extra_path))
    print(f"复制完成{copy_path}")


def copy_directory(src_dir, dst_dir, overwrite=True):
    """
    复制源目录 `src_dir` 及其所有内容到目标目录 `dst_dir`。

    参数:
        src_dir (str): 源目录的完整路径。
        dst_dir (str): 目标目录的完整路径（如果不存在，将被创建）。
    """
    if not os.path.exists(dst_dir):
        os.makedirs(dst_dir)

    for item in os.listdir(src_dir):
        src_item = os.path.join(src_dir, item)
        dst_item = os.path.join(dst_dir, item)

        if os.path.isdir(src_item):
            copy_directory(src_item, dst_item, overwrite)
        else:
            if os.path.exists(dst_item) and overwrite:
                os.remove(dst_item)  # Remove existing file before copying
            shutil.copy2(src_item, dst_dir)  # Copy with metadata preservation


# 整合后的数据转换方法
def main_train_data_metha(label_list: list, train_data_list: list, test_data_list: list):
    # 复制原数据
    copy_directory(train_data_list[0], train_data_list[1])
    copy_directory(test_data_list[0], test_data_list[1])
    # 转换数据
    train_data(train_data_list[1], label_list)
    train_data(test_data_list[1], label_list)
    # 复制数据
    copy_data(train_data_list[1], train_data_list[2], train_data_list[3])
    copy_data(test_data_list[1], test_data_list[2], test_data_list[3])


if __name__ == '__main__':
    # 完整的一个数据标注后的处理流程
    # 苹果数据处理
    label_list = ["redapple"]
    train_data_list = ["fruit/apple/train/", "cache-train/apple-train/train/", "cache-result", "train"]
    test_data_list = ["fruit/apple/test/", "cache-train/apple-test/test/", "cache-result", "val"]
    main_train_data_metha(label_list, train_data_list, test_data_list)

执行后，可以看到，新增了三个目录，其中cache-result，就是结果目录，对应的images和labels文件夹，就是到时候Yolo需要训练的图片，还有标签目录。

那么，我们怎么知道，自己到底有没有转换出错呢？这里博主提供一个python脚本，用于校验，脚本的代码如下：

import os

import cv2


def Xmin_Xmax_Ymin_Ymax(img_path, txt_path):
    """
    :param img_path: 图片文件的路径
    :param txt_path: 标签文件的路径
    :return:
    """
    img = cv2.imread(img_path)
    # 获取图片的高宽
    h, w, _ = img.shape

    con_rect = []
    # 读取TXT文件 中的中心坐标和框大小
    with open(txt_path, "r") as fp:
        # 以空格划分
        lines = fp.readlines()
        for l in lines:
            contline = l.split(' ')

            xmin = float((contline[1])) - float(contline[3]) / 2
            xmax = float(contline[1]) + float(contline[3]) / 2
            ymin = float(contline[2]) - float(contline[4]) / 2
            ymax = float(contline[2].strip()) + float(contline[4].strip()) / 2
            xmin, xmax = w * xmin, w * xmax
            ymin, ymax = h * ymin, h * ymax

            con_rect.append((contline[0], xmin, ymin, xmax, ymax))

    return con_rect


# 根据label坐标画出目标框
def plot_tangle(img_dir, txt_dir):
    contents = os.listdir(img_dir)

    for file in contents:
        img_path = os.path.join(img_dir, file)
        img = cv2.imread(img_path)
        txt_path = os.path.join(txt_dir, (os.path.splitext(os.path.basename(file))[0] + ".txt"))

        con_rect = Xmin_Xmax_Ymin_Ymax(img_path, txt_path)

        for rect in con_rect:
            cv2.rectangle(img, (int(rect[1]), int(rect[2])), (int(rect[3]), int(rect[4])), (0, 0, 255))

        cv2.namedWindow("valwindow")
        cv2.imshow("src", img)
        cv2.waitKey()


if __name__ == "__main__":
    img_dir = "cache-result/images/train"
    txt_dir = "cache-result/labels/train"
    plot_tangle(img_dir, txt_dir)

然后指定代码，这个时候，就会有个opencv的弹窗，显示你刚才标注的结果，如下图：

那么，是不是标注完成了？
好了，上面就是自己下载数据的教程一。

二，通过Fifyone进行下载

下面是fity相关的依赖，链接：
使用文档
依赖安装
pip install fiftyone
pip install tensorflow torch torchvision umap-learn
pip install ‘ipywidgets>=8,<9’

---

完成上述步骤后，然后进行下载图片的代码编写，示例代码如下：

if __name__ == '__main__':
    dataset_test = foz.load_zoo_dataset(
        "open-images-v7",
        split="train",  # 指定下载数据集
        classes=["Lemon"],
        shuffle=True,
        max_samples=200,  # 指定下载图片数
        only_matching=True,
        label_types=["detections"],  # 指定下载目标检测的类型,detections,segmentation，relationships，classifications
        dataset_dir="E:\\workstation\\python\\resource_detected_friut_food\\OpenImg\\Cache",  # 保存的路径
        num_workers=4,  # 指定工作进程数
    )

上述代码中，可以看到，博主是指定了split='train’训练集，指定了类别为柠檬（Lemon）点击运行，即可。

接下来就是漫长的等待了，注意！！dataset_dir目录不要随意切换，这里有fiftyone的相关缓存文件！
下载完成后，目录如下：

对应的OpenImg大目录，就是存放了我们下载的一切。
同样的，data就是我们的柠檬数据，labels就是标签文件，metadata可以理解为是fifty的一些缓存文件，其中包含了数据集合的类别等信息。
是不是发现，如果我们要继续整理训练数据，还是差了标注文件？没错，那就要编写一些脚本，对labels目录中的csv文件，进行转化，得到我们yolo所需的标签文件！！

先放出相关转换的代码：

fiftyone_export_label.py

import csv
import os
import shutil

import cv2
import numpy as np


def create_path(path: str):
    if not os.path.exists(path):
        os.makedirs(path)


def delete_path(path: str):
    try:
        shutil.rmtree(path)
    except Exception as e:
        print("delete_path error")


def copy_path(src_dir: str, dst_dir):
    # 确保目标目录存在
    if not os.path.exists(dst_dir):
        os.makedirs(dst_dir)
    # 遍历源目录下的所有文件
    for src_file in os.listdir(src_dir):
        src_file_path = os.path.join(src_dir, src_file)
        # 只复制文件，忽略子目录
        if os.path.isfile(src_file_path):
            dst_file_path = os.path.join(dst_dir, src_file)
            shutil.copy2(src_file_path, dst_file_path)


# annotation_path = r"E:\workstation\python\resource_detected_friut_food\OpenImg\Cache\train\labels\detections_ces.csv"
# image_path = r"E:\workstation\python\resource_detected_friut_food\OpenImg\Cache\train\data"
# class_name_csv = r"E:\workstation\python\resource_detected_friut_food\OpenImg\Cache\train\metadata\classes.csv"
def train(annotation_path, image_path, class_name_csv, label_path, label_pos: int, filter_name: str):
    annotation_data = []
    with open(annotation_path, "r") as f:
        annotation_files = csv.reader(f)
        for data in annotation_files:
            annotation_data.append(data)
    images_name_list = os.listdir(image_path)
    images_path_list = [os.path.join(image_path, image_name) for image_name in images_name_list]

    classes_dict = {}
    with open(class_name_csv, "r") as f:
        annotation_files = csv.reader(f)
        for data in annotation_files:
            classes_dict[data[0]] = data[1]
    print(classes_dict)

    np.random.seed(12)
    np.random.shuffle(images_path_list)
    np.random.seed(12)
    np.random.shuffle(images_name_list)

    # <class_index> <x_center> <y_center> <width> <height>
    # <class_index>：对象的类别索引（从0开始）。
    # <x_center>、<y_center>：对象边界框中心相对于图像宽度和高度的坐标（范围通常在0到1之间）。
    # <width>、<height>：对象边界框的宽度和高度相对于图像宽度和高度的比例（范围通常在0到1之间）。

    def train_to_yolo_label(width: int, height: int, x1: float, y1: float, x2: float, y2: float):
        # 求中心点
        center_x = (x1 + (x2 - x1) / 2.0) / width
        center_y = (y1 + (y2 - y1) / 2.0) / height
        label_width = (x2 - x1) * 1.0 / width
        label_height = (y2 - y1) * 1.0 / height
        return [center_x, center_y, label_width, label_height]

    for i, image_path in enumerate(images_path_list):
        image_src = cv2.imread(image_path)
        image_name = images_name_list[i].split(".")[0]
        image_row = image_src.shape[0]
        image_col = image_src.shape[1]
        # print(f"width: {image_col}  height: {image_row}")
        # print(f"image_path: {image_path}")
        parts = image_name
        output_file_name = "".join(parts)
        # print(f"label_path: {label_path} output_file_name: {output_file_name}")
        out_file = open('%s/%s.txt' % (label_path, output_file_name), 'w')
        for image_annotation in annotation_data:
            if image_annotation[0] == image_name:
                x = float(image_annotation[4]) * image_col
                x2 = float(image_annotation[5]) * image_col
                y = float(image_annotation[6]) * image_row
                y2 = float(image_annotation[7]) * image_row
                class_name = classes_dict[image_annotation[2]]
                # print(f"x:{x} x2:{x2} y:{y} y2:{y2} class_name:{class_name} ")
                train_info = train_to_yolo_label(image_col, image_row, x, y, x2, y2)
                if class_name == filter_name:
                    train_txt = str(label_pos) + " " + " ".join([str(a) for a in train_info])
                    # print(f"train_txt:{train_txt} ")
                    out_file.write(train_txt + '\n')


# annotation_path = r"E:\workstation\python\resource_detected_friut_food\OpenImg\Cache\train\labels\detections_ces.csv"
# image_path = r"E:\workstation\python\resource_detected_friut_food\OpenImg\Cache\train\data"
# class_name_csv = r"E:\workstation\python\resource_detected_friut_food\OpenImg\Cache\train\metadata\classes.csv"

def start_train(label_csv_file: str, fifty_img_path: str, class_csv_file: str, label_pos: int, filter_name: str):
    cache_label_path = "cache-fifty-label/"
    cache_data_path = "cache-fifty-data/"
    delete_path(cache_label_path)
    delete_path(cache_data_path)
    create_path(cache_label_path)
    create_path(cache_data_path)
    # 复制数据到指定的目录
    copy_path(fifty_img_path, cache_data_path)
    train(label_csv_file, cache_data_path, class_csv_file, cache_label_path, label_pos, filter_name)
    print("finish")


if __name__ == '__main__':
    annotation_path = r"OpenImg\Cache\train\labels\detections_ces.csv"
    image_path = r"OpenImg\Cache\train\data"
    class_name_csv = r"OpenImg\Cache\train\metadata\classes.csv"
    start_train(annotation_path, image_path, class_name_csv, 0, "Apple")

fiftyone_tarin_detection.py

import csv
import os

from tqdm import tqdm

from fiftyone_export_label import start_train


# 标注文件路径
# csv_file_path = r"OpenImg\Cache\train\labels\detections.csv"
# 图像文件夹路径
# images_file_path = r"OpenImg\Cache\train\data"
# 保存标注文件路径
# data_annotation_csv = r"OpenImg\Cache\train\labels\detections_ces.csv"

# 从标注中，找出符合数据集合的标签csv文件
def inner_train(csv_file_path: str, images_file_path: str, data_annotation_csv: str):
    # 标注文件路径
    # 图像文件夹路径
    images_name = os.listdir(images_file_path)
    images_name = [x.split(".")[0] for x in images_name]
    # 保存标注文件路径
    with open(csv_file_path, 'r', encoding='utf-8') as f:
        with open(data_annotation_csv, "w", encoding='utf-8') as ff:
            csv_f = csv.reader(f)
            bar = tqdm(csv_f)
            for row in bar:
                if row[0] in images_name:
                    # print("get image {}".format(row[0]))
                    for index in range(len(row)):
                        ff.write(row[index])
                        if (index != (len(row) - 1)):
                            ff.write(",")
                    ff.write("\n")


if __name__ == '__main__':
    image_path = r"OpenImg\Cache\train\data"
    csv_file_path = r"OpenImg\Cache\train\labels\detections.csv"
    annotation_path = r"OpenImg\Cache\train\labels\detections_ces.csv"
    class_name_csv = r"OpenImg\Cache\train\metadata\classes.csv"
    inner_train(csv_file_path, image_path, annotation_path)
    start_train(annotation_path, image_path, class_name_csv, 5, "Lemon")

整理上述代码以后，直接执行fiftyone_tarin_detection.py即可。
注意：

    cache_label_path = "cache-fifty-label/"
    cache_data_path = "cache-fifty-data/"

执行完成后，就会多出这两个目录，其中data就是图片目录，lebel就是标签文件目录。同样的，执行结果是否正确，可以通过方法一中的验证脚本，进行验证。

---

上述就是两种自定义数据集下载的全部思路和代码，本文完毕。