Darknet Object Detection Framework and YOLO
The editor of Downcodes will give you an in-depth understanding of Darknet, an open source neural network framework written in C, C++ and CUDA, and the advanced real-time target detection system YOLO (You Only Look Once) running on the Darknet framework.
The Darknet/YOLO framework is faster and more accurate than other frameworks and YOLO versions. This framework is completely free and open source. You can integrate Darknet/YOLO into existing projects and products, including commercial projects, without licenses or fees.
Darknet V3 ("Jazz"), released in October 2024, can accurately run LEGO dataset videos at up to 1000 FPS when using an NVIDIA RTX 3090 GPU, meaning each video frame takes 1 millisecond or less Internally read, resized and processed by Darknet/YOLO.
If you need help or want to discuss Darknet/YOLO, please join the Darknet/YOLO Discord server: https://discord.gg/zSq8rtW
The CPU version of Darknet/YOLO can run on simple devices such as Raspberry Pi, cloud and collaboration servers, desktops, laptops, and high-end training equipment. The GPU version of Darknet/YOLO requires NVIDIA's CUDA-supported GPU.
Darknet/YOLO is known to run on Linux, Windows and Mac. Please see the build instructions below.
The original Darknet tools written by Joseph Redmon in 2013-2017 did not have version numbers. We think this is version 0.x.
The next popular Darknet library maintained by Alexey Bochkovskiy from 2017-2021 also had no version number. We believe this is version 1.x.
Starting in 2023, the Darknet library sponsored by Hank.ai and maintained by Stéphane Charette is the first library to have a version command. From 2023 to the end of 2024, it returns to version 2.x "OAK".
The goal is to get familiar with the code base while minimizing disruption to existing functionality.
Re-write the build steps so that we have 1 unified way to build using CMake on Windows and Linux.
Convert the code base to use a C++ compiler.
Chart.png during enhanced training.
Bug fixes and performance-related optimizations, mainly related to reducing the time required to train the network.
The last branch of this codebase is version 2.1 in the v2 branch.
The next phase of development begins in mid-2024, with release in October 2024. The version command now returns 3.x "JAZZ".
If you need to run one of these commands, you can always checkout the previous v2 branch. Please let us know so we can investigate adding back any missing commands.
Removed many old and unmaintained commands.
During training and inference, many performance optimizations were made.
Changes to the legacy C API; applications using the original Darknet API require minor modifications: https://darknetcv.ai/api/api.html
New Darknet V3 C and C++ API: https://darknetcv.ai/api/api.html
New applications and sample code in src-examples: https://darknetcv.ai/api/files.html
For convenience, several popular versions of YOLO are pre-trained on the MSCOCO dataset. This dataset has 80 categories and can be seen in the text file cfg/coco.names.
There are several other simpler datasets and pre-trained weights available for testing Darknet/YOLO, such as LEGO Gears and Rolodex. See the Darknet/YOLO FAQ for details.
MSCOCO pre-trained weights can be downloaded from a number of different locations and can also be downloaded from this repository:
YOLOv2, November 2016
*YOLOv2-tiny
*YOLOv2-full
YOLOv3, May 2018
* YOLOv3-tiny
*YOLOv3-full
YOLOv4, May 2020
* YOLOv4-tiny
*YOLOv4-full
YOLOv7, August 2022
* YOLOv7-tiny
*YOLOv7-full
MSCOCO pretrained weights are for demonstration purposes only. The .cfg and .names files corresponding to MSCOCO are located in the cfg directory. Example command:
`
wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights
darknet02displayannotatedimages coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi
`
Note that one should train their own network. MSCOCO is usually used to confirm that everything is working properly.
Various build methods provided in the past (before 2023) have been merged into a unified solution. Darknet requires C++17 or higher, OpenCV, and uses CMake to generate the necessary project files.
You don't need to know C++ to build, install, or run Darknet/YOLO, just like you don't need to be a mechanic to drive a car.
The instructions for Google Colab are the same as for Linux. A number of Jupyter notebooks are provided showing how to perform certain tasks, such as training a new network.
Please check out the notebook in the colab subdirectory, or follow the Linux instructions below.
Darknet build tutorial on Linux
Optional: If you have a modern NVIDIA GPU, you can install CUDA or CUDA+cuDNN at this time. If installed, Darknet will use your GPU to accelerate image (and video) processing.
You must delete the CMakeCache.txt file from the Darknet build directory to force CMake to re-find all required files.
Remember to rebuild Darknet.
Darknet can run without it, but if you want to train a custom network, you need CUDA or CUDA+cuDNN.
Visit https://developer.nvidia.com/cuda-downloads to download and install CUDA.
Visit https://developer.nvidia.com/rdp/cudnn-download or https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview to download and Install cuDNN.
After installing CUDA, make sure nvcc and nvidia-smi can run. You may need to modify the PATH variable.
If you install CUDA or CUDA+cuDNN later, or upgrade to a newer version of NVIDIA software:
These instructions assume (but do not require!) a system running Ubuntu 22.04. If you are using another distribution, adjust as needed.
`
sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/srccd ~/src
git clone https://github.com/hank-ai/darknetcd darknet
mkdir buildcd build
cmake -DCMAKEBUILDTYPE=Release ..
make -j4 package
sudo dpkg -i darknet-VERSION.deb
`
If you are using an older version of CMake, you will need to upgrade CMake before running the cmake command above. CMake can be upgraded on Ubuntu using the following command:
`
sudo apt-get purge cmakesudo snap install cmake --classic
`
If you are using bash as your command shell, you will need to restart your shell at this point. If using fish it should pick up the new path immediately.
Advanced users:
If you want to build an RPM installation file instead of a DEB file, see the relevant lines in CM_package.cmake. Before running make -j4 package you need to edit these two lines:
`
SET (CPACKGENERATOR "DEB")# SET (CPACKGENERATOR "RPM")
`
For distributions like Centos and OpenSUSE, you need to switch these two lines in CM_package.cmake to:
`
SET (CPACKGENERATOR "DEB")SET (CPACKGENERATOR "RPM")
`
After the installation package is built, you can use the distribution's common package manager to install it. For example, on a Debian-based system such as Ubuntu:
`
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Installing the .deb package will copy the following files:
/usr/bin/darknet is a commonly used Darknet executable file. Run darknet version from the CLI to confirm it is installed correctly.
/usr/include/darknet.h is the Darknet API for C, C++ and Python developers.
/usr/include/darknet_version.h contains the developer's version information.
/usr/lib/libdarknet.so is a library for C, C++ and Python developers to link against.
/opt/darknet/cfg/... is where all .cfg templates are stored.
You are done now! Darknet is built and installed into /usr/bin/. Run the following command to test: darknet version.
If you don't have /usr/bin/darknet, it means you didn't install it, you just built it! Please make sure to install the .deb or .rpm file as described above.
These instructions assume a clean installation of Windows 11 22H2.
Open a regular cmd.exe command prompt window and run the following command:
`
winget install Git.Git
winget install Kitware.CMake
winget install nsis.nsis
winget install Microsoft.VisualStudio.2022.Community
`
At this point, we need to modify the Visual Studio installation to include support for C++ applications:
1. Click the "Windows Start" menu and run "Visual Studio Installer".
2. Click Edit.
3. Choose desktop development using C++.
4. Click Edit in the lower right corner, then click Yes.
After everything is downloaded and installed, click on the "Windows Start" menu again and select the Developer Command Prompt for VS 2022. Do not use PowerShell for these steps, you will run into problems!
Advanced users:
Instead of running the developer command prompt, you can also use a normal command prompt or ssh to the device and manually run "Program FilesMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".
After running the developer command prompt above (not PowerShell!), run the following command to install Microsoft VCPKG, which will then be used to build OpenCV:
`
cdc:
mkdir c:srccd c:src
git clone https://github.com/microsoft/vcpkgcd vcpkg
bootstrap-vcpkg.bat .vcpkg.exe integrate
install .vcpkg.exe integrate powershell.vcpkg.exe install opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
Be patient during this last step as it may take a long time to run. It requires downloading and building a lot of stuff.
Advanced users:
Note that there are many other optional modules you can add when building OpenCV. Run .vcpkg.exe search opencv to see the complete list.
Optional: If you have a modern NVIDIA GPU, you can install CUDA or CUDA+cuDNN at this time. If installed, Darknet will use your GPU to accelerate image (and video) processing.
You must delete the CMakeCache.txt file from the Darknet build directory to force CMake to re-find all required files.
Remember to rebuild Darknet.
Darknet can run without it, but if you want to train a custom network, you need CUDA or CUDA+cuDNN.
Visit https://developer.nvidia.com/cuda-downloads to download and install CUDA.
Visit https://developer.nvidia.com/rdp/cudnn-download or https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows to download and install cuDNN.
After installing CUDA, make sure you can run nvcc.exe and nvidia-smi.exe. You may need to modify the PATH variable.
After downloading cuDNN, unzip it and copy the bin, include, and lib directories to C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[version]/. You may need to overwrite some files.
If you install CUDA or CUDA+cuDNN later, or upgrade to a newer version of NVIDIA software:
CUDA must be installed after Visual Studio. If you upgrade Visual Studio, remember to reinstall CUDA.
After all previous steps are completed successfully, you need to clone Darknet and build it. In this step we also need to tell CMake where vcpkg is located so that it can find OpenCV and other dependencies:
`
cd c:src
git clone https://github.com/hank-ai/darknet.gitcd darknet
mkdir buildcd build
cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
If you receive an error about some missing CUDA or cuDNN DLL (such as cublas64_12.dll), then manually copy the CUDA .dll file to the same output directory as Darknet.exe. For example:
`
copy "C:Program FilesNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(This is an example! Please check which version you are running and run the appropriate command for what you have installed.)
After copying the files, re-run the last msbuild.exe command to generate the NSIS installation package:
`
msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj
`
Advanced users:
Please note that the output of the cmake command is a normal Visual Studio solution file, Darknet.sln. If you are a software developer who frequently uses the Visual Studio GUI instead of msbuild.exe to build projects, you can ignore the command line and load the Darknet project in Visual Studio.
You should now have the following file that you can run: C:srcDarknetbuildsrc-cliReleasedarknet.exe. Run the following command to test: C:srcDarknetbuildsrc-cliReleasedarknet.exe version.
To properly install Darknet, libraries, include files, and necessary DLLs, run the NSIS installation wizard built in the last step. Please look at the darknet-VERSION.exe file in the build directory. For example:
`
darknet-2.0.31-win64.exe
`
Installing the NSIS installation package will:
Create a directory called Darknet, for example C:Program FilesDarknet.
Install the CLI application, darknet.exe and other sample applications.
Install required third-party .dll files, such as those from OpenCV.
Install the necessary Darknet .dll, .lib, and .h files to use darknet.dll from another application.
Install the template .cfg file.
You are done now! After the installation wizard is completed, Darknet will be installed into C:Program FilesDarknet. Run the following command to test: C:Program FilesDarknetbindarknet.exe version.
If you don't have C:/Program Files/darknet/bin/darknet.exe, it means you didn't install it, you just built it! Please make sure to complete each panel of the NSIS Installation Wizard in the previous step.
The following is not a complete list of all commands supported by Darknet.
In addition to the Darknet CLI, also note the DarkHelp project CLI, which provides a different CLI than Darknet/YOLO. DarkHelp CLI also has several advanced features not directly available in Darknet. You can use both the Darknet CLI and the DarkHelp CLI, they are not mutually exclusive.
For most of the commands shown below, you will need the .weights file and the corresponding .names and .cfg files. You can train the network yourself (highly recommended!), or download a network that others have trained and are freely available on the Internet. Examples of pre-training datasets include:
LEGO Gears (find objects in images)
Rolodex (find text in image)
MSCOCO (standard 80 category target detection)
Commands that can be run include:
List some commands and options that can be run:
`
darknet help
`
Check version:
`
darknet version
`
Use images to make predictions:
`
V2: darknet detector test cars.data cars.cfg cars_best.weights image1.jpg
V3: darknet02displayannotatedimages cars.cfg image1.jpg
DarkHelp: DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg
`
Output coordinates:
`
V2: darknet detector test animals.data animals.cfg animalsbest.weights -extoutput dog.jpg
V3: darknet01inference_images animals dog.jpg
DarkHelp: DarkHelp --json animals.cfg animals.names animals_best.weights dog.jpg
`
Use video:
`
V2: darknet detector demo animals.data animals.cfg animalsbest.weights -extoutput test.mp4
V3: darknet03display_videos animals.cfg test.mp4
DarkHelp: DarkHelp animals.cfg animals.names animals_best.weights test.mp4
`
Reading from webcam:
`
V2: darknet detector demo animals.data animals.cfg animals_best.weights -c 0
V3: darknet08display_webcam animals
`
Save results to video:
`
V2: darknet detector demo animals.data animals.cfg animalsbest.weights test.mp4 -outfilename res.avi
V3: darknet05processvideosmultithreaded animals.cfg animals.names animals_best.weights test.mp4
DarkHelp: DarkHelp animals.cfg animals.names animals_best.weights test.mp4
`
JSON:
`
V2: darknet detector demo animals.data animals.cfg animalsbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
V3: darknet06imagestojson animals image1.jpg
DarkHelp: DarkHelp --json animals.names animals.cfg animals_best.weights image1.jpg
`
Run on specific GPU:
`
V2: darknet detector demo animals.data animals.cfg animals_best.weights -i 1 test.mp4
`
Check the accuracy of the neural network:
`
darknet detector map driving.data driving.cfg driving_best.weights ...
Id Name AvgPrecision TP FN FP TN Accuracy ErrorRate Precision Recall Specificity FalsePosRate
-- ---- ------------ ------ ------ ------ ------ -------- --------- --------- ------ ---------- ----------
0 vehicle 91.2495 32648 3903 5826 65129 0.9095 0.0905 0.8486 0.8932 0.9179 0.0821
1 motorcycle 80.4499 2936 513 569 5393 0.8850 0.1150 0.8377 0.8513 0.9046 0.0954
2 bicycle 89.0912 570 124 104 3548 0.9475 0.0525 0.8457 0.8213 0.9715 0.0285
3 person 76.7937 7072 1727 2574 27523 0.8894 0.1106 0.7332 0.8037 0.9145 0.0855
4 many vehicles 64.3089 1068 509 733 11288 0.9087 0.0913 0.5930 0.6772 0.9390 0.0610
5 green light 86.8118 1969 239 510 4116 0.8904 0.1096 0.7943 0.8918 0.8898 0.1102
6 yellow light 82.0390 126 38 30 1239 0.9525 0.0475 0.8077 0.7683 0.9764 0.0236
7 red light 94.1033 3449 217 451 4643 0.9237 0.0763 0.8844 0.9408 0.9115 0.0885
`
Check the accuracy of mAP@IoU=75:
`
darknet detector map animals.data animals.cfg animalsbest.weights -iouthresh 0.75
`
Recalculating anchor points is best done in DarkMark as it runs 100 times in a row and selects the best anchor point from all calculated anchor points. However, if you want to run an older version in Darknet, use the following command:
`
darknet detector calcanchors animals.data -numof_clusters 6 -width 320 -height 256
`
Train a new network:
`
darknet detector -map -dont_show train animals.data animals.cfg (see also training section below)
`
Quick links to relevant sections of the Darknet/YOLO FAQ:
How should I set up my files and directories?
Which profile should I use?
Which command should I use when training my own network?
The easiest way to annotate and train with DarkMark is to create all necessary Darknet files. This is definitely the recommended way to train new neural networks.
If you want to manually set up the various files to train a custom network:
1. Create a new folder to store these files. For this example, you will create a neural network that detects animals, so the following directory will be created: ~/nn/animals/.
2. Copy one of the Darknet configuration files you want to use as a template. For example, see cfg/yolov4-tiny.cfg. Place it in the folder you created. For this example, we now have ~/nn/animals/animals.cfg.
3. In the same folder where you placed the configuration file, create an animals.names text file. For this example, we now have ~/nn/animals/animals.names.
4. Use a text editor to edit the animals.names file. List the categories you want to use. You need exactly one entry per line, no blank lines and no comments. For this example, the .names file will contain exactly 4 lines:
`
dog
cat
bird
horse
`
5. Create an animals.data text file in the same folder. For this example, the .data file will contain:
`
classes = 4
train = /home/username/nn/animals/animals_train.txt
valid = /home/username/nn/animals/animals_valid.txt
names = /home/username/nn/animals/animals.names
backup = /home/username/nn/animals
`
6. Create a folder to store your images and annotations. For example, this could be ~/nn/animals/dataset. Each image requires a corresponding .txt file that describes the annotations for that image. The format of .txt comment files is very specific. You cannot create these files manually because each annotation needs to contain the exact coordinates of the annotation. See DarkMark or other similar software to annotate your images. The YOLO annotation format is described in the Darknet/YOLO FAQ.
7. Create "train" and "valid" text files named in the .data file. These two text files need to separately list all the images that Darknet must use for training and validation in order to calculate mAP%. There is exactly one image per row. Paths and filenames can be relative or absolute.
8. Use a text editor to modify your .cfg file.
* Make sure batch=64.
* Pay attention to subdivisions. Depending on the network size and the amount of memory available on the GPU, you may need to increase subdivisions. The optimal value is 1, so start with 1. If you are unable to use 1, please see the Darknet/YOLO FAQ.
Note that the optimal value for maxbatches=.... to start with is 2000 times the number of classes. For this example we have 4 animals, so 4 2000 = 8000. This means we will use maxbatches=8000.
* Note steps=.... This should be set to 80% and 90% of maxbatches. For this example we will use steps=6400,7200 since maxbatches is set to 8000.
* Note that width=... and height=.... These are network dimensions. The Darknet/YOLO FAQ explains how to calculate the optimal size to use.
* Search for the classes=... line in the [convolutional] section and modify it before each [yolo] section to include the number of classes from the .names file. For this example we will use classes=4.
Search for the filters=... line in the [convolutional] section before each [yolo] section. The value to use is (number of categories + 5) 3. This means that for this example, (4 + 5) * 3 = 27. Therefore, we use filters=27 on the appropriate lines.
9. Start training! Run the following command:
`
cd ~/nn/animals/
darknet detector -map -dont_show train animals.data animals.cfg
`
Be patient. The best weights will be saved as animals_best.weights. And you can observe the progress of training by viewing the chart.png file. See the Darknet/YOLO FAQ for additional parameters you may want to use when training a new network.
If you want to see more details during training, add the --verbose parameter. For example:
`
darknet detector -map -dont_show --verbose train animals.data animals.cfg
`
To manage your Darknet/YOLO project, annotate images, validate your annotations, and generate the necessary files for training with Darknet, see DarkMark.
To get a powerful Darknet alternative CLI, use image tiling, do object tracking in your videos, or use a powerful C++ API that can be easily used in commercial applications, see DarkHelp.
Please check out the Darknet/YOLO FAQ to see if it can help answer your question.
Watch many tutorials and example videos on Stéphane's YouTube channel
If you have support questions or would like to chat with other Darknet/YOLO users, please join the Darknet/YOLO Discord server.
Last updated: 2024-10-30
Replaced qsort() used during training with std::sort() (some other lesser known ones still exist)
Get rid of check_mistakes, getchar() and system()
Convert Darknet to use a C++ compiler (g++ on Linux, Visual Studio on Windows)
Fix Windows build
Fix Python support
Build darknet library
Re-enable predicted labels ("alphabet" code)
Re-enable CUDA/GPU code
Re-enable CUDNN
Re-enable CUDNN half
Don't hardcode the CUDA architecture
Better CUDA version information
Re-enable AVX
Remove old solution and Makefile
Make OpenCV non-optional
Remove dependency on old pthread library
Delete STB
Rewrite CMakeLists.txt to use new CUDA detection
Removed old "alphabet" code and deleted over 700 images in data/labels
Build outside source
Have better version number output
Training-related performance optimizations (ongoing tasks)
Performance optimizations related to inference (ongoing tasks)
Use references by value whenever possible
Clean .hpp files
Rewrite darknet.h
Don't cast cv::Mat to void, instead use it as a proper C++ object
Fix or keep internal image structures used consistently
Fix build for ARM based Jetson devices
* Since NVIDIA no longer supports original Jetson devices, they are unlikely to be fixed (no C++17 compiler)
* New Jetson Orin device now running
Fix Python API in V3
* Need better Python support (any Python developers willing to help?)
Replace printf() with std::cout (work in progress)
Looking into old zed camera support
Better, more consistent command line parsing (work in progress)
Remove all char codes and replace with std::string
Don't hide warnings and clean up compiler warnings (work in progress)
Better to use cv::Mat instead of custom image structures in C (work in progress)
Replace old list functions with std::vector or std::list
Fix support for 1-channel grayscale images
Add support for N-channel images where N > 3 (e.g. images with extra depth or thermal channels)
Ongoing code cleanup (in progress)
Fix CUDA/CUDNN issues for all GPUs
Rewrite the CUDA+cuDNN code
Consider adding support for non-NVIDIA GPUs
Rotated bounding box, or some kind of "angle" support
key points/skeleton
Heatmap (work in progress)
segmentation
