darknet框架训练YOLOv7模型与工业缺陷检测

1. darkne介绍

　　Darknet 是一个开源的深度学习框架，由 Joseph Redmon(YOLO~YOLOv3作者或参与者) 开发，主要用于实现神经网络模型。这个框架最初是为了实现计算机视觉任务而创建的，尤其是目标检测。其中最著名的应用之一就是 YOLO（You Only Look Once）系列目标检测算法。

　　以下是 Darknet 的一些特点和重要信息：

  1. 轻量级： Darknet 是一个相对轻量级的框架，由 C 语言编写，运行速度快，并且不需要依赖其他的深度学习库。

  2. 灵活性： Darknet 具有良好的灵活性，可以用于构建各种类型的神经网络模型，包括卷积神经网络（CNN）、循环神经网络（RNN）等。

  3. YOLO 算法： 最初的 YOLO 目标检测算法是在 Darknet 框架上实现的。YOLO 系列算法以其快速、准确的特点而闻名，适用于实时目标检测任务。

  4. 支持多种数据类型： Darknet 支持处理图像、视频、声音等不同类型的数据，使其可以应用于多种领域。

  5. 开源： Darknet 是一个开源项目，其代码可以在 GitHub 上找到，并且可以自由使用和修改。

 　　截止到目前Darknet似乎只支持到YOLOV7。而目前YOLO最新系列为YOLOV9。

2. darkne官网与github仓库地址

　　Darknet官方网站:   https://pjreddie.com/darknet/

　　Darknet 的官方 GitHub 仓库: https://github.com/pjreddie/darknet

　　Darknet 的官方网站由 Darknet 的主要开发者之一 Joseph Redmon 维护。这个网站提供了关于 Darknet 框架的介绍、文档、示例以及下载链接等信息。Darknet 的官方 GitHub 仓库，也由 Joseph Redmon 维护。在这个仓库中，可以找到 Darknet 的源代码、问题追踪、贡献指南以及其他与开发相关的内容。

　　很受欢迎的非官方Github仓库: https://github.com/AlexeyAB/darknet

　　其是一个 Darknet 的修改版本的 GitHub 仓库，由 AlexeyAB 维护。这个仓库包含了一些对原始 Darknet 框架的改进和增强，特别是在 Windows 平台上的兼容性方面。AlexeyAB 的修改版本在社区中很受欢迎，因为它使得 Darknet 更容易在 Windows 上使用，并且添加了一些额外的功能和改进。虽然这不是 Darknet 的官方仓库，但它已经得到了很多人的使用和贡献。

3. Darknet项目主要目录及主要文件介绍

　　在github中下载好后，主要文件及主要文件夹介绍如下：

　　cfg文件夹:里面有很多模型的架构文件，包括下面要用到的yolov7-timy.cfg文件；

　　data文件夹:存放了一些示例图片；

　　include文件夹:存放了头文件，darknet.h是Darknet框架的主要头文件，这个头文件中定义了 Darknet 框架的主要函数和类，如创建神经网络、加载模型、进行目标检测等。开发者通常需要包含这个头文件来使用 Darknet 框架提供的功能;

　　cmake文件夹:存放构建系统相关的文件;

　　build文件夹:通常用于存放编译过程中生成的中间文件、编译结果以及其他与构建过程相关的文件；

　　scripts文件夹:通常用于存放一些脚本文件，这些脚本文件可能包含了一些辅助性的任务或者工具，用于项目的构建、测试、部署或者其他相关操作。如将VOC格式数据转换为yolo训练的格式脚本;

　　src文件夹:src 文件夹通常是用于存放源代码文件的目录。这些源代码文件包含了 Darknet 框架的实现代码，其中定义了各种函数、类、结构体等，用于实现 Darknet 框架提供的功能和特性;

　　Makefile文件:Makefile 主要负责编译 Darknet 框架的源代码，生成可执行文件。它定义了 Darknet 框架的编译规则和依赖关系，以及编译参数和选项;

　　darknet.py文件:Darknet 框架的主要 Python 接口脚本，其中包含了与 Darknet C 代码进行交互的函数和类。这些函数和类允许在 Python 中加载 Darknet 模型、进行目标检测、处理图像和视频等操作;

　　darknet_images.py文件:用于在 Python 中进行图像目标检测的示例脚本。它使用了 darknet.py 中定义的函数和类，加载 Darknet 模型，并对输入的图像进行目标检测。这个脚本可以用于批量处理图像文件。

　　darknet_video.py文件:用于在 Python 中进行视频目标检测的示例脚本。它使用了 darknet.py 中定义的函数和类，加载 Darknet 模型，并对输入的视频进行逐帧目标检测。这个脚本可以用于实时目标检测或者批量处理视频文件。

4. Makefile文件配置

　　在Makefile文件中，前面几行内容如下:

GPU=1
CUDNN=1
CUDNN_HALF=0
OPENCV=1
AVX=0
OPENMP=0
LIBSO=0
ZED_CAMERA=0
ZED_CAMERA_v2_8=0

　　各项解释如下：

  1. GPU=1：启用 GPU 支持，设置为 1 表示启用，设置为 0 表示禁用。

  2. CUDNN=1：启用 cuDNN 支持，设置为 1 表示启用，设置为 0 表示禁用。

  3. CUDNN_HALF=0：启用 cuDNN 半精度（16-bit）支持，设置为 1 表示启用，设置为 0 表示禁用。

  4. OPENCV=1：启用 OpenCV 支持，用于读取和处理图像，设置为 1 表示启用，设置为 0 表示禁用。

  5. AVX=0：启用 AVX 指令集优化，设置为 1 表示启用，设置为 0 表示禁用。适用于 Intel 处理器。

  6. OPENMP=0：启用 OpenMP 并行化支持，设置为 1 表示启用，设置为 0 表示禁用。

  7. LIBSO=0：生成动态链接库文件，设置为 1 表示生成，设置为 0 表示不生成。

  8. ZED_CAMERA=0：启用 ZED 相机支持，设置为 1 表示启用，设置为 0 表示禁用。

  9. ZED_CAMERA_v2_8=0：启用 ZED 相机 v2.8 支持，设置为 1 表示启用，设置为 0 表示禁用。

　　一般常常配置的有GPU=1，使用GPU加速。还有OPENCV=1，Darknet 将会使用 OpenCV 库来读取和处理、显示保存预测框图像。如果设置为0，只能得到预测的坐标框的结果数据。也就是说最好是安装opencv。

5. Windows环境下Darknet环境搭建及编译

　　在第3步中下载完项目后，只有源代码，并不能直接使用命令训练我们的数据。因为缺少darknet.exe这个文件。需要编译得到darknet.exe，关于windows下的编译，网上方式有多种，可以参考文章最后面的链接的一种方式，由于配置过程中遇到的问题比较多，弄了很久才解决的，且解决办法没有及时截图记录下来，所以这里暂时不作讲解。

　　如果不想看连接配置视频，也可以访问https://github.com/AlexeyAB/darknet，里面有与视频配置一样的步骤，这里不详述。后面再补充。

6. Ubuntu环境下Darknet环境搭建及编译

　　后面再配置时再补充。

7. 判断环境是否搭建好

　　如果前面环境搭建好了，编译也生成了darknet可执行程序，windows中在含有应用程序darknet.exe的目录，输入如下命令（权重参数下载后面会给出）就可以测试

darknet detector test cfg/coco.data cfg/yolov4.cfg  cfg/yolov4.weights -i 0 -thresh 0.6 dog.jpg -ext_output

　　如果是linux，如下:

./darknet detector test cfg/coco.data cfg/yolov4.cfg  cfg/yolov4.weights -i 0 -thresh 0.6 dog.jpg -ext_output

　　因为其训练了coco数据集，所以会出来下图，表明测试用例正常了。并会保存为predictions.jpg

 　　关于上述命令：解释如下：

  • "./darknet"：Darknet框架的执行文件
  • "detector test"：进行目标检测
  • "cfg/coco.data"：COCO数据集的配置文件
  • "cfg/yolov4.cfg"：YOLOv4模型的配置文件
  • "cfg/yolov4.weights"：YOLOv4模型的权重文件
  • "-i 0"：指定GPU编号为0
  • "-thresh 0.6"：指定目标检测的置信度阈值为0.6
  • "dog.jpg"：要进行目标检测的图像文件
  • "-ext_output"：输出扩展信息，例如边界框的坐标和置信度

 　　也可以输入以下简单命令测试(默认置信度阈值为0.5，不输出检测框的信息):

./darknet detector test cfg/coco.data cfg/yolov4.cfg cfg/yolov4.weights dog.jpg

　　除了yolov4外，也可以使用其他yolo系列版本测试,cfg与.weights文件对应就可以了。

8. YOLO的cfg网络结构文件与.weights权重参数文件

　　cfg文件包含了网络的结构信息，包括层的类型、参数设置、网络的结构等。在Darknet中，YOLO的cfg文件定义了网络的架构和超参数。超参数信息如下：

[net]
# Testing
#batch=1
#subdivisions=1
# Training
batch=64
subdivisions=1
width=416
height=416
channels=3
momentum=0.9
decay=0.0005
angle=0
saturation = 1.5
exposure = 1.5
hue=.1

learning_rate=0.00261
burn_in=1000

max_batches = 2000200
policy=steps
steps=1600000,1800000
scales=.1,.1

　　各项解释如下:

  • batch=64：每个训练迭代中使用的图像数目。在这里，每个迭代使用64张图像进行训练。
  • subdivisions=1：将batch分成subdivisions个小批次进行训练。在这里，每个batch大小为64，subdivisions为1，所以整个batch将一次性用于训练。
  • width=416, height=416：输入图像的宽度和高度。在这里，网络接受大小为416x416的输入图像。
  • learning_rate=0.00261：初始学习率。网络在训练过程中使用的学习率，用于更新网络参数。
  • burn_in=1000：热身阶段的迭代次数。在热身阶段，学习率会逐渐增加，以帮助网络更快地收敛。
  • max_batches=2000200：总的训练迭代次数。网络将在这么多次迭代后停止训练。
  • policy=steps：学习率下降策略。在这里，使用的是steps策略，即在训练的特定迭代步骤时降低学习率。
  • steps=1600000,1800000：学习率下降的步骤。在第1600000和1800000次迭代时，学习率会按照scales指定的比例进行下降。
  • scales=.1,.1：学习率下降的比例。在steps指定的迭代次数时，学习率会按照这里指定的比例进行下降。

　　如果是训练，就注释Testing,测试就注释Trainging部分。另外width与height为网络的输入大小，根据自己图片的实际尺寸自己调整，训练时，如果实际图片大小与设置的width,height不同，darknet框架训练时会自动将图片缩放成这个设置的大小，所以一般这个大小尽量与实际大小相差不大，另外width与height得是32的倍数，否则可能会出现报错。

　　除了上述配置外，网络结构部分只需要改变几个地方的filters，将cfg文件中所有[yolo]上方的最近的filters其改为

　　filters = (classes + 5) * anchors=(标签的类别数+5)*3

　　[yolo]中的classes改为类别数。

　　上面的5表示每个anchor框对应5个参数（中心坐标、宽度、高度和目标置信度），3表示3个anchor框。

9. 预训练权重文件下载

　　这里只介绍darknet的某些预训练权重文件.weights文件下载。

　　https://pjreddie.com/darknet/yolov2/
　　https://pjreddie.com/media/files/yolov2.weights
　　https://pjreddie.com/media/files/yolov2-tiny.weights
　　https://pjreddie.com/media/files/yolov3-tiny.weights
　　https://github.com/AlexeyAB/darknet/releases/download/darknet_yolo_v3_optimal/yolov4.weights
　　https://github.com/AlexeyAB/darknet/releases/download/yolov4/yolov7.weights
　　https://github.com/AlexeyAB/darknet/releases/download/yolov4/yolov7x.weights
　　https://github.com/AlexeyAB/darknet/releases/download/yolov4/yolov7-tiny.weights

10. 制作数据集

　　这里打开labelimg（安装网上都有，这里不介绍）,选择YOLO格式，可以直接训练，不需要再处理。如果选择PascalVOC格式，则需要再处理。

　　标注好后，标注的每个图片会生成.txt文件标签，，里面的每一行有5个数，表示一个矩形标注信息，这5个数分别代表类别，边界框中心的x和y坐标，以及边界框的宽度和高度。x,y,w,h都是归一化后的,看作比例，也就是将图片宽高看作1。比如：0 0.363285 0.439189 0.109200 0.243243

　　注意，对于没有目标的图片，我们不需要标注，但是如果加入训练，就需要制作一个空白的txt标签文件。这里提供了python代码，将没有标注过的图片生成对应的空白txt文件。

import os
def create_empty_txt_files(folder_path):
    # 获取文件夹中所有图片文件的列表
    image_files = [f for f in os.listdir(folder_path) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp'))]
    for image_file in image_files:
        # 生成对应的 txt 文件名
        txt_file = os.path.splitext(image_file)[0] + '.txt'
        # 生成完整的路径
        txt_file_path = os.path.join(folder_path, txt_file)
        # 如果对应的 txt 文件不存在，则创建空白的 txt 文件
        if not os.path.exists(txt_file_path):
            open(txt_file_path, 'w').close()

if __name__ == "__main__":
    # 替换成你的图片文件夹路径
    folder_path = r'E:\2024\train_data'
    create_empty_txt_files(folder_path)

　　至此，得到了要训练的数据集，也就是一个文件夹（图片与对应标注的txt文件）。

11. 划分训练集与测试集

　　上面已经制作好了数据集，但是还未对数据集进行划分

import os
import random

def split_train_test(image_folder, train_ratio=0.8):
    # 获取所有图片文件路径
    image_files = [os.path.join(image_folder, file) for file in os.listdir(image_folder) if file.endswith(('.jpg', '.jpeg', '.png'))]
    # 随机打乱图片文件列表
    random.shuffle(image_files)
    # 计算划分点
    split_index = int(len(image_files) * train_ratio)
    # 划分训练集与测试集
    train_files = image_files[:split_index]
    test_files = image_files[split_index:]
    return train_files, test_files

def save_to_txt(file_path, data):
    with open(file_path, 'w') as file:
        file.write('\n'.join(data))

def main():
    # 设置图片文件夹路径和划分比例
    image_folder = r'E:\2024\train_data'#前面制作好的数据集,存放有图片与txt
    train_ratio = 0.8  # 训练集比例，例如80%
    # 划分训练集与测试集
    train_files, test_files = split_train_test(image_folder, train_ratio)
    # 保存训练集与测试集文件路径到 train.txt 与 test.txt
    save_to_txt(r'E:\2024\train.txt', train_files)
    save_to_txt(r'E:\2024\test.txt', test_files)
    #print(f"Train set: {len(train_files)} images")
    #print(f"Test set: {len(test_files)} images")

if __name__ == "__main__":
    main()

　　除了上面的划分，还可以使用sklearn.model_selection中的train_test_split函数进行划分。如下：

import os
from sklearn.model_selection import train_test_split

def split_and_create_txt_files(folder_path, train_ratio=0.8, val_ratio=0.1, test_ratio=0.1):
    # 获取文件夹中所有图片文件的列表
    image_files = [f for f in os.listdir(folder_path) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp'))]

    # 随机划分数据集
    train_files, test_val_files = train_test_split(image_files, test_size=(val_ratio + test_ratio), random_state=42)
    val_files, test_files = train_test_split(test_val_files, test_size=(test_ratio / (val_ratio + test_ratio)),
                                             random_state=42)

    # 生成对应的 txt 文件
    create_txt_file(train_files, 'train.txt', folder_path)
    create_txt_file(val_files, 'val.txt', folder_path)
    create_txt_file(test_files, 'test.txt', folder_path)

def create_txt_file(files, file_name, folder_path):
    with open(file_name, 'w') as txt_file:
        for file in files:
            # 写入图片的完整路径到 txt 文件
            txt_file.write(os.path.join(folder_path, file) + '\n')

if __name__ == "__main__":
    # 替换成你的图片文件夹路径
    folder_path = r'E:\2024\train_data'
    # 按照8:1:1划分并生成txt文件
    split_and_create_txt_files(folder_path)

12. 参数配置文件

　　12.1. .cfg配置文件

　　前面的cfg文件中超参数配置已经介绍过了，比较重要的是width与height，这个参数我们要看自己的数据集（每张图大小最好都差不多）大概是多少，既要保证是32的倍数，也尽可能设置的与原图大小一致或接近。也就是说width与height（width与height不一定相等）是网络的输入尺寸，原图会经过darknet程序缩放成width,height大小，然后输入网络。其他超参数自己根据需要调节。

　　网络结构的调节中，我们一般不修改网络结构，而只是根据自己标注的类别数进行配置。具体为将cfg文件中每个[yolo]上方的filters改为filters = (classes + 5) * anchors=(标签的类别数+5)*3，如果只标注了一个类别就是18;classes改为类别数，一个类别就是1。至于为什么这么配置，可以去看一下yolo的网络结构。比如其中的一个filters：

[convolutional]
size=1
stride=1
pad=1
filters=18
#activation=linear
activation=logistic

[yolo]
mask = 0,1,2
anchors = 10,13, 16,30, 33,23, 30,61, 62,45, 59,119, 116,90, 156,198, 373,326
classes=1
num=9
jitter=.1

　　修改所有[yolo]上方的最近的filters与下面的classes以后，cfg就配置完成了。

　　12.2. .data配置文件

　　通过以上，我们有了cfg文件，预训练权重.weight文件（不是必须的，一般加上,加快收敛），此时还差数据配置.data文件。结构如下:

classes = 1
train  = E:/2024/yolov7_data_train/train.txt
valid  = E:/2024/yolov7_data_train/val.txt
names= E:/2024/yolov7_data_train/classes.names
backup = E:/2024/yolov7_data_train/backup

　　各项解释如下:

  • classes = 1：指定了数据集中要检测的类别数量。在这里，classes 被设置为1，表示数据集中只有一个类别。

  • train = E:/2024/yolov7_data_train/train.txt：指定了包含训练图像路径的文本文件的路径。这个文件通常包含了每张图像的路径，每一行一个路径，这个文件前面划分数据集得到。

  • valid = E:/2024/yolov7_data_train/val.txt：指定了包含验证图像路径的文本文件的路径。这个文件也是类似于 train.txt，包含了验证集中每张图像的路径，这个文件前面划分数据集得到。

  • names = E:/2024/yolov7_data_train/classes.names：指定了包含类别名称的文本文件的路径。这个文件包含了每个类别的名称，每一行一个名称。

  • backup = E:/2024/yolov7_data_train/backup：指定了模型权重文件（.weights）保存的目录。在训练过程中，模型的权重会被定期保存到这个目录中，以便在训练过程中或训练完成后进行检查点保存和恢复。

　　上面有个classes.names，打开后就是每一行一个名称，注意与你标注的yolo数字类别一一对应。比如数字类别0就对应classes.names中的第一行英文类别名称，以此类推。

13. 训练

　　我这里选择yolov7-tiny模型,在cmd中进入应用程序darknet(windwows为darknet.exe)所在目录，windows训练使用如下命令:

darknet detector train  E:/yolov7_tiny.data E:/yolov7-tiny.cfg E:/yolov7-tiny.weights

　　linux命令为

./darknet detector train  E:/yolov7_tiny.data E:/yolov7-tiny.cfg E:/yolov7-tiny.weights

　　训练感觉可以了可以自己停止，或者等到迭代次数达到cfg配置的值后停止。

14. 测试

　　先注释Training，修改成Testing。如下:

[net]
# Testing
batch=1
subdivisions=1
# Training
#batch=64
#subdivisions=1

　　测试与前面测试狗子图一致，命令如下:

darknet detector test E:/yolov7_tiny.data E:/yolov7-tiny.cfg E:/2024/yolov7_data_train/backup/yolov7-tiny_final.weights -i 0 -thresh 0.5 E:/test.jpg -ext_output

　　backup中有多个，不一定用yolov7-tiny_final.weights，哪个效果好用哪个,test.jpg，是要测试的图片，-i 0表示使用第一个GPU。-ext_output会输出检测框的大小与坐标信息。这里注意，还记得前面我们设置了width与height。这里输出的坐标信息是经过调整后还原到原图的坐标框信息，不是指网络的检测框坐标，所以不用担心坐标还原问题。

　　这里简单放一个训练以后，工业缺陷检测测试的效果。

15. python程序测试

　　相信大家都不喜欢这种方式测试，如果是使用python程序，该怎么接入训练的.weight权重呢？文章前面提到过，在下载的darknet项目中有个darknet.py文件，利用它可以实现程序测试。

　　在darknet.py文件中，有段代码如下:

if os.name == "posix":
    cwd = os.path.dirname(__file__)
    lib = ct.CDLL(cwd + "/libdarknet.so", ct.RTLD_GLOBAL)
elif os.name == "nt":
    cwd = os.path.dirname(__file__)
    os.environ["PATH"] = os.path.pathsep.join((cwd, os.environ["PATH"]))
    lib = ct.CDLL("darknet.dll", winmode = 0, mode = ct.RTLD_GLOBAL)
else:
    lib = None  # Intellisense
    print("Unsupported OS")
    exit()

　　这个代码表明，如果是windows系统就加载darknet.dll动态链接库，如果是linux就加载libdarknet.so动态链接库。darknet动态链接库是源码编译得到的，如果前面环境配置好了，windows就该有darknet.dll包含了 Darknet 框架的核心功能和实现，包括神经网络模型的定义、训练和推理等功能。

　　我们可以直接,训练好的模型，最简单的方法就是直接在darknet-master中运行darknet_images.py(前面提到过的)这个文件。关于这个文件配置信息的部分下面给出：

def parser():
    parser = argparse.ArgumentParser(description="YOLO Object Detection")
    parser.add_argument("--input", type=str, default="",
                        help="image source. It can be a single image, a"
                        "txt with paths to them, or a folder. Image valid"
                        " formats are jpg, jpeg or png."
                        "If no input is given, ")
    parser.add_argument("--batch_size", default=1, type=int,
                        help="number of images to be processed at the same time")
    parser.add_argument("--weights", default="yolov4.weights",
                        help="yolo weights path")
    parser.add_argument("--dont_show", action='store_true',
                        help="windown inference display. For headless systems")
    parser.add_argument("--ext_output", action='store_true',
                        help="display bbox coordinates of detected objects")
    parser.add_argument("--save_labels", action='store_true',
                        help="save detections bbox for each image in yolo format")
    parser.add_argument("--config_file", default="./cfg/yolov4.cfg",
                        help="path to config file")
    parser.add_argument("--data_file", default="./cfg/coco.data",
                        help="path to data file")
    parser.add_argument("--thresh", type=float, default=.25,
                        help="remove detections with lower confidence")
    return parser.parse_args()

　　将上述红色标注的配置文件换成自己的就行了，最后运行会出现如下：

...... 
 158 conv    512       1 x 1/ 1     19 x  19 x1024 ->   19 x  19 x 512 0.379 BF
 159 conv   1024       3 x 3/ 1     19 x  19 x 512 ->   19 x  19 x1024 3.407 BF
 160 conv    255       1 x 1/ 1     19 x  19 x1024 ->   19 x  19 x 255 0.189 BF
 161 yolo
[yolo] params: iou loss: ciou (4), iou_norm: 0.07, obj_norm: 1.00, cls_norm: 1.00, delta_norm: 1.00, scale_x_y: 1.05
Total BFLOPS 128.459 
avg_outputs = 1068395 
Loading weights from yolov4.weights...nms_kind: greedynms (1), beta = 0.600000 
 Try to load weights: yolov4.weights 

 seen 64, trained: 32032 K-images (500 Kilo-batches_64) 
Done! Loaded 162 layers from weights-file 
Loaded - names_list: data/coco.names, classes = 80 
Enter Image Path: 这里输入图片路径

　　也就是最后出现了Enter Image Path: 然后我们将图片路径输入到这个地方就能对图片进行预测了。运行后会弹出一个带预测框的预测图。可是，并没有打印坐标之类的，不急，继续往下看。

16. windows下自己编写python程序测试

　　在上面的程序中，是在原始daknet项目darknet-master中测试的，如果要加入自己项目，把整个darknet-master放到自己项目让人感觉到不爽。下面介绍自己编写程序测试。首先我们需要把darknet-master(前提是已经编译好了)中的darknet.dll与pthreadVC2.dll文件(pthreadVC2.dl与POSIX 线程相关)及darknet.py单独拿出来放在自己的项目中（这里说的是windows系统，需要darknet.dll与pthreadVC2.dll，如果是ubuntu,libdarknet.so应该就可以了）。然后在自己的项目中编写一个简单的程序就能运用自己训练的.weights权重进行预测了。代码如下：

import cv2
import darknet #这里导入的就是darknet.py
from darknet_images import image_detection #darknet_images.py里的image_detection函数，可以自己单独拿出来使用，因为这个函数是调用了darknet.py里面的函数或者直接把darknet_images.py放到自己项目中
cfg_path=r'./yolov4.cfg'
weights_path=r'./yolov4.weights'
data_path=r'./coco.data'
image_path=r'./images/dog.jpg'

image=cv2.imread(image_path,cv2.IMREAD_UNCHANGED)
network, class_names, class_colors = darknet.load_network(cfg_path,data_path,weights_path,batch_size=1)
rgb_img,detections=image_detection(image_path, network, class_names, class_colors, 0.5)#BGR???
cv2.imwrite('./rgb_image.png',rgb_img)#直接保存就可以了，不需要转BGR，这里保存后图是正常的。图是带检测结果框的图。
print(detections)#输出检测信息如下,输出的是原图的信息，分别是物体类别,置信度,检测框中心点坐标及宽高
'''
[('dog', '86.17', (155.87567138671875, 430.31817626953125, 316.5921325683594, 353.9104919433594)),
('person', '92.19', (493.63946533203125, 246.59573364257812, 238.42356872558594, 475.4678649902344)),
('bowl', '97.84', (436.1259765625, 230.2063446044922, 125.04444885253906, 135.35476684570312))]
'''

　　上面的.cfg,.weights,.data大家配置成自己的就可以了。最后这个图，我也贴上。

　　小结:本文并未对darknet环境编译及配置进行说明，也未对yolo网络结构进行详细解释与说明，后期会补上。在模型选择中，我选择了Yolov7-tiny这个模型，其是Yolov7的轻量级版本。另外，文章最后给出了windows下最简单的测试，希望能帮助到大家，更多功能函数大家可以阅读darknet项目自带的darkent.py代码。最后，在windows系统中，我们需要darknet.dll与pthreadVC2.dll及darknet.py来实现自己的模型检测代码。

　　

　　若有不足之处，欢迎评论与指正。若觉得有用，请点个赞!

 

参考资料:

https://www.cnblogs.com/embedded-linux/p/12374634.html

https://www.bilibili.com/video/BV1HZ4y1s7YF/?spm_id_from=333.337.search-card.all.click(windows下darknet编译视频)

https://zhuanlan.zhihu.com/p/45845454

 

posted @ 2024-03-29 17:16  wancy  阅读(51)  评论(0)  编辑  收藏  举报