适用于Windows和Linux的Yolo-v4 使用方法（中文版使用手册）

 

适用于Windows和Linux的Yolo-v4和Yolo-v3 / v2 ---- （用于对象检测的神经网络）-Tensor Core可以在Linux和Windows上使用

Paper Yolo v4：https://arxiv.org/abs/2004.10934

更多详细信息：http://pjreddie.com/darknet/yolo/

关于pytorch，可加群857449786 注明（pytorch）

Tensorflow 深度学习实战群 755860371 共同学习，谢谢

 

• 要求（以及如何安装依赖项）
• 预训练模型
• 问题说明
• 其他框架中的Yolo v3（TensorRT，TensorFlow，PyTorch，OpenVINO，OpenCV-dnn，TVM等）
• 数据集

1. 该存储库中的改进
2. 如何使用
3. 如何在Linux上编译
   • 使用cmake
   • 使用make
4. 如何在Windows上编译
   • 使用CMake-GUI
   • 使用vcpkg
   • 传统方式
5. 对MS COCO进行速度和准确性的培训和评估
6. 如何使用多GPU进行训练：
7. 如何训练（检测您的自定义对象）
8. 如何训练tiny-yolo（检测您的自定义对象）
9. 我什么时候应该停止训练
10. 如何改善物体检测
11. 如何标记对象的有界框并创建注释文件
12. 如何将Yolo用作DLL和SO库

• Yolo v4完整比较：map_fps
• CSPNet：纸张和map_fps比较：https://github.com/WongKinYiu/CrossStagePartialNetworks
• MS COCO上的Yolo v3：速度/准确度（[email protected]）图表
• MS COCO上的Yolo v3（Yolo v3 vs RetinaNet）-图3：https://hsto.org/files/a24/21e/068/a2421e0689fb43f08584de9d44c2215f.jpg
• Yolo v2 on Pascal VOC 2012 (comp4): https://hsto.org/files/3a6/fdf/b53/3a6fdfb533f34cee9b52bdd9bb0b19d9.jpg

How to evaluate AP of YOLOv4 on the MS COCO evaluation server

1. Download and unzip test-dev2017 dataset from MS COCO server: http://images.cocodataset.org/zips/test2017.zip
2. Download list of images for Detection taks and replace the paths with yours: https://raw.githubusercontent.com/AlexeyAB/darknet/master/scripts/testdev2017.txt
3. Download yolov4.weights file: https://drive.google.com/open?id=1cewMfusmPjYWbrnuJRuKhPMwRe_b9PaT
4. Content of the file cfg/coco.data should be

classes= 80
train  = /trainvalno5k.txt
valid = /testdev2017.txt
names = data/coco.names
backup = backup
eval=coco 

1. Create /results/ folder near with ./darknet executable file
2. Run validation: ./darknet detector valid cfg/coco.data cfg/yolov4.cfg yolov4.weights
3. Rename the file /results/coco_results.json to detections_test-dev2017_yolov4_results.json and compress it to detections_test-dev2017_yolov4_results.zip
4. Submit file detections_test-dev2017_yolov4_results.zip to the MS COCO evaluation server for the test-dev2019 (bbox)

How to evaluate FPS of YOLOv4 on GPU

1. Compile Darknet with GPU=1 CUDNN=1 CUDNN_HALF=1 OPENCV=1 in the Makefile (or use the same settings with Cmake)
2. Download yolov4.weights file 245 MB: yolov4.weights (Google-drive mirror yolov4.weights )
3. Get any .avi/.mp4 video file (preferably not more than 1920x1080 to avoid bottlenecks in CPU performance)
4. Run one of two commands and look at the AVG FPS:

• include video_capturing + NMS + drawing_bboxes: ./darknet detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights test.mp4 -dont_show -ext_output
• exclude video_capturing + NMS + drawing_bboxes: ./darknet detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights test.mp4 -benchmark

Pre-trained models

There are weights-file for different cfg-files (trained for MS COCO dataset):

FPS on RTX 2070 (R) and Tesla V100 (V):

• yolov4.cfg - 245 MB: yolov4.weights (Google-drive mirror yolov4.weights ) paper Yolo v4 just change width= and height= parameters in yolov4.cfg file and use the same yolov4.weights file for all cases:

  • width=608 height=608 in cfg: 65.7% [email protected] (43.5% [email protected]:0.95) - 34(R) FPS / 62(V) FPS - 128.5 BFlops
  • width=512 height=512 in cfg: 64.9% [email protected] (43.0% [email protected]:0.95) - 45(R) FPS / 83(V) FPS - 91.1 BFlops
  • width=416 height=416 in cfg: 62.8% [email protected] (41.2% [email protected]:0.95) - 55(R) FPS / 96(V) FPS - 60.1 BFlops
  • width=320 height=320 in cfg: 60% [email protected] ( 38% [email protected]:0.95) - 63(R) FPS / 123(V) FPS - 35.5 BFlops

• yolov3-微小-prn.cfg - 33.1％[email protected] - 370（R）FPS - 3.5 BFlops - 18.8 MB：yolov3-微小-prn.weights

• ENET-coco.cfg（EfficientNetB0-Yolov3） - 45.5％[email protected] - 55（R）FPS - 3.7 BFlops - 18.3 MB：enetb0-coco_final.weights

• yolov3-openimages.cfg -247 MB​​-18（R）FPS-OpenImages数据集：yolov3-openimages.weights

单击我 -Yolo v3型号

单击我 -Yolo v2型号

放到编译后：darknet.exe

您可以通过以下路径获取cfg文件： darknet/cfg/

要求

• Windows或Linux
• CMake> = 3.8对于现代CUDA支持：https://cmake.org/download/
• CUDA 10.0：https://developer.nvidia.com/cuda-toolkit-archive（在Linux上执行安装后操作）
• OpenCV> = 2.4：使用您首选的软件包管理器（棕色，apt），使用vcpkg从源代码构建或从OpenCV官方网站下载（在Windows上，设置系统变量OpenCV_DIR= C:\opencv\build- include和x64文件夹图像）
• CUD 10.0的cuDNN> = 7.0 https://developer.nvidia.com/rdp/cudnn-archive（在Linux副本上cudnn.h，libcudnn.so...如此处所述https://docs.nvidia.com/deeplearning/sdk/cudnn-install /index.html#installlinux-tar上的Windows拷贝cudnn.h，cudnn64_7.dll，cudnn64_7.lib这里desribed https://docs.nvidia.com/deeplearning/sdk/cudnn-install/index.html#installwindows）
• CC> = 3.0的GPU：https://en.wikipedia.org/wiki/CUDA#GPUs_supported
• 在Linux GCC或Clang上，在Windows MSVC 2015/2017/2019 https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community

其他框架中的Yolo v3

• TensorFlow：转换yolov3.weights/ cfg文件yolov3.ckpt/ pb/meta：使用mystic123或jinyu121项目，TensorFlow -精简版
• 英特尔OpenVINO 2019 R1：（Myriad X / USB神经计算棒/ Arria FPGA）：阅读本手册
• OpenCV-dnn是CPU（x86 / ARM-Android）最快的实现，OpenCV可以使用OpenVINO后端进行编译以在（Myriad X / USB Neural Compute Stick / Arria FPGA）上运行，与yolov3.weights/ cfg配合使用：C ++示例或Python示例
• PyTorch> ONNX> CoreML> iOS如何将cfg / weights-files转换为pt-file：ultralytics / yolov3和iOS App
• TensorRT for YOLOv3 (-70% faster inference): Yolo is natively supported in DeepStream 4.0 read PDF
• TVM - compilation of deep learning models (Keras, MXNet, PyTorch, Tensorflow, CoreML, DarkNet) into minimum deployable modules on diverse hardware backends (CPUs, GPUs, FPGA, and specialized accelerators): https://tvm.ai/about
• OpenDataCam - It detects, tracks and counts moving objects by using Yolo: https://github.com/opendatacam/opendatacam#-hardware-pre-requisite
• Netron - Visualizer for neural networks: https://github.com/lutzroeder/netron

Datasets

• MS COCO: use ./scripts/get_coco_dataset.sh to get labeled MS COCO detection dataset
• OpenImages: use python ./scripts/get_openimages_dataset.py for labeling train detection dataset
• Pascal VOC：python ./scripts/voc_label.py用于标记Train / Test / Val检测数据集
• ILSVRC2012（ImageNet分类）：使用./scripts/get_imagenet_train.sh（也imagenet_label.sh用于标记有效集）
• 用于检测的德语/比利时/俄罗斯/ LISA / MASTIF交通标志数据集-使用此解析器：https://github.com/angeligareta/Datasets2Darknet#detection-task
• 其他数据集列表：https://github.com/AlexeyAB/darknet/tree/master/scripts#datasets

结果示例

其他：https://www.youtube.com/user/pjreddie/videos

该存储库中的改进

• 增加了对Windows的支持
• 添加了最新模型：CSP，PRN，EfficientNet
• 添加的层：[conv_lstm]，[scale_channels] SE / ASFF / BiFPN，[local_avgpool]，[sam]，[Gaussian_yolo]，[reorg3d]（固定的[reorg]），固定的[batchnorm]
• 添加了训练循环模型（具有conv-lstm [conv_lstm]/ conv-rnn层[crnn]）以精确检测视频的功能
• 添加了数据扩充：[net] mixup=1 cutmix=1 mosaic=1 blur=1。添加的激活：SWISH，MISH，NORM_CHAN，NORM_CHAN_SOFTMAX
• 增加了使用CPU-RAM进行GPU处理训练的能力，以增加mini_batch_size和准确性（而非批处理规范同步）
• 如果使用此XNOR-net模型训练自己的权重（位1推断），则在CPU和GPU上的二进制神经网络性能将提高2到4倍的检测速度：https://github.com/AlexeyAB/darknet/blob/master /cfg/yolov3-tiny_xnor.cfg
• 通过将2层融合到1个卷积+批范数中，将神经网络性能提高了7％左右
• 改进的性能：如果在或中定义了Tensor Core，则在GPU Volta / Turing（Tesla V100，GeForce RTX等）上检测2倍，CUDNN_HALFMakefiledarknet.sln
• 改进了FullHD的性能约1.2倍，4K的性能约2倍，使用darknet detector demo... 可以检测视频（文件/流）
• 性能提高了3.5倍的数据增强进行训练（使用OpenCV SSE / AVX功能而不是手写功能）-消除了在多GPU或GPU Volta上进行训练的瓶颈
• 使用AVX改进了对Intel CPU的检测和训练性能（Yolo v3?85 ％）
• 在调整网络大小时优化内存分配 random=1
• 优化的GPU初始化以进行检测-我们最初使用batch = 1，而不是使用batch = 1重新初始化
• 使用命令添加了正确的mAP，F1，IoU，Precision-Recall计算darknet detector map...
• -map在训练过程中添加了平均损耗和准确度mAP（标志）图表
• ./darknet detector demo ... -json_port 8070 -mjpeg_port 8090作为JSON和MJPEG服务器运行，以使用软件或Web浏览器通过网络在线获取结果
• 增加了训练锚的计算
• 添加了检测和跟踪对象的示例：https://github.com/AlexeyAB/darknet/blob/master/src/yolo_console_dll.cpp
• 如果使用了不正确的cfg文件或数据集，则为运行时提示和警告
• 许多其他代码修复...

并添加了手册- 如何训练Yolo v4-v2（以检测您的自定义对象）

另外，您可能对使用简化的存储库感兴趣，该存储库中已实现INT8量化（+ 30％的加速和-1％的mAP降低）：https://github.com/AlexeyAB/yolo2_light

如何在命令行上使用

在Linux上，请使用./darknet代替darknet.exe，例如：./darknet detector test ./cfg/coco.data ./cfg/yolov4.cfg ./yolov4.weights

在Linux上./darknet，在根目录中找到可执行文件，而在Windows上，在目录中找到可执行文件。\build\darknet\x64

• Yolo v4 COCO- 图片：darknet.exe detector test cfg/coco.data cfg/yolov4.cfg yolov4.weights -thresh 0.25
• 输出对象的坐标：darknet.exe detector test cfg/coco.data yolov4.cfg yolov4.weights -ext_output dog.jpg
• Yolo v4 COCO- 视频：darknet.exe detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights -ext_output test.mp4
• Yolo v4 COCO- WebCam 0：darknet.exe detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights -c 0
• 用于网络摄像机的 Yolo v4 COCO-智能网络摄像头：darknet.exe detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights http://192.168.0.80:8080/video?dummy=param.mjpg
• Yolo v4-保存结果视频文件res.avi：darknet.exe detector demo cfg/coco.data cfg/yolov4.cfg yolov4.weights test.mp4 -out_filename res.avi
• Yolo v3 Tiny COCO-视频：darknet.exe detector demo cfg/coco.data cfg/yolov3-tiny.cfg yolov3-tiny.weights test.mp4
• JSON和MJPEG服务器，允许来自您的软件浏览器或Web浏览器ip-address:8070和8090的多个连接：./darknet detector demo ./cfg/coco.data ./cfg/yolov3.cfg ./yolov3.weights test50.mp4 -json_port 8070 -mjpeg_port 8090 -ext_output
• GPU＃1上的 Yolo v3 Tiny ：darknet.exe detector demo cfg/coco.data cfg/yolov3-tiny.cfg yolov3-tiny.weights -i 1 test.mp4
• 替代方法Yolo v3 COCO-图片： darknet.exe detect cfg/yolov4.cfg yolov4.weights -i 0 -thresh 0.25
• 在Amazon EC2上进行训练，以使用URL来查看mAP和丢失图表，例如：http://ec2-35-160-228-91.us-west-2.compute.amazonaws.com:8090在Chrome / Firefox中（Darknet应该使用OpenCV进行编译）： ./darknet detector train cfg/coco.data yolov4.cfg yolov4.conv.137 -dont_show -mjpeg_port 8090 -map
• 186 MB Yolo9000-图片： darknet.exe detector test cfg/combine9k.data cfg/yolo9000.cfg yolo9000.weights
• 如果使用cpp api构建应用程序，请记住将data / 9k.tree和data / coco9k.map放在应用程序的同一文件夹下
• 要处理图像列表data/train.txt并将检测结果保存到result.json文件中，请使用： darknet.exe detector test cfg/coco.data cfg/yolov4.cfg yolov4.weights -ext_output -dont_show -out result.json < data/train.txt
• 处理图像列表data/train.txt并保存检测结果以result.txt供使用：
  darknet.exe detector test cfg/coco.data cfg/yolov4.cfg yolov4.weights -dont_show -ext_output < data/train.txt > result.txt
• 伪标记-处理图像列表data/new_train.txt并将检测结果以Yolo训练格式保存为每个图像作为标签.txt（通过这种方式，您可以增加训练数据量）使用： darknet.exe detector test cfg/coco.data cfg/yolov4.cfg yolov4.weights -thresh 0.25 -dont_show -save_labels < data/new_train.txt
• 要计算锚点： darknet.exe detector calc_anchors data/obj.data -num_of_clusters 9 -width 416 -height 416
• 要检查准确性mAP @ IoU = 50： darknet.exe detector map data/obj.data yolo-obj.cfg backup\yolo-obj_7000.weights
• 要检查准确性mAP @ IoU = 75： darknet.exe detector map data/obj.data yolo-obj.cfg backup\yolo-obj_7000.weights -iou_thresh 0.75

用于在任何Android智能手机上使用网络摄像机mjpeg-stream

1. 下载Android手机mjpeg-stream soft：IP网络摄像头/ Smart WebCam

   • 智能网络摄像头-最好：https://play.google.com/store/apps/details?id=com.acontech.android.SmartWebCam2
   • IP网络摄像头：https://play.google.com/store/apps/details?id=com.pas.webcam

2. 通过WiFi（通过WiFi路由器）或USB将Android手机连接到计算机

3. 在手机上启动Smart WebCam

4. 替换下面的地址，在电话应用程序（Smart WebCam）中显示并启动：

• Yolo v4 COCO模型： darknet.exe detector demo data/coco.data yolov4.cfg yolov4.weights http://192.168.0.80:8080/video?dummy=param.mjpg -i 0

如何在Linux上编译（使用cmake）

该CMakeLists.txt将尝试查找已安装的可选依赖像CUDA，cudnn，ZED与那些身材。它还将创建一个共享对象库文件以darknet用于代码开发。

在克隆的存储库中执行以下操作：

mkdir build-release
cd build-release
cmake ..
make
make install 

如何在Linux上编译（使用make）

只需make在darknet目录中即可。在制作之前，您可以在Makefile：链接中设置此类选项。

• GPU=1使用CUDA进行构建以通过使用GPU加速（CUDA应该在中/usr/local/cuda）
• CUDNN=1使用cuDNN v5-v7进行构建，以通过使用GPU加速培训（cuDNN应该在中/usr/local/cudnn）
• CUDNN_HALF=1 为Tensor Core构建（在Titan V / Tesla V100 / DGX-2及更高版本上）加速检测3倍，训练2倍
• OPENCV=1 使用OpenCV 4.x / 3.x / 2.4.x进行构建-允许检测来自网络摄像机或网络摄像机的视频文件和视频流
• DEBUG=1 调试Yolo版本
• OPENMP=1 使用OpenMP支持进行构建以通过使用多核CPU来加速Yolo
• LIBSO=1生成一个库darknet.so和uselib使用该库的二进制可运行文件。或者，您也可以尝试运行，LD_LIBRARY_PATH=./:$LD_LIBRARY_PATH ./uselib test.mp4如何从自己的代码中使用此SO库-您可以查看C ++示例：https://github.com/AlexeyAB/darknet/blob/master/src/yolo_console_dll.cpp 或在这样的方式：LD_LIBRARY_PATH=./:$LD_LIBRARY_PATH ./uselib data/coco.names cfg/yolov4.cfg yolov4.weights test.mp4
• ZED_CAMERA=1 构建具有ZED-3D摄像机支持的库（应安装ZED SDK），然后运行 LD_LIBRARY_PATH=./:$LD_LIBRARY_PATH ./uselib data/coco.names cfg/yolov4.cfg yolov4.weights zed_camera

要在Linux上运行Darknet，请使用本文提供的示例，只需使用./darknet代替darknet.exe，即使用以下命令：./darknet detector test ./cfg/coco.data ./cfg/yolov4.cfg ./yolov4.weights

如何在Windows上进行编译（使用CMake-GUI）

如果您已经安装了Visual Studio 2015/2017/2019，CUDA> 10.0，cuDNN> 7.0和OpenCV> 2.4，则这是在Windows上构建Darknet的推荐方法。

使用CMake-GUI如下所示这个IMAGE：

1. 配置
2. 发电机的可选平台（设置：x64）
3. 完
4. 生成
5. 公开项目
6. 设置：x64和发行版
7. 建立
8. 建立解决方案

如何在Windows上进行编译（使用vcpkg）

如果您已经安装了Visual Studio 2015/2017/2019，CUDA> 10.0，cuDNN> 7.0，OpenCV> 2.4，则要编译Darknet，建议使用 CMake-GUI。

否则，请按照下列步骤操作：

1. 将Visual Studio安装或更新到至少2017版，并确保已对其进行全面修补（如果不确定是否自动更新到最新版本，请再次运行安装程序）。如果需要从头开始安装，请从此处下载VS：Visual Studio社区

2. 安装CUDA和cuDNN

3. 安装git和cmake。确保它们至少在当前帐户的路径上

4. 安装vcpkg并尝试安装测试库以确保一切正常，例如vcpkg install opengl

5. 定义环境变量，VCPKG_ROOT指向的安装路径vcpkg

6. 用名称VCPKG_DEFAULT_TRIPLET和值定义另一个环境变量x64-windows

7. 打开Powershell并键入以下命令：

PS \ >                   cd $ env： VCPKG_ROOT 
PS代码\ vcpkg >          。\ vcpkg install pthreads opencv [ ffmpeg ] ＃如果您要使用cuda加速的openCV，请替换为opencv [cuda，ffmpeg]

1. 打开Powershell，转到darknet文件夹并使用命令进行构建.\build.ps1。如果要使用Visual Studio，将在构建后找到由CMake为您创建的两个自定义解决方案，一个在中build_win_debug，另一个在中build_win_release，其中包含系统的所有适当配置标志。

如何在Windows上编译（旧版方式）

C:\opencv_3.0\opencv\build\x64\vc14\lib;$(CUDA_PATH)\lib\$(PlatformName);$(CUDNN)\lib\x64;%(AdditionalLibraryDirectories)

..\..\3rdparty\lib\x64\pthreadVC2.lib;cublas.lib;curand.lib;cudart.lib;cudnn.lib;%(AdditionalDependencies)

OPENCV;_TIMESPEC_DEFINED;_CRT_SECURE_NO_WARNINGS;_CRT_RAND_S;WIN32;NDEBUG;_CONSOLE;_LIB;%(PreprocessorDefinitions)

如何使用多GPU进行训练：

仅对于小型数据集，有时对于4个GPU集learning_rate = 0.00025（例如，learning_rate = 0.001 / GPU）而言，降低学习率更好。在这种情况下burn_in =，请max_batches =在您的cfg文件中增加4倍的时间。即使用burn_in = 4000代替1000。steps=如果policy=steps设置相同。

https://groups.google.com/d/msg/darknet/NbJqonJBTSY/Te5PfIpuCAAJ

如何训练（检测您的自定义对象）：

（培养老YOLO V2 yolov2-voc.cfg，yolov2-tiny-voc.cfg，yolo-voc.cfg，yolo-voc.2.0.cfg，... 通过链接点击）

培训Yolo v4（和v3）：

因此，如果classes=1应该filters=18。如果classes=2再写filters=21。

（不要写在cfg文件中：filters =（classs + 5）x3）

（通常filters取决于classes，coords和的数量mask，即filters = (classes + coords + 1)*，其中mask是锚的索引。如果mask不存在，则filters = (classes + coords + 1)*num）

因此，例如，对于2个对象，您的文件yolo-obj.cfg应该yolov4-custom.cfg在3个 [yolo]层的每一层中均不同于以下行：

[convolutional]
filters=21

[region]
classes=2 

classes= 2
train  = data/train.txt
valid  = data/test.txt
names = data/obj.names
backup = backup/ 

它将.txt为.jpg同一目录中具有相同名称但具有.txt-extension的每个-image-file- 创建一个-file ，并将其放置到文件中：该图像上的对象编号和对象坐标，用于新行中的每个对象：

哪里：

例如，将为img1.jpg您创建img1.txt包含：

1 0.716797 0.395833 0.216406 0.147222
0 0.687109 0.379167 0.255469 0.158333
1 0.420312 0.395833 0.140625 0.166667 

data/obj/img1.jpg
data/obj/img2.jpg
data/obj/img3.jpg 

8.1。对于每4个纪元（设置valid=valid.txt或train.txt在obj.data文件中）使用mAP（平均平均精度）计算进行训练并运行：darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137 -map

注意：如果在训练过程中看到nan“ avg（损失）”字段的值-则训练有误，但如果出现nan在其他行中-则训练进行得很好。

注意：如果您在cfg文件中更改了width =或height =，则新的宽度和高度必须被32整除。

注意：训练后，请使用以下命令进行检测：darknet.exe detector test data/obj.data yolo-obj.cfg yolo-obj_8000.weights

注意：如果Out of memory发生错误，.cfg则应在-file中增加subdivisions=1632或64：链接

如何训练tiny-yolo（检测您的自定义对象）：

执行与上述完整yolo模型相同的所有步骤。除了：

1. 如果您具有CUDA 10.0，cuDNN 7.4和OpenCV 3.x（路径：C:\opencv_3.0\opencv\build\include＆C:\opencv_3.0\opencv\build\x64\vc14\lib），则打开build\darknet\darknet.sln，设置x64并释放 https://hsto.org/webt/uh/fk/-e/uhfk-eb0q-hwd9hsxhrikbokd6u.jpeg并执行以下操作：构建->构建darknet。还要添加Windows系统变量CUDNN以及CUDNN的路径：https://developer.nvidia.com/rdp/cudnn-archive

2. 添加CUDNN具有CUDNN路径的Windows系统变量：https://devblogs.nvidia.com/parallelforall/wp-content/uploads/ 2015/01 / VS2013-R-5.jpg

3. 添加到项目：
   • 所有.c档案
   • 所有.cu档案
   • 文件http_stream.cpp从\src目录
   • 文件darknet.h从\include目录
4. （右键单击项目）->属性->链接器->常规->其他库目录，放在这里：
   • （右键单击项目）->属性->链接器->输入->其他依赖项，放在这里：
   • （右键单击项目）->属性-> C / C ++->预处理程序->预处理程序定义

   • 编译为.exe（X64＆Release）并将.dll-s与.exe放在附近：https://hsto.org/webt/uh/fk/-e/uhfk-eb0q-hwd9hsxhrikbokd6u.jpeg

     • pthreadVC2.dll, pthreadGC2.dll 来自\ 3rdparty \ dll \ x64

     • cusolver64_91.dll, curand64_91.dll, cudart64_91.dll, cublas64_91.dll -91（对于CUDA 9.1或您的版本），来自C：\ Program Files \ NVIDIA GPU Computing Toolkit \ CUDA \ v9.1 \ bin

     • 对于OpenCV的3.2：opencv_world320.dll与opencv_ffmpeg320_64.dll从C:\opencv_3.0\opencv\build\x64\vc14\bin

     • 对于OpenCV的2.4.13： opencv_core2413.dll，opencv_highgui2413.dll并opencv_ffmpeg2413_64.dll从 C:\opencv_2.4.13\opencv\build\x64\vc14\bin

   1. 首先在1个GPU上进行约1000次迭代的训练： darknet.exe detector train cfg/coco.data cfg/yolov4.cfg yolov4.conv.137

   2. 然后停止并通过使用部分训练的模型/backup/yolov4_1000.weights运行训练来进行multigpu（最多4个GPU）：darknet.exe detector train cfg/coco.data cfg/yolov4.cfg /backup/yolov4_1000.weights -gpus 0,1,2,3

   1. 要进行培训，请cfg/yolov4-custom.cfg下载预训练的权重文件（162 MB）：yolov4.conv.137（Google驱动器镜像yolov4.conv.137）

   2. 创建yolo-obj.cfg内容与中相同的文件yolov4-custom.cfg（或复制yolov4-custom.cfg到yolo-obj.cfg)和：

   • 将行批次更改为 batch=64
   • 将线路细分更改为 subdivisions=16
   • 将max_batches线更改为（classes*2000但不小于4000），max_batches=6000如果您训练3节课，则更改为fe
   • 将线路步长更改为max_batches，fe的80％和90％ steps=4800,5400
   • 设置网络大小width=416 height=416或任何32的值的倍数：https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L8-L9
   • 将行更改classes=80为3 [yolo]层中每层的对象数：
     • https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L610
     • https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L696
     • https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L783
   • 将[ filters=255] 更改为[convolutional]每层前3个中的filter =（classs + 5）x3 [yolo]，请记住，它只需是[convolutional]每个[yolo]层之前的最后一个。
     • https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L603
     • https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L689
     • https://github.com/AlexeyAB/darknet/blob/0039fd26786ab5f71d5af725fc18b3f521e7acfd/cfg/yolov3.cfg#L776
   • 当使用[Gaussian_yolo] 层，改变[ filters=57]过滤器=（类+ 9）X3在3 [convolutional]每个前[Gaussian_yolo]层
     • https://github.com/AlexeyAB/darknet/blob/6e5bdf1282ad6b06ed0e962c3f5be67cf63d96dc/cfg/Gaussian_yolov3_BDD.cfg#L604
     • https://github.com/AlexeyAB/darknet/blob/6e5bdf1282ad6b06ed0e962c3f5be67cf63d96dc/cfg/Gaussian_yolov3_BDD.cfg#L696
     • https://github.com/AlexeyAB/darknet/blob/6e5bdf1282ad6b06ed0e962c3f5be67cf63d96dc/cfg/Gaussian_yolov3_BDD.cfg#L789

   1. obj.names在目录中创建文件build\darknet\x64\data\，并带有对象名称-每个都在新行中

   2. obj.data在目录中创建文件build\darknet\x64\data\，其中包含（其中class =对象数）：

   1. 将对象的图像文件（.jpg）放在目录中 build\darknet\x64\data\obj\

   2. 您应该在数据集中的图像上标记每个对象。使用此可视化GUI软件来标记对象的边界框并为Yolo v2和v3生成注释文件：https://github.com/AlexeyAB/Yolo_mark

   • -从0到的整数对象编号(classes-1)
   • -浮动值相对于图片的宽度和高度，可以等于(0.0 to 1.0]
   • 例如： = / 或 = /
   • 注意： -矩形的中心（不是左上角）
   1. train.txt在directory中创建文件build\darknet\x64\data\，其中包含图像的文件名，每个文件名都换行，并具有相对于的路径darknet.exe，例如，包含：

   1. 下载卷积层的预训练权重并放置到目录中 build\darknet\x64

      • 为yolov4.cfg，yolov4-custom.cfg（162 MB）：yolov4.conv.137（谷歌驱动镜yolov4.conv.137）
      • for csresnext50-panet-spp.cfg（133 MB）：csresnext50-panet-spp.conv.112
      • 对于yolov3.cfg, yolov3-spp.cfg（154 MB）：darknet53.conv.74
      • for yolov3-tiny-prn.cfg , yolov3-tiny.cfg（6 MB）：yolov3-tiny.conv.11
      • 对于enet-coco.cfg (EfficientNetB0-Yolov3)（14 MB）：enetb0-coco.conv.132

   2. 使用命令行开始培训： darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137

      要在Linux上训练，请使用以下命令：（./darknet detector train data/obj.data yolo-obj.cfg yolov4.conv.137仅使用./darknet代替darknet.exe）

      • （文件每100次迭代yolo-obj_last.weights将保存到中build\darknet\x64\backup\）
      • （文件每1000次迭代yolo-obj_xxxx.weights将保存到中build\darknet\x64\backup\）
      • （darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137 -dont_show如果您在没有监视器的计算机（如云Amazon EC2）上进行训练，则可以禁用Loss-Window的使用）
      • （要在没有GUI的远程服务器上进行培训时查看mAP和失误表，请使用命令，darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137 -dont_show -mjpeg_port 8090 -map然后http://ip-address:8090在Chrome / Firefox浏览器中打开URL ）
   1. 训练完成后- yolo-obj_final.weights从路径中获取结果build\darknet\x64\backup\

   • 每进行100次迭代后，您可以停止，然后从这一点开始训练。例如，经过2000次迭代后，您可以停止训练，之后再开始使用以下方法开始训练：darknet.exe detector train data/obj.data yolo-obj.cfg backup\yolo-obj_2000.weights

     （在原始存储库https://github.com/pjreddie/darknet中，权重文件每1万次迭代仅保存一次if(iterations > 1000)）

   • 同样，您可以比所有45000次迭代更早地获得结果。

   • 下载yolov3-tiny的默认权重文件：https://github.com/AlexeyAB/darknet/blob/master/build/ darknet / x64 / partial.cmd 如果您创建的定制模型不基于其他模型，则可以在不预先训练权重的情况下对其进行训练，然后将使用随机初始权重。

      

     我什么时候应该停止训练：

     通常，每个类（对象）需要进行2000次迭代，但总计不少于4000次迭代。但是对于何时停止训练的更精确定义，请使用以下手册：

     1. 在训练期间，您会看到各种错误指示，并且当不再减少0.XXXXXXX avg时，您应该停止操作：

     区域平均IOU：0.798363，类：0.893232，对象：0.700808，无对象：0.004567，平均调用率：1.000000，计数：8区域平均IOU：0.800677，类：0.892181，对象：0.701590，无对象：0.004574，平均调用率：1.000000 ，数：8

     9002：0.211667，0.60730 平均，0.001000速率，3.868000秒，576128图像加载：0.000000秒

     • 9002-迭代编号（批处理数量）
     • 0.60730平均 -平均损失（错误）- 越低越好

     当您发现平均损失0.xxxxxx平均不再在许多次迭代中减少时，您应该停止训练。最终平均损失可能从0.05（对于小模型和简单数据集）到3.0（对于大模型和困难数据集）。

     1. 训练停止后，您应该.weights从中提取一些最后的文件，darknet\build\darknet\x64\backup并从中选择最好的文件：

     例如，您在9000次迭代后停止了训练，但最佳结果可以给出以前的权重之一（7000、8000、9000）。可能由于过度拟合而发生。过度拟合 -这种情况是您可以从训练数据集中检测图像上的对象，但无法检测其他图像上的对象。您应该从Early Stopping Point获得权重：

     

     要从早期停止点获取权重：

     2.1。首先，obj.data您必须在文件中指定验证数据集的路径valid = valid.txt（格式valid.txt为中的train.txt），如果您没有验证图片，则只需复制data\train.txt到即可data\valid.txt。

     2.2如果在9000次迭代后停止训练，要验证以前的权重，请使用以下命令：

     （如果您使用另一个GitHub存储库，请使用darknet.exe detector recall...而不是darknet.exe detector map...）

     • darknet.exe detector map data/obj.data yolo-obj.cfg backup\yolo-obj_7000.weights
     • darknet.exe detector map data/obj.data yolo-obj.cfg backup\yolo-obj_8000.weights
     • darknet.exe detector map data/obj.data yolo-obj.cfg backup\yolo-obj_9000.weights

     每个权重（7000、8000、9000）的comapre最后输出线：

     选择具有最高mAP（平均平均精度）或IoU（与联合相交）的权重文件

     例如，较大的mAP会赋予权重yolo-obj_8000.weights-然后使用此权重进行检测。

     或者只是用-map国旗训练：

     darknet.exe detector train data/obj.data yolo-obj.cfg yolov4.conv.137 -map

     因此，您将在“损失图”窗口中看到“ mAP图”（红线）。将使用valid=valid.txt文件中指定的obj.data文件（1 Epoch = images_in_train_txt / batch迭代）为每个4个时期计算mAP

     （将3类的最大x轴值更改max_batches=为2000*classes-fe max_batches=6000）

     

     自定义对象检测的示例： darknet.exe detector test data/obj.data yolo-obj.cfg yolo-obj_8000.weights

     • IoU（联合上方的相交）-物体联合上方的平均insectect和检测到的某个阈值= 0.24

     • mAP（平均平均精度）- average precisions每个类别的average precision平均值，其中是同一类别的每个可能阈值（每个检测概率）的PR曲线上11点的平均值（以PascalVOC表示的Precision-Recall，其中Precision = TP /（TP + FP）和Recall = TP /（TP + FN）），第11页：http://homepages.inf.ed.ac.uk/ckiw/postscript/ijcv_voc09.pdf

     mAP是PascalVOC竞赛中默认的精度指标，与MS COCO竞赛中的AP50指标相同。在Wiki方面，指标Precision和Recall的含义与PascalVOC竞赛中的含义略有不同，但是IoU 始终具有相同的含义。

     自定义对象检测：

     自定义对象检测的示例： darknet.exe detector test data/obj.data yolo-obj.cfg yolo-obj_8000.weights

     如何改善物体检测：

     1. 训练前：

     • random=1在.cfg-file文件中设置标志-通过训练Yolo不同的分辨率，它将提高精度：链接

     • 提高您的网络分辨率.cfg-file（ height=608，width=608或32任何价值倍数） -它会增加精度

     • 检查您要检测的每个对象是否在数据集中被强制标记-数据集中的任何对象都不应没有标签。在大多数培训问题中-数据集中有错误的标签（通过使用某些转换脚本，使用第三方工具标记的标签来获得标签，...）。始终使用以下方法检查数据集：https://github.com/AlexeyAB/Yolo_mark

     • 我的损失非常高，而mAP却很低，训练错了吗？ -show_imgs在training命令的末尾运行带有flag的训练，您是否看到正确的有界对象框（在Windows或文件中aug_...jpg）？如果否-您的训练数据集有误。

     • 对于您要检测的每个对象-训练数据集中必须至少有一个相似的对象，且它们具有大致相同的形状：形状，对象的侧面，相对大小，旋转角度，倾斜度，照明度。希望训练数据集包含不同对象的图像：比例，旋转，照明，不同侧面，不同背景的图像-每个班级或以上，您最好拥有2000张不同的图像，并且您应训练2000*classes迭代或更多次

     • 希望您的训练数据集包含带有您不想检测的未标记对象的图像-无边界框的负样本（空.txt文件）-使用与带有对象的图像一样多的负样本图像

     • 标记对象的最佳方法是：仅标记对象的可见部分，或标记对象的可见和重叠部分，或标记比整个对象多一点（有一点间隙）？随心所欲标记-您希望如何检测它。

     • 要在每个图像中使用大量对象进行训练，请在cfg文件max=200的最后[yolo]一层或最后一层中添加参数或更高的值[region]（YoloV3可以检测到的全局最大对象数0,0615234375*(width*height)是宽度和高度是[net]cfg文件中部分的参数）

     • 用于训练小对象（将图像调整为416x416后小于16x16）-设置layers = 23为https://github.com/AlexeyAB/darknet/blob/6f718c257815a984253346bba8fb7aa756c55090/cfg/yolov4.cfg#L895 设置stride=4为https：// /github.com/AlexeyAB/darknet/blob/6f718c257815a984253346bba8fb7aa756c55090/cfg/yolov4.cfg#L892 并设置stride=4为https://github.com/AlexeyAB/darknet/blob/6f718c257815a984253346bba8fb7aa756c55090/cfg/yolov4。

     • 对于小型和大型对象的训练，请使用修改后的模型：

       • 完整模型：5个yolo层：https://github.com /AlexeyAB/darknet/blob/3d2d0a7c98dbc8923d9ff705b81ff4f7940ea6ff/cfg/yolov3.cfg#L17

          

       • 一般规则-您的训练数据集应包括一组要检测的相对大小的对象：

         • train_network_width * train_obj_width / train_image_width ~= detection_network_width * detection_obj_width / detection_image_width
         • train_network_height * train_obj_height / train_image_height ~= detection_network_height * detection_obj_height / detection_image_height

         即，对于Test数据集中的每个对象，Training数据集中必须至少有1个对象具有相同的class_id和大约相同的相对大小：

         object width in percent from Training dataset ?= object width in percent from Test dataset

         也就是说，如果训练集中仅存在占图像80-90％的对象，则受训练的网络将无法检测到占图像1-10％的对象。

       • 加快训练速度（降低检测精度）stopbackward=1在cfg文件中为第136层设置参数

       • 每个：model of object, side, illimination, scale, each 30 grad转角和倾斜角- 从神经网络的内部角度来看，它们是不同的对象。因此，要检测的对象越不同，应使用越复杂的网络模型。

       • 为了使检测到的边界框更准确，您可以ignore_thresh = .9 iou_normalizer=0.5 iou_loss=giou在每个[yolo]图层上添加3个参数并进行训练，它将增加[email protected]，但减少[email protected]。

       • 仅当您是神经检测网络专家时-才为cfg文件width和height从cfg文件重新计算数据集的锚点： darknet.exe detector calc_anchors data/obj.data -num_of_clusters 9 -width 416 -height 416 然后在cfg文件anchors的3 [yolo]层中的每一个中设置相同的9 。但是，您应该masks=为每个[yolo]层更改锚点的索引，以使第一[yolo]层的锚点大于60x60，第二个层大于30x30，剩下的第三个层。同样，您应该filters=(classes + 5)*在每个[yolo]层之前更改。如果许多计算出的锚不适合在适当的图层下-则只需尝试使用所有默认锚即可。

       1. 训练后-用于检测：

       • 通过在.cfg-file（height=608和width=608）或（height=832和width=832）或（32的任何值）中设置来提高网络分辨率-这可以提高精度并可以检测小对象：link

         • 无需再次训练网络，只需使用.weights已针对416x416分辨率进行训练的-file
         • 但是要获得更高的精度，您应该使用更高分辨率的608x608或832x832进行训练，请注意：如果Out of memory发生错误，.cfg则应在-file文件中增加subdivisions=16，32或64：链接

       如何标记对象的边界框并创建注释文件：

       在这里，您可以找到带有GUI软件的存储库，用于标记对象的有界框并为Yolo v2-v4生成注释文件：https://github.com/AlexeyAB/Yolo_mark

       与示例的：train.txt，obj.names，obj.data，yolo-obj.cfg，air1-6 .txt，bird1-4 .txt为2类的对象（空气，鸟）和train_obj.cmd与实施例如何培养这个图像组具有YOLO V2 - V4

       在图像中标记对象的不同工具：

       1. 在C ++中：https://github.com/AlexeyAB/Yolo_mark
       2. 在Python中：https://github.com/tzutalin/labelImg
       3. 在Python中：https://github.com/Cartucho/OpenLabeling
       4. 在C ++中：https://www.ccoderun.ca/darkmark/
       5. 在JavaScript中：https://github.com/opencv/cvat

       使用Yolo9000

       同时检测和分类9000个对象： darknet.exe detector test cfg/combine9k.data cfg/yolo9000.cfg yolo9000.weights data/dog.jpg

       • yolo9000.weights-（186 MB Yolo9000型号）需要4 GB GPU-RAM：http://github.com/AlexeyAB/darknet/blob/master/include/darknet.h

         • 使用C API的Python示例：
           • https://github.com/AlexeyAB/darknet/blob/master/darknet.py
           • https://github.com/AlexeyAB/darknet/blob/master/darknet_video.py

       • C ++ API：https://github.com/AlexeyAB/darknet/blob/master/include/yolo_v2_class.hpp

         • 使用C ++ API的C ++示例：https://github.com/AlexeyAB/darknet/blob/master/src/yolo_console_dll.cpp

       ---

       1. 要将Yolo编译为C ++ DLL文件yolo_cpp_dll.dll-打开解决方案build\darknet\yolo_cpp_dll.sln，设置x64和Release，然后执行以下操作：Build-> Build yolo_cpp_dll

          • 您应该已经安装了CUDA 10.0
          • 要使用cuDNN，请执行以下操作：（右键单击项目）->属性-> C / C ++->预处理程序->预处理程序定义，然后在行的开头添加： CUDNN;

       2. 要将Yolo用作C ++控制台应用程序中的DLL文件，请打开解决方案build\darknet\yolo_console_dll.sln，设置x64和Release，然后执行以下操作：构建->构建yolo_console_dll

          • 您可以build\darknet\x64\yolo_console_dll.exe 使用以下命令从Windows资源管理器运行控制台应用程序：yolo_console_dll.exe data/coco.names yolov4.cfg yolov4.weights test.mp4

          • 启动控制台应用程序并输入图像文件名后，您将看到每个对象的信息： 

          • 要使用简单的OpenCV-GUI，您应该//#define OPENCV在yolo_console_dll.cpp-file：链接中取消注释行

          • 您可以在视频文件上看到用于检测的简单示例的源代码：链接

       yolo_cpp_dll.dll-API：链接

       struct bbox_t {
           unsigned int x, y, w, h;    // (x,y) - top-left corner, (w, h) - width & height of bounded box
           float prob;                    // confidence - probability that the object was found correctly
           unsigned int obj_id;        // class of object - from range [0, classes-1]
           unsigned int track_id;        // tracking id for video (0 - untracked, 1 - inf - tracked object)
           unsigned int frames_counter;// counter of frames on which the object was detected
       };
       
       class Detector {
       public:
               Detector(std::string cfg_filename, std::string weight_filename, int gpu_id = 0);
               ~Detector();
       
               std::vector detect(std::string image_filename, float thresh = 0.2, bool use_mean = false);
               std::vector detect(image_t img, float thresh = 0.2, bool use_mean = false);
               static image_t load_image(std::string image_filename);
               static void free_image(image_t m);
       
       #ifdef OPENCV
               std::vector detect(cv::Mat mat, float thresh = 0.2, bool use_mean = false);
       	std::shared_ptr mat_to_image_resize(cv::Mat mat) const;
       #endif
       }; 

关于pytorch，可加群857449786 注明（pytorch）

Tensorflow 深度学习实战群 755860371 共同学习，谢谢