rusthw

Darknet Object Detection Framework und YOLO

Darknet ist ein Open-Source-Framework für neuronale Netzwerke, das hauptsächlich in C und C++ entwickelt wurde und die CUDA-Beschleunigung unterstützt.

YOLO (You Only Look Once), ein hochmodernes Echtzeit-Objekterkennungssystem, ist eine prominente Implementierung innerhalb des Darknet-Frameworks.

Lesen Sie mehr darüber, wie Hank.ai zur Darknet/YOLO-Community beiträgt:

Ankündigung von Darknet V3 „Jazz“: https://darknetcv.ai/blog/anncreasing-darknet-v3-jazz

Darknet/YOLO-Website: https://darknetcv.ai/

Darknet/YOLO-FAQ: https://darknetcv.ai/faq/

Darknet/YOLO Discord-Server: https://discord.gg/zSq8rtW

Papiere

1. YOLOv7: https://arxiv.org/abs/2207.02696

2. Scaled-YOLOv4: https://arxiv.org/abs/2102.12725

3. YOLOv4: https://arxiv.org/abs/2004.10934

4. YOLOv3: https://pjreddie.com/media/files/papers/YOLOv3.pdf

Allgemeine Informationen

Das Darknet/YOLO-Framework behauptet seine Position als eines der schnellsten und genauesten Objekterkennungssysteme.

Hauptvorteile von Darknet/YOLO:

Kostenlos und Open Source: Darknet/YOLO ist vollständig Open Source und ermöglicht die kostenlose Integration in bestehende Projekte, auch kommerzielle.

Hohe Leistung: Darknet V3 („Jazz“), veröffentlicht im Oktober 2024, zeigt eine bemerkenswerte Leistung und erreicht bis zu 1000 FPS im LEGO-Datensatz mit einer NVIDIA RTX 3090 GPU.

Vielseitigkeit: Die CPU-Version von Darknet/YOLO kann auf verschiedenen Plattformen eingesetzt werden, darunter Raspberry Pi, Cloud-Server, Desktops, Laptops und leistungsstarke Trainingsgeräte. Die GPU-Version erfordert eine CUDA-fähige NVIDIA-GPU.

Plattformübergreifende Kompatibilität: Darknet/YOLO funktioniert bekanntermaßen nahtlos unter Linux, Windows und Mac.

Darknet-Versionierung

Darknet 0.x: Dies bezieht sich auf das ursprüngliche Darknet-Tool, das Joseph Redmon zwischen 2013 und 2017 entwickelt hat. Es fehlte eine formelle Versionsnummer.

Darknet 1.x: Diese Version wurde von 2017 bis 2021 von Alexey Bochkovskiy gepflegt. Es fehlte auch eine formelle Versionsnummer.

Darknet 2.x „OAK“: Diese Version wurde von Hank.ai gesponsert und ab 2023 von Stéphane Charette gepflegt. Dies war die erste Veröffentlichung, die einen Versionsbefehl einführte. Es gab die Version 2.x bis Ende 2024 zurück.

Darknet 3.x „JAZZ“: Diese im Oktober 2024 veröffentlichte Version markierte eine bedeutende Entwicklungsphase und führte eine neue C- und C++-API, verbesserte Leistung und zahlreiche Fehlerkorrekturen ein.

Vortrainierte MSCOCO-Gewichte

Verschiedene beliebte YOLO-Versionen wurden auf dem MSCOCO-Datensatz vorab trainiert. Dieser Datensatz besteht aus 80 Klassen, die in der Datei cfg/coco.names zu finden sind.

Vortrainierte Gewichte zum Download verfügbar:

1. YOLOv2 (November 2016)

* YOLOv2-tiny

* YOLOv2-voll

2. YOLOv3 (Mai 2018)

* YOLOv3-tiny

* YOLOv3-voll

3. YOLOv4 (Mai 2020)

* YOLOv4-tiny

* YOLOv4-voll

4. YOLOv7 (August 2022)

* YOLOv7-tiny

* YOLOv7-voll

Beispielverwendung:

`

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

`

Hinweis: Die vortrainierten MSCOCO-Gewichte werden hauptsächlich zu Demonstrationszwecken bereitgestellt. Das Training benutzerdefinierter Netzwerke wird dringend empfohlen, wobei MSCOCO normalerweise zur Überprüfung der Systemfunktionalität verwendet wird.

Darknet aufbauen

Darknet basiert auf C++17 oder neuer, OpenCV, und nutzt CMake, um Projektdateien zu generieren.

Bauablauf:

1. Google Colab: Die Google Colab-Anweisungen sind die gleichen wie die Linux-Anweisungen. Im Unterverzeichnis „colab“ finden Sie Jupyter-Notebooks, die bestimmte Aufgaben darstellen.

2. Linux CMake-Methode:

* Voraussetzungen:

* Build-essential-Tools: sudo apt-get install build-essential

* Git: sudo apt-get install git

* OpenCV: sudo apt-get install libopencv-dev

* CMake: sudo apt-get install cmake

* Installation:

* Arbeitsverzeichnisse erstellen: mkdir ~/srccd ~/src

* Klonen Sie das Repository: Git Clone https://github.com/hank-ai/darknet

* Navigieren Sie zum Darknet-Verzeichnis: cd darknet

* Erstellen Sie ein Build-Verzeichnis: mkdir build

* Darknet aufbauen:

* CD-Build

* cmake -DCMAKEBUILDTYPE=Release ..

* mache -j4

* Paket

* Installieren Sie das Paket: sudo dpkg -i darknet-VERSION.deb

* Optional: CUDA/cuDNN-Installation

* Laden Sie CUDA von https://developer.nvidia.com/cuda-downloads herunter und installieren Sie es

* Laden Sie cuDNN von https://developer.nvidia.com/rdp/cudnn-download oder https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager- herunter und installieren Sie es. Installationsübersicht

* Stellen Sie sicher, dass Sie nvcc und nvidia-smi ausführen können. Möglicherweise müssen Sie Ihre PATH-Variable ändern.

* Wenn Sie CUDA oder cuDNN später installieren oder auf eine neuere Version aktualisieren, stellen Sie sicher, dass Sie Darknet nach der Änderung Ihrer Umgebung neu erstellen.

3. Windows CMake-Methode:

* Voraussetzungen:

* Git: Winget installiert Git.Git

* CMake: Winget installiert Kitware.CMake

* NSIS: Winget installiert nsis.nsis

* Visual Studio 2022 Community Edition: Winget-Installation von Microsoft.VisualStudio.2022.Community

* Ändern Sie die Visual Studio-Installation, um C++-Unterstützung einzuschließen:

* Öffnen Sie das Visual Studio-Installationsprogramm

* Klicken Sie auf „Ändern“

* Wählen Sie „Desktop-Entwicklung mit C++“

* Klicken Sie auf „Ändern“ und dann auf „Ja“.

* Installation:

* Öffnen Sie die Entwickler-Eingabeaufforderung für VS 2022 (nicht PowerShell).

* Installieren Sie Microsoft VCPKG:

* CDC:

* mkdir c:srccd c:src

* Git-Klon https://github.com/microsoft/vcpkg

* cd vcpkg

* Bootstrap-vcpkg.bat .vcpkg.exe integrieren

* .vcpkg.exe installieren, powershell.vcpkg.exe integrieren, opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows installieren

* Darknet klonen und erstellen:

* cd c:src

* Git-Klon https://github.com/hank-ai/darknet.git

* CD Darknet

* mkdir-Build

* CD-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

* Optional: CUDA/cuDNN-Installation

* Laden Sie CUDA von https://developer.nvidia.com/cuda-downloads herunter und installieren Sie es

* Laden Sie cuDNN von https://developer.nvidia.com/rdp/cudnn-download oder https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows herunter und installieren Sie es

* Entpacken Sie cuDNN und kopieren Sie die Verzeichnisse bin, include und lib nach C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[version] (überschreiben Sie ggf. vorhandene Dateien).

* Stellen Sie sicher, dass Sie nvcc.exe ausführen können. Möglicherweise müssen Sie Ihre PATH-Variable ändern.

Nutzung von Darknet

CLI (Befehlszeilenschnittstelle)

Allgemeine Verwendung: Darknet bietet eine Befehlszeilenschnittstelle (CLI) für die Interaktion mit seinen Funktionen. Es ist nicht erschöpfend; Weitere Funktionen finden Sie in der DarkHelp-Projekt-CLI.

Vorab trainierte Modelle: Für die meisten Befehle benötigen Sie die .weights-Datei zusammen mit den entsprechenden .names- und .cfg-Dateien. Sie können entweder Ihr eigenes Netzwerk trainieren (sehr empfehlenswert) oder vorab trainierte Modelle nutzen, die online verfügbar sind. Beispiele hierfür sind:

* LEGO Gears (Objekterkennung in Bildern)

* Rolodex (Texterkennung in Bildern)

* MSCOCO (Standardobjekterkennung der 80er-Klasse)

Allgemeine Befehle:

Hilfe: Darknet-Hilfe

Version: Darknet-Version

Vorhersage mit einem Bild:

* V2: Darknet-Detektortest car.data car.cfg car_best.weights image1.jpg

* V3: darknet02displayannotatedimages cars.cfg image1.jpg

* DarkHelp: DarkHelp cars.cfg cars_best.weights image1.jpg

Ausgabekoordinaten:

* V2: Darknet-Detektortest 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 Hund.jpg

Videoverarbeitung:

* V2:

* Darknet-Detektor-Demo Animals.data Animals.cfg Animalsbest.weights -extoutput test.mp4 (Videovorhersage)

* Darknet-Detektor-Demo Animals.data Animals.cfg Animals_best.weights -c 0 (Webcam-Eingabe)

* Darknet-Detektor-Demo Animals.data Animals.cfg Animalsbest.weights test.mp4 -outfilename res.avi (Ergebnisse im Video speichern)

* V3:

* darknet03display_videos Animals.cfg test.mp4 (Videovorhersage)

* darknet08display_webcam Tiere (Webcam-Eingabe)

* darknet05processvideosmultithreaded Animals.cfg Animals.names Animals_best.weights test.mp4 (Ergebnisse im Video speichern)

* DarkHelp:

* DarkHelp Animals.cfg Animals.names Animals_best.weights test.mp4 (Videovorhersage)

* DarkHelp Animals.cfg Animals.names Animals_best.weights test.mp4 (Ergebnisse im Video speichern)

JSON-Ausgabe:

* V2: Darknet-Detektor-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

GPU-Auswahl: Darknet Detector Demo Animals.data Animals.cfg Animals_best.weights -i 1 test.mp4

Genauigkeitsbewertung:

* Darknet-Detektorkarte fahren.daten fahren.cfg fahren_best.gewichte ... (mAP@IoU=50)

* Darknet-Detektorkarte Animals.data Animals.cfg Animalsbest.weights -iouthresh 0,75 (mAP@IoU=75)

Ankerberechnung: (Verwenden Sie DarkMark für eine optimale Ankerneuberechnung)

* Darknet-Detektor calcanchors Animals.data -numof_clusters 6 -width 320 -height 256

Netzwerktraining:

* Darknet-Detektor -map -dont_show train Animals.data Animals.cfg

Ein neues Netzwerk trainieren

DarkMark: Der empfohlene Ansatz für Anmerkungen und Schulungen ist die Verwendung von DarkMark, das den Prozess der Generierung der erforderlichen Darknet-Dateien automatisiert.

Manuelle Einrichtung:

1. Erstellen Sie ein Projektverzeichnis: Zum Beispiel ~/nn/animals/, um ein Netzwerk zum Erkennen von Tieren zu trainieren.

2. Kopieren Sie eine Konfigurationsdatei: Wählen Sie eine Vorlagenkonfigurationsdatei aus cfg/ aus (z. B. cfg/yolov4-tiny.cfg) und legen Sie sie in Ihrem Projektverzeichnis ab.

3. Erstellen Sie eine .names-Datei: Erstellen Sie im selben Verzeichnis eine Textdatei mit dem Namen Animals.names. Listen Sie die Klassen auf, die Sie erkennen möchten, eine pro Zeile, ohne Leerzeilen oder Kommentare. Beispiel:

`

Hund

Katze

Vogel

Pferd

`

4. Erstellen Sie eine .data-Datei: Erstellen Sie im selben Verzeichnis eine Textdatei mit dem Namen Animals.data. Diese Datei enthält Informationen zu Ihren Trainingsdaten. Beispiel:

`

Klassen=4

train=/home/username/nn/animals/animals_train.txt

valid=/home/username/nn/animals/animals_valid.txt

Namen=/home/Benutzername/nn/animals/animals.names

backup=/home/username/nn/animals

`

5. Datensatzverzeichnis: Erstellen Sie ein Verzeichnis zum Speichern Ihrer Bilder und der entsprechenden Anmerkungen (z. B. ~/nn/animals/dataset). Für jedes Bild ist eine zugehörige TXT-Datei mit einer Beschreibung der Anmerkungen erforderlich. Diese TXT-Dateien müssen einem bestimmten Format entsprechen und werden am besten mit DarkMark oder einer ähnlichen Software erstellt.

6. Trainings- und Validierungsdateien: Erstellen Sie die Textdateien „Training“ und „Valid“, wie in Ihrer .data-Datei angegeben. In diesen Dateien sind die Bilder aufgeführt, die für das Training bzw. die Validierung verwendet werden sollen.

7. Ändern Sie die Konfigurationsdatei:

* Batch-Größe: Batch=64 einstellen.

* Unterteilungen: Beginnen Sie mit Unterteilungen=1. Erhöhen Sie je nach Bedarf die Speicherkapazität Ihrer GPU.

Max. Batches: Verwenden Sie maxbatches=2000 numberofclasses. In diesem Fall ist maxbatches=8000.

* Schritte: Stellen Sie die Schritte auf 80 % und 90 % von max_batches ein. Beispiel: Schritte=6400,7200.

* Breite und Höhe: Passen Sie die Netzwerkabmessungen (Breite und Höhe) an. Hinweise zur Bestimmung optimaler Größen finden Sie in den Darknet/YOLO-FAQ.

* Klassen: Aktualisieren Sie „classes=...“ so, dass es der Anzahl der Klassen in Ihrer .names-Datei entspricht (in diesem Fall „classes=4“).

Filter: Passen Sie filter=... in den [Faltungs]-Abschnitten vor jedem [yolo]-Abschnitt an. Berechnen Sie mit Filtern = (Anzahl der Klassen + 5) 3. In diesem Fall sind Filter = 27.

8. Training starten: Navigieren Sie zu Ihrem Projektverzeichnis und führen Sie den folgenden Befehl aus:

`

Darknet-Detektor -map -dont_show train Animals.data Animals.cfg

`

* Ausführliche Ausgabe: Für detailliertere Trainingsinformationen verwenden Sie --verbose.

* Fortschritt: Die besten Gewichte werden als Animals_best.weights gespeichert und der Trainingsfortschritt kann über die Datei chart.png überwacht werden.

Andere Tools und Links

DarkMark: Für Darknet/YOLO-Projektmanagement, Bildanmerkung, Anmerkungsüberprüfung und Erstellung von Trainingsdateien.

DarkHelp: Eine robuste alternative CLI zu Darknet mit Funktionen wie Bildkacheln, Objektverfolgung und einer C++-API für kommerzielle Anwendungen.

Darknet/YOLO-FAQ: https://darknetcv.ai/faq/

Stéphane Charettes YouTube-Kanal: Hier finden Sie Tutorials und Beispielvideos: https://www.youtube.com/channel/UCOQ-nJ8l6kG3153g09XwY8g

Darknet/YOLO Discord-Server: https://discord.gg/zSq8rtW

Roadmap

Letzte Aktualisierung: 30.10.2024

Vollendet:

1. Während des Trainings wurde qsort() gegebenenfalls durch std::sort() ersetzt (einige verbleibende Fälle).

2. check_mistakes, getchar() und system() entfernt.

3. Konvertierung von Darknet zur Verwendung des C++-Compilers (g++ unter Linux, VisualStudio unter Windows).

4. Windows-Build korrigiert.

5. Python-Unterstützung behoben.

6. Erstellte Darknet-Bibliothek.

7. Beschriftungen für Vorhersagen wieder aktiviert („Alphabet“-Code).

8. CUDA/GPU-Code wieder aktiviert.

9. CUDNN erneut aktiviert.

10. CUDNN-Hälfte wieder aktiviert.

11. Die hartcodierte CUDA-Architektur wurde entfernt.

12. Verbesserte CUDA-Versionsinformationen.

13. AVX erneut aktiviert.

14. Alte Lösungen und Makefile entfernt.

15. OpenCV nicht optional gemacht.

16. Abhängigkeit von der alten pthread-Bibliothek entfernt.

17. STB entfernt.

18. CMakeLists.txt neu geschrieben, um die neue CUDA-Erkennung zu verwenden.

19. Alter „Alphabet“-Code entfernt und über 700 Bilder in Daten/Beschriftungen gelöscht.

20. Out-of-Source-Build implementiert.

21. Verbesserte Ausgabe der Versionsnummer.

22. Leistungsoptimierungen im Zusammenhang mit dem Training (laufend).

23. Leistungsoptimierungen im Zusammenhang mit Inferenz (laufend).

24. Wenn möglich, werden Pass-by-Referenzen eingesetzt.

25. .hpp-Dateien bereinigt.

26. Darknet.h neu geschrieben.

27. cv::Mat als richtiges C++-Objekt verwendet, anstatt in void* umzuwandeln.

28. Die Verwendung der internen Bildstruktur wurde festgelegt oder standardisiert.

29. Build für ARM-basierte Jetson-Geräte korrigiert (neue Jetson Orin-Geräte funktionieren).

30. Verbesserte Python-API in V3.

Kurzfristige Ziele:

1. Ersetzen Sie printf() durch std::cout (in Bearbeitung).

2. Untersuchen Sie die alte ZED-Kameraunterstützung.

3. Verbesserung und Standardisierung der Befehlszeilenanalyse (in Bearbeitung).

Mittelfristige Ziele:

1. Entfernen Sie den gesamten char*-Code und ersetzen Sie ihn durch std::string.

2. Eliminieren Sie Compiler-Warnungen und stellen Sie eine konsistente Warnungsbehandlung sicher (in Bearbeitung).

3. Nutzen Sie cv::Mat effektiver anstelle von benutzerdefinierten Bildstrukturen in C (in Bearbeitung).

4. Ersetzen Sie die alte Listenfunktionalität durch std::vector oder std::list.

5. Unterstützung für 1-Kanal-Graustufenbilder behoben.

6. Fügen Sie Unterstützung für N-Kanal-Bilder hinzu, bei denen N > 3 ist (z. B. Bilder mit zusätzlicher Tiefe oder Wärmekanal).

7. Laufende Codebereinigung (in Bearbeitung).

Langfristige Ziele:

1. Beheben Sie CUDA/CUDNN-Probleme mit allen GPUs.

2. Schreiben Sie den CUDA+cuDNN-Code neu.

3. Entdecken Sie das Hinzufügen von Unterstützung für Nicht-NVIDIA-GPUs.

4. Implementieren Sie die Unterstützung für gedrehte Begrenzungsrahmen oder ein „Winkel“-Attribut.

5. Unterstützung für Schlüsselpunkte/Skelette hinzufügen.

6. Heatmaps implementieren (in Bearbeitung).

7. Segmentierung implementieren.