rusthw

Marco de detección de objetos Darknet y YOLO

Darknet es un marco de red neuronal de código abierto desarrollado principalmente en C y C++, con soporte para aceleración CUDA.

YOLO (Solo miras una vez), un sistema de detección de objetos en tiempo real de vanguardia, es una implementación destacada dentro del marco Darknet.

Lea más sobre cómo Hank.ai contribuye a la comunidad Darknet/YOLO:

Anuncio de Darknet V3 "Jazz": https://darknetcv.ai/blog/annunciando-darknet-v3-jazz

Sitio web Darknet/YOLO: https://darknetcv.ai/

Preguntas frecuentes sobre Darknet/YOLO: https://darknetcv.ai/faq/

Servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW

Papeles

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

2. YOLOv4 escalado: https://arxiv.org/abs/2102.12725

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

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

Información general

El marco Darknet/YOLO mantiene su posición como uno de los sistemas de detección de objetos más rápidos y precisos.

Ventajas clave de Darknet/YOLO:

Gratis y de código abierto: Darknet/YOLO es completamente de código abierto, lo que permite la integración gratuita en proyectos existentes, incluidos los comerciales.

Alto rendimiento: Darknet V3 ("Jazz"), lanzado en octubre de 2024, demuestra un rendimiento notable, logrando hasta 1000 FPS en el conjunto de datos LEGO con una GPU NVIDIA RTX 3090.

Versatilidad: la versión de CPU de Darknet/YOLO se puede implementar en varias plataformas, incluidas Raspberry Pi, servidores en la nube, computadoras de escritorio, portátiles y potentes equipos de capacitación. La versión GPU requiere una GPU NVIDIA compatible con CUDA.

Compatibilidad multiplataforma: Se sabe que Darknet/YOLO funciona sin problemas en Linux, Windows y Mac.

Control de versiones de la red oscura

Darknet 0.x: Se refiere a la herramienta Darknet original desarrollada por Joseph Redmon entre 2013 y 2017. Carecía de un número de versión formal.

Darknet 1.x: esta versión fue mantenida por Alexey Bochkovskiy de 2017 a 2021. También carecía de un número de versión formal.

Darknet 2.x "OAK": esta versión fue patrocinada por Hank.ai y mantenida por Stéphane Charette a partir de 2023. Esta fue la primera versión que introdujo un comando de versión. Devolvió la versión 2.x hasta finales de 2024.

Darknet 3.x "JAZZ": esta versión, lanzada en octubre de 2024, marcó una importante fase de desarrollo, introduciendo una nueva API de C y C++, rendimiento mejorado y numerosas correcciones de errores.

Pesas preentrenadas MSCOCO

Se han entrenado previamente varias versiones populares de YOLO en el conjunto de datos de MSCOCO. Este conjunto de datos consta de 80 clases, que se pueden encontrar en el archivo cfg/coco.names.

Pesos previamente entrenados disponibles para descargar:

1. YOLOv2 (noviembre de 2016)

* YOLOv2-pequeño

* YOLOv2-completo

2. YOLOv3 (mayo de 2018)

* YOLOv3-pequeño

* YOLOv3-completo

3. YOLOv4 (mayo de 2020)

* YOLOv4-pequeño

* YOLOv4-completo

4. YOLOv7 (agosto de 2022)

* YOLOv7-pequeño

* YOLOv7-completo

Uso de ejemplo:

`

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.nombres yolov4-tiny.cfg yolov4-tiny.weights image1.jpg

DarkHelp coco.nombres yolov4-tiny.cfg yolov4-tiny.pesos video1.avi

`

Nota: Las pesas previamente entrenadas de MSCOCO se proporcionan principalmente con fines de demostración. Se recomienda encarecidamente la formación de redes personalizadas; normalmente se utiliza MSCOCO para verificar la funcionalidad del sistema.

Construyendo la red oscura

Darknet se basa en C++ 17 o posterior, OpenCV, y utiliza CMake para generar archivos de proyecto.

Proceso de construcción:

1. Google Colab: las instrucciones de Google Colab son las mismas que las de Linux. Consulte el subdirectorio colab para ver los cuadernos de Jupyter que muestran tareas específicas.

2. Método CMake de Linux:

*Requisitos previos:

* Herramientas esenciales para la compilación: 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

* Instalación:

* Crear directorios de trabajo: mkdir ~/srccd ~/src

* Clonar el repositorio: git clone https://github.com/hank-ai/darknet

* Navegue al directorio Darknet: cd darknet

* Crear un directorio de compilación: mkdir build

* Construir Darknet:

* compilación de cd

* cmake -DCMAKEBUILDTYPE=Lanzar ..

* hacer -j4

* paquete

* Instalar el paquete: sudo dpkg -i darknet-VERSION.deb

* Opcional: Instalación CUDA/cuDNN

* Descargue e instale CUDA desde https://developer.nvidia.com/cuda-downloads

* Descargue e instale cuDNN desde https://developer.nvidia.com/rdp/cudnn-download o https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager- descripción general de la instalación

* Asegúrese de poder ejecutar nvcc y nvidia-smi. Es posible que deba modificar su variable PATH.

* Si instala CUDA o cuDNN más adelante o actualiza a una versión más reciente, asegúrese de reconstruir Darknet después de modificar su entorno.

3. Método CMake de Windows:

*Requisitos previos:

* Git: Winget instala Git.Git

* CMake: instalar Kitware.CMake

* NSIS: Winget instala nsis.nsis

* Visual Studio 2022 Community Edition: instale Microsoft.VisualStudio.2022.Community

* Modifique la instalación de Visual Studio para incluir compatibilidad con C++:

* Abra el instalador de Visual Studio

* Haga clic en "Modificar"

* Seleccione "Desarrollo de escritorio con C++"

* Haga clic en "Modificar" y luego en "Sí"

* Instalación:

* Abra el símbolo del sistema del desarrollador para VS 2022 (no PowerShell).

* Instalar Microsoft VCPKG:

* Centros para el Control y la Prevención de Enfermedades:

* mkdir c:srccd c:src

* clon de git https://github.com/microsoft/vcpkg

* cd vcpkg

* bootstrap-vcpkg.bat .vcpkg.exe integrar

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

* Clonar Darknet y construir:

* cdc:src

* clon de git https://github.com/hank-ai/darknet.git

* cd red oscura

* compilación mkdir

* compilación de cd

* cmake -DCMAKEBUILDTYPE=Versión -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

* Opcional: Instalación CUDA/cuDNN

* Descargue e instale CUDA desde https://developer.nvidia.com/cuda-downloads

* Descargue e instale cuDNN desde https://developer.nvidia.com/rdp/cudnn-download o https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows

* Descomprima cuDNN y copie los directorios bin, include y lib en C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[versión] (sobrescribiendo los archivos existentes si es necesario).

* Asegúrese de poder ejecutar nvcc.exe. Es posible que deba modificar su variable PATH.

Usando la red oscura

CLI (interfaz de línea de comando)

Uso general: Darknet ofrece una interfaz de línea de comandos (CLI) para interactuar con sus funcionalidades. No es exhaustivo; Consulte la CLI del proyecto DarkHelp para obtener funciones adicionales.

Modelos previamente entrenados: para la mayoría de los comandos, necesitará el archivo .weights junto con los archivos .names y .cfg correspondientes. Puede entrenar su propia red (muy recomendable) o utilizar modelos previamente entrenados disponibles en línea. Los ejemplos incluyen:

* LEGO Gears (detección de objetos en imágenes)

* Rolodex (detección de texto en imágenes)

* MSCOCO (detección de objetos estándar de clase 80)

Comandos comunes:

Ayuda: ayuda de la red oscura

Versión: versión darknet

Predicción con una imagen:

* V2: prueba del detector darknet cars.data cars.cfg cars_best.weights image1.jpg

* V3: darknet02displayannotatedimages cars.cfg image1.jpg

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

Coordenadas de salida:

* V2: prueba del detector de red oscura animales.datos animales.cfg animalesbest.weights -extoutput dog.jpg

* V3: darknet01inference_images animales perro.jpg

* DarkHelp: DarkHelp --json animales.cfg animales.nombres animales_mejor.pesos perro.jpg

Procesamiento de vídeo:

* V2:

* Demostración del detector darknet animales.data animales.cfg animalesbest.weights -extoutput test.mp4 (predicción de vídeo)

* Demostración del detector de darknet animales.data animales.cfg animales_best.weights -c 0 (entrada de cámara web)

* Demostración del detector darknet animales.datos animales.cfg animalesbest.weights test.mp4 -outfilename res.avi (Guardando resultados en video)

*V3:

* darknet03display_videos animales.cfg test.mp4 (Predicción de vídeo)

* darknet08display_webcam animales (entrada de cámara web)

* darknet05processvideosmultithreaded animales.cfg animales.nombres animales_mejores.pesos prueba.mp4 (Guardando resultados en video)

* Ayuda oscura:

* DarkHelp animales.cfg animales.nombres animales_mejores.pesos prueba.mp4 (predicción de vídeo)

* DarkHelp animales.cfg animales.nombres animales_mejores.pesos prueba.mp4 (Guardando resultados en video)

Salida JSON:

* V2: demostración del detector darknet animales.datos animales.cfg animalesbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput

* V3: darknet06imagestojson animales image1.jpg

* DarkHelp: DarkHelp --json animales.nombres animales.cfg animales_mejor.pesos imagen1.jpg

Selección de GPU: demostración del detector de red oscura animales.data animales.cfg animales_best.weights -i 1 test.mp4

Evaluación de precisión:

* mapa del detector de darknet conducción.datos conducción.cfg conducción_mejor.pesos... (mAP@IoU=50)

* Mapa del detector de darknet animales.datos animales.cfg animalesbest.weights -iouthresh 0,75 (mAP@IoU=75)

Cálculo de anclaje: (use DarkMark para un recálculo de anclaje óptimo)

* detector de red oscura calcanchors animales.data -numof_clusters 6 -ancho 320 -alto 256

Capacitación en red:

* detector de red oscura -mapa -dont_show entrenar animales.datos animales.cfg

Entrenando una nueva red

DarkMark: el enfoque recomendado para la anotación y la capacitación es utilizar DarkMark, que automatiza el proceso de generación de los archivos Darknet necesarios.

Configuración manual:

1. Cree un directorio de proyectos: por ejemplo, ~/nn/animals/ para entrenar una red para detectar animales.

2. Copie un archivo de configuración: seleccione un archivo de configuración de plantilla de cfg/ (por ejemplo, cfg/yolov4-tiny.cfg) y colóquelo en el directorio de su proyecto.

3. Cree un archivo .names: en el mismo directorio, cree un archivo de texto llamado animales.nombres. Enumere las clases que desea detectar, una por línea, sin líneas en blanco ni comentarios. Ejemplo:

`

perro

gato

pájaro

caballo

`

4. Cree un archivo .data: en el mismo directorio, cree un archivo de texto llamado animales.data. Este archivo contiene información sobre sus datos de entrenamiento. Ejemplo:

`

clases=4

tren=/home/nombre de usuario/nn/animals/animals_train.txt

valid=/home/nombre de usuario/nn/animals/animals_valid.txt

nombres=/home/nombredeusuario/nn/animals/animals.nombres

copia de seguridad=/home/nombre de usuario/nn/animales

`

5. Directorio de conjunto de datos: cree un directorio para almacenar sus imágenes y las anotaciones correspondientes (por ejemplo, ~/nn/animals/dataset). Cada imagen necesitará un archivo .txt asociado que describa las anotaciones. Estos archivos .txt deben seguir un formato específico y es mejor generarlos utilizando DarkMark o software similar.

6. Archivos de entrenamiento y validación: cree los archivos de texto "entrenamiento" y "válidos" como se especifica en su archivo .data. Estos archivos enumeran las imágenes que se utilizarán para la capacitación y la validación, respectivamente.

7. Modifique el archivo de configuración:

* Tamaño de lote: Establecer lote = 64.

* Subdivisiones: Comienza con subdivisiones=1. Aumente según sea necesario según la capacidad de memoria de su GPU.

Lotes máximos: utilice maxbatches=2000 número de clases. En este caso, maxbatches=8000.

* Pasos: establezca los pasos en 80% y 90% de max_batches. Ejemplo: pasos=6400,7200.

* Ancho y Alto: Ajusta las dimensiones de la red (ancho y alto). Consulte las preguntas frecuentes de Darknet/YOLO para obtener orientación sobre cómo determinar los tamaños óptimos.

* Clases: actualice clases=... para que coincida con el número de clases en su archivo .names (en este caso, clases=4).

Filtros: ajuste los filtros =... en las secciones [convolucionales] antes de cada sección [yolo]. Calcule usando filtros = (número de clases + 5) 3. En este caso, filtros = 27.

8. Inicie la capacitación: navegue hasta el directorio de su proyecto y ejecute el siguiente comando:

`

detector de red oscura -mapa -dont_show entrenar animales.datos animales.cfg

`

* Salida detallada: para obtener información de capacitación más detallada, utilice --verbose.

* Progreso: los mejores pesos se guardarán como animales_best.weights y el progreso del entrenamiento se puede monitorear a través del archivo chart.png.

Otras herramientas y enlaces

DarkMark: para gestión de proyectos Darknet/YOLO, anotación de imágenes, verificación de anotaciones y generación de archivos de entrenamiento.

DarkHelp: una CLI alternativa sólida a Darknet, con características como mosaico de imágenes, seguimiento de objetos y una API C++ para aplicaciones comerciales.

Preguntas frecuentes sobre Darknet/YOLO: https://darknetcv.ai/faq/

Canal YouTube de Stéphane Charette: encuentre tutoriales y vídeos de ejemplo: https://www.youtube.com/channel/UCOQ-nJ8l6kG3153g09XwY8g

Servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW

Hoja de ruta

Última actualización: 2024-10-30

Terminado:

1. Se reemplazó qsort() con std::sort() cuando corresponda durante el entrenamiento (algunos casos restantes).

2. Se eliminaron check_mistakes, getchar() y system().

3. Se convirtió Darknet para usar el compilador C++ (g++ en Linux, VisualStudio en Windows).

4. Se corrigió la compilación de Windows.

5. Se corrigió el soporte de Python.

6. Biblioteca Darknet construida.

7. Etiquetas reactivadas en las predicciones (código "alfabeto").

8. Código CUDA/GPU rehabilitado.

9. CUDNN rehabilitado.

10. Se rehabilitó la mitad CUDNN.

11. Se eliminó la arquitectura CUDA codificada.

12. Información de versión CUDA mejorada.

13. AVX rehabilitado.

14. Se eliminaron soluciones antiguas y Makefile.

15. OpenCV se hizo no opcional.

16. Se eliminó la dependencia de la antigua biblioteca pthread.

17. STB eliminado.

18. Reescribió CMakeLists.txt para usar la nueva detección CUDA.

19. Se eliminó el antiguo código "alfabeto" y se eliminaron más de 700 imágenes en datos/etiquetas.

20. Implementación de compilación externa.

21. Salida del número de versión mejorada.

22. Optimizaciones del rendimiento relacionadas con la formación (en curso).

23. Optimizaciones de rendimiento relacionadas con la inferencia (en curso).

24. Empleado pase por referencia cuando sea posible.

25. Archivos .hpp limpios.

26. Reescribió darknet.h.

27. Usé cv::Mat como un objeto C++ adecuado en lugar de convertirlo a void*.

28. Se corrigió o estandarizó cómo se utiliza la estructura de la imagen interna.

29. Se corrigió la compilación para dispositivos Jetson basados ​​en ARM (los nuevos dispositivos Jetson Orin están funcionando).

30. API de Python mejorada en V3.

Metas a corto plazo:

1. Reemplace printf() con std::cout (en progreso).

2. Investigue el antiguo soporte de la cámara ZED.

3. Mejorar y estandarizar el análisis de la línea de comandos (en progreso).

Metas a mediano plazo:

1. Elimine todo el código char* y reemplácelo con std::string.

2. Elimine las advertencias del compilador y garantice un manejo coherente de las advertencias (en progreso).

3. Utilice cv::Mat de manera más efectiva en lugar de estructuras de imágenes personalizadas en C (en progreso).

4. Reemplace la funcionalidad de lista anterior con std::vector o std::list.

5. Se corrigió la compatibilidad con imágenes en escala de grises de 1 canal.

6. Agregue soporte para imágenes de canal N donde N > 3 (por ejemplo, imágenes con una profundidad adicional o un canal térmico).

7. Limpieza de código en curso (en progreso).

Metas a largo plazo:

1. Solucione los problemas de CUDA/CUDNN con todas las GPU.

2. Vuelva a escribir el código CUDA+cuDNN.

3. Explore la posibilidad de agregar compatibilidad con GPU que no sean NVIDIA.

4. Implementar soporte para cuadros delimitadores girados o un atributo de "ángulo".

5. Agregue soporte para puntos clave/esqueletos.

6. Implementar mapas de calor (en progreso).

7. Implementar la segmentación.