Home

Awesome

Table of Contents

Darknet Object Detection Framework and YOLO

darknet and hank.ai logos

Darknet is an open source neural network framework written in C, C++, and CUDA.

YOLO (You Only Look Once) is a state-of-the-art, real-time, object detection system, which runs in the Darknet framework.

Papers

General Information

The Darknet/YOLO framework continues to be both faster and more accurate than other frameworks and versions of YOLO.

This framework is both completely free and open source. You can incorporate Darknet/YOLO into existing projects and products -- including commercial ones -- without a license or paying a fee.

Darknet V3 ("Jazz") released in October 2024 can accurately run the LEGO dataset videos at up to 1000 FPS when using a NVIDIA RTX 3090 GPU, meaning each video frame is read, resized, and processed by Darknet/YOLO in 1 millisecond or less.

Please join the Darknet/YOLO Discord server if you need help or you want to discuss Darknet/YOLO: https://discord.gg/zSq8rtW

The CPU version of Darknet/YOLO can run on simple devices such as Raspberry Pi, cloud & colab servers, desktops, laptops, and high-end training rigs. The GPU version of Darknet/YOLO requires a CUDA-capable GPU from NVIDIA.

Darknet/YOLO is known to work on Linux, Windows, and Mac. See the building instructions below.

Darknet Version

MSCOCO Pre-trained Weights

Several popular versions of YOLO were pre-trained for convenience on the MSCOCO dataset. This dataset has 80 classes, which 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 <a target="_blank" href="https://www.ccoderun.ca/programming/yolo_faq/#datasets">the Darknet/YOLO FAQ</a> for details.

The MSCOCO pre-trained weights can be downloaded from several different locations, and are also available for download from this repo:

The MSCOCO pre-trained weights are provided for demo-purpose only. The corresponding .cfg and .names files for MSCOCO are in the cfg directory. Example commands:

wget --no-clobber https://github.com/hank-ai/darknet/releases/download/v2.0/yolov4-tiny.weights
darknet_02_display_annotated_images coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg
darknet_03_display_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 people are expected to train their own networks. MSCOCO is normally used to confirm that everything is working correctly.

Building

The various build methods available in the past (pre-2023) have been merged together into a single unified solution. Darknet requires C++17 or newer, OpenCV, and uses CMake to generate the necessary project files.

You do not need to know C++ to build, install, nor run Darknet/YOLO, the same way you don't need to be a mechanic to drive a car.

Beware if you are following old tutorials with more complicated build steps, or build steps that don't match what is in this readme. The new build steps as described below started in August 2023.

Software developers are encouraged to visit https://darknetcv.ai/ to get information on the internals of the Darknet/YOLO object detection framework.

Google Colab

The Google Colab instructions are the same as the Linux instructions. Several Jupyter notebooks are available showing how to do certain tasks, such as training a new network.

See the notebooks in the colab subdirectory, and/or follow the Linux instructions below.

WSL

If you have a modern version of Windows and a decent computer, then the use of WSL (Windows Subsystem for Linux) and Ubuntu 24.04 LTS is highly recommended.

WSL is a feature in Windows which allows people to run Linux-based applications from within their Windows desktop. This is similar to a virtual machine with host/guest extensions. Linux apps running in WSL have access to the GPU if you install the Linux NVIDIA driver for WSL, and you can train a new network with Darknet/YOLO running within WSL.

Once WSL is installed, run sudo apt-get update at least once from your Ubuntu command prompt to get the updated list of packages, and then follow the usual Linux instructions.

If you don't want to use Darknet/YOLO from within WSL, then skip ahead to the Windows instructions.

Linux CMake Method

Darknet build tutorial for Linux

These instructions assume (but do not require!) a system running Ubuntu 22.04. Adapt as necessary if you're using a different distribution.

sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/src
cd ~/src
git clone https://github.com/hank-ai/darknet
cd darknet
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release ..
make -j4 package
sudo dpkg -i darknet-<INSERT-VERSION-YOU-BUILT-HERE>.deb

If you are using an older version of CMake then you'll need to upgrade CMake before you can run the cmake command above. Upgrading CMake on Ubuntu can be done with the following commands:

sudo apt-get purge cmake
sudo snap install cmake --classic

If using bash as your command shell you'll want to re-start your shell at this point. If using fish, it should immediately pick up the new path.

Advanced users:

If you want to build a RPM installation file instead of a DEB file, see the relevant lines in CM_package.cmake. Prior to running make -j4 package you'll need to edit these two lines:

SET (CPACK_GENERATOR "DEB")
# SET (CPACK_GENERATOR "RPM")

For distros such as Centos and OpenSUSE, you'll need to switch those two lines in CM_package.cmake to be:

# SET (CPACK_GENERATOR "DEB")
SET (CPACK_GENERATOR "RPM")

To install the installation package once it has finished building, use the usual package manager for your distribution. For example, on Debian-based systems such as Ubuntu:

sudo dpkg -i darknet-2.0.1-Linux.deb

Installing the .deb package will copy the following files:

You are now done! Darknet has been built and installed into /usr/bin/. Run this to test: darknet version.

If you don't have /usr/bin/darknet then this means you did not install it, you only built it! Make sure you install the .deb or .rpm file as described above.

Windows CMake Method

Before building Darknet/YOLO for Windows please see the note about using WSL. (Spoiler ... Darknet/YOLO works great in WSL!)

Open a normal cmd.exe command prompt window and run the following commands:

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:

IMPORTANT: Once everything is downloaded and installed, click on the "Windows Start" menu again and select 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 use a normal command prompt or ssh into the device and manually run "\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\VsDevCmd.bat".

Lots of people make the same mistake and think they can skip the previous step. Please don't skip this step! Do not use a normal command prompt, nor PowerShell! Re-read the steps above to see what kind of window you must be using. Anytime you want to use Visual Studio from the command prompt to compile C++ code you must use the Visual Studio developer command prompt as described above.

Once you have the Developer Command Prompt running as described above run the following commands to install Microsoft VCPKG, which will then be used to build OpenCV:

cd c:\
mkdir c:\src
cd c:\src
git clone https://github.com/microsoft/vcpkg
cd 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 at this last step as it can take a long time to run. It needs to download and build many things.

Advanced users:

Note there are many other optional modules you may want to add when building OpenCV. Run .\vcpkg.exe search opencv to see the full list.

Once all of the previous steps have finished successfully, you need to clone Darknet and build it. During this step we also need to tell CMake where vcpkg is located so it can find OpenCV and other dependencies. Make sure you continue to use the Developer Command Prompt as described above when you run these commands:

cd c:\src
git clone https://github.com/hank-ai/darknet.git
cd darknet
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=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 get an error about some missing CUDA or cuDNN DLLs such as cublas64_12.dll, then manually copy the CUDA .dll files into the same output directory as Darknet.exe. For example:

copy "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.2\bin\*.dll" src-cli\Release\

(That is an example! Check to make sure what version you are running, and run the command that is appropriate for what you have installed.)

Once the files have been copied, re-run the last msbuild.exe command to generate the NSIS installation package:

msbuild.exe /property:Platform=x64;Configuration=Release PACKAGE.vcxproj

Advanced users:

Note that the output of the cmake command is a normal Visual Studio solution file, Darknet.sln. If you are a software developer who regularly 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 this file you can run: C:\src\Darknet\build\src-cli\Release\darknet.exe. Run this to test: C:\src\Darknet\build\src-cli\Release\darknet.exe --version.

To correctly install Darknet, the libraries, the include files, and the necessary DLLs, run the NSIS installation wizard that was built in the last step. See the file darknet-<INSERT-VERSION-YOU-BUILT-HERE>-win64.exe in the build directory. For example:

darknet-<INSERT-VERSION-YOU-BUILT-HERE>-win64.exe

Installing the NSIS installation package will:

You are now done! Once the installation wizard has finished, Darknet will have been installed into C:\Program Files\Darknet\. Run this to test: C:\Program Files\Darknet\bin\darknet.exe version.

If you don't have C:/Program Files/darknet/bin/darknet.exe then this means you did not install it, you only built it! Make sure you go through each panel of the NSIS installation wizard in the previous step.

Using Darknet

CLI

The following is not the full list of all commands supported by Darknet.

In addition to the Darknet CLI, also note the DarkHelp project CLI which provides an alternative CLI to Darknet/YOLO. The DarkHelp CLI also has several advanced features that are not available directly in Darknet. You can use both the Darknet CLI and the DarkHelp CLI together, they are not mutually exclusive.

For most of the commands shown below, you'll need the .weights file with the corresponding .names and .cfg files. You can either train your own network (highly recommended!) or download a neural network that someone has already trained and made available for free on the internet. Examples of pre-trained datasets include:

Commands to run include:

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

darknet detector calc_anchors animals.data -num_of_clusters 6 -width 320 -height 256

Training

Quick links to relevant sections of the Darknet/YOLO FAQ:

The simplest way to annotate and train is with the use of DarkMark to create all of the necessary Darknet files. This is definitely the recommended way to train a new neural network.

If you'd rather manually setup the various files to train a custom network:

dog
cat
bird
horse

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

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 the progress of training can be observed 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

Other Tools and Links

Roadmap

Last updated 2024-11-02:

Completed

Short-term goals

Mid-term goals

Long-term goals