Marco de detección de objetos Darknet y YOLO
Darknet es un marco de red neuronal de código abierto escrito en C, C++ y CUDA.
YOLO (Solo miras una vez) es un sistema de detección de objetos en tiempo real de última generación que se ejecuta en el marco Darknet.
Lea cómo Hank.ai está ayudando a la comunidad Darknet/YOLO
Anuncio de Darknet V3 "Jazz"
Consulte el sitio web Darknet/YOLO
Lea las preguntas frecuentes sobre Darknet/YOLO
Únase al servidor de discordia Darknet/YOLO
Papeles
1. Papel YOLOv7
2. Escala de papel-YOLOv4
3. Papel YOLOv4
4. Papel YOLOv3
Información general
El marco Darknet/YOLO sigue siendo más rápido y preciso que otros marcos y versiones de YOLO.
Este marco es completamente gratuito y de código abierto. Puede incorporar Darknet/YOLO en proyectos y productos existentes, incluidos los comerciales, sin necesidad de licencia ni pago de una tarifa.
Darknet V3 ("Jazz") lanzado en octubre de 2024 puede ejecutar con precisión los videos del conjunto de datos LEGO a hasta 1000 FPS cuando se usa una GPU NVIDIA RTX 3090, lo que significa que Darknet/YOLO lee, redimensiona y procesa cada cuadro de video en 1 milisegundo o menos.
Únase al servidor Darknet/YOLO Discord si necesita ayuda o desea hablar sobre Darknet/YOLO: https://discord.gg/zSq8rtW
La versión CPU de Darknet/YOLO puede ejecutarse en dispositivos simples como Raspberry Pi, servidores en la nube y colab, computadoras de escritorio, portátiles y equipos de entrenamiento de alta gama. La versión GPU de Darknet/YOLO requiere una GPU compatible con CUDA de NVIDIA.
Se sabe que Darknet/YOLO funciona en Linux, Windows y Mac. Consulte las instrucciones de construcción a continuación.
Versión de la red oscura
La herramienta Darknet original escrita por Joseph Redmon entre 2013 y 2017 no tenía un número de versión. Consideramos esta versión 0.x.
El siguiente repositorio popular de Darknet mantenido por Alexey Bochkovskiy entre 2017 y 2021 tampoco tenía un número de versión. Consideramos esta versión 1.x.
El repositorio Darknet patrocinado por Hank.ai y mantenido por Stéphane Charette a partir de 2023 fue el primero con un comando de versión. Desde 2023 hasta finales de 2024, devolvió la versión 2.x "OAK".
El objetivo era intentar romper la menor cantidad de funcionalidad existente mientras se familiarizaba con el código base.
Los cambios clave en esta versión incluyen:
1. Reescribió los pasos de compilación para tener una forma unificada de compilar usando CMake tanto en Windows como en Linux.
2. Convirtió el código base para usar el compilador C++.
3. Chart.png mejorado durante el entrenamiento.
4. Corrección de errores y optimizaciones relacionadas con el rendimiento, principalmente relacionadas con la reducción del tiempo que lleva entrenar una red.
La última rama de este código base es la versión 2.1 en la rama v2.
La siguiente fase de desarrollo comenzó a mediados de 2024 y se lanzó en octubre de 2024. El comando de versión ahora devuelve 3.x "JAZZ".
Siempre puede realizar un pago de la rama v2 anterior si necesita ejecutar uno de estos comandos. Háganos saber para que podamos investigar cómo volver a agregar los comandos que faltan.
Los cambios clave en esta versión incluyen:
1. Se eliminaron muchos comandos antiguos y no mantenidos.
2. Muchas optimizaciones de rendimiento, tanto durante el entrenamiento como durante la inferencia.
3. Se modificó la API C heredada; las aplicaciones que utilizan la API Darknet original necesitarán modificaciones menores: https://darknetcv.ai/api/api.html
4. Nueva API Darknet V3 C y C++: https://darknetcv.ai/api/api.html
5. Nuevas aplicaciones y código de muestra en src-examples: https://darknetcv.ai/api/files.html
Pesas preentrenadas MSCOCO
Se entrenaron previamente varias versiones populares de YOLO para mayor comodidad en el conjunto de datos MSCOCO. Este conjunto de datos tiene 80 clases, que se pueden ver en el archivo de texto cfg/coco.names.
Hay varios otros conjuntos de datos más simples y pesos previamente entrenados disponibles para probar Darknet/YOLO, como LEGO Gears y Rolodex. Consulte las preguntas frecuentes de Darknet/YOLO para obtener más detalles.
Los pesos previamente entrenados de MSCOCO se pueden descargar desde varias ubicaciones diferentes y también están disponibles para descargar desde este repositorio:
1. YOLOv2, noviembre de 2016
- YOLOv2-diminuto
- YOLOv2-completo
2. YOLOv3, mayo de 2018
- YOLOv3-diminuto
- YOLOv3-completo
3. YOLOv4, mayo de 2020
- YOLOv4-diminuto
- YOLOv4-completo
4. YOLOv7, agosto de 2022
- YOLOv7-diminuto
- YOLOv7-completo
Las pesas previamente entrenadas de MSCOCO se proporcionan únicamente con fines de demostración. Los archivos .cfg y .names correspondientes a MSCOCO se encuentran en el directorio cfg. Comandos de ejemplo:
`golpear
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
`
Tenga en cuenta que se espera que las personas capaciten sus propias redes. MSCOCO normalmente se utiliza para confirmar que todo funciona correctamente.
Edificio
Los diversos métodos de compilación disponibles en el pasado (antes de 2023) se han fusionado en una única solución unificada. Darknet requiere C++ 17 o posterior, OpenCV, y usa CMake para generar los archivos de proyecto necesarios.
No necesita saber C++ para construir, instalar ni ejecutar Darknet/YOLO, de la misma manera que no necesita ser mecánico para conducir un automóvil.
Tenga cuidado si sigue tutoriales antiguos con pasos de compilación más complicados o pasos de compilación que no coinciden con lo que se encuentra en este archivo Léame. Los nuevos pasos de construcción que se describen a continuación comenzaron en agosto de 2023.
Se anima a los desarrolladores de software a visitar https://darknetcv.ai/ para obtener información sobre los aspectos internos del marco de detección de objetos Darknet/YOLO.
colaboración de google
Las instrucciones de Google Colab son las mismas que las de Linux. Hay varios cuadernos de Jupyter disponibles que muestran cómo realizar determinadas tareas, como entrenar una nueva red.
Consulte los cuadernos en el subdirectorio colab y/o siga las instrucciones de Linux a continuación.
Método CMake de Linux
1. Instale los paquetes necesarios:
`golpear
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clonar el repositorio Darknet:
`golpear
mkdir ~/srccd ~/src
clon de git https://github.com/hank-ai/darknetcd red oscura
`
3. Cree un directorio de compilación y ejecute CMake:
`golpear
mkdir buildcd construir
cmake -DCMAKEBUILDTYPE=Lanzar ..
`
4. Construya la red oscura:
`golpear
hacer -j4
`
5. Empaquete e instale Darknet:
`golpear
paquete
sudo dpkg -i darknet-VERSIÓN.deb
`
6. Verifique la instalación:
`golpear
versión de la red oscura
`
Método CMake de Windows
1. Instale los paquetes necesarios:
`golpear
instalación de Winget Git.Git instalación de Winget Kitware.CMake instalación de Winget nsis.nsis instalación de Winget Microsoft.VisualStudio.2022.Community
`
2. Modifique la instalación de Visual Studio:
- Haga clic en el menú "Inicio de Windows" y ejecute "Visual Studio Installer".
- Haga clic en Modificar.
- Seleccione Desarrollo de escritorio con C++.
- Haga clic en Modificar en la esquina inferior derecha y luego haga clic en Sí.
3. Abra el símbolo del sistema del desarrollador para VS 2022:
- Haga clic en el menú "Inicio de Windows" y seleccione Símbolo del sistema para desarrolladores para VS 2022. No utilice PowerShell para estos pasos.
4. Instale Microsoft VCPKG:
`golpear
cd c:mkdir c:srccd c:src git clon https://github.com/microsoft/vcpkgcd vcpkg
arranque-vcpkg.bat
.vcpkg.exe integrar
instalar .vcpkg.exe integrar powershell.vcpkg.exe instalar opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
5. Clonar el repositorio Darknet:
`golpear
cdc:src
clon de git https://github.com/hank-ai/darknet.gitcd darknet
`
6. Cree un directorio de compilación y ejecute CMake:
`golpear
mkdir buildcd construir
cmake -DCMAKEBUILDTYPE=Versión -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
7. Construya la red oscura:
`golpear
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
`
8. Genere el paquete de instalación de NSIS:
`golpear
msbuild.exe /property:Platform=x64;Configuration=Versión PACKAGE.vcxproj
`
9. Ejecute el asistente de instalación de NSIS:
- Abra el archivo darknet-VERSION.exe en el directorio de compilación. Por ejemplo: darknet-2.0.31-win64.exe.
10. Verificar la instalación:
`golpear
C: Archivos de programa Versión Darknetbindarknet.exe
`
Usando la red oscura
CLI
La siguiente no es la lista completa de todos los comandos admitidos por Darknet.
Además de la CLI de Darknet, también tenga en cuenta la CLI del proyecto DarkHelp, que proporciona una CLI alternativa a Darknet/YOLO. La CLI de DarkHelp también tiene varias funciones avanzadas que no están disponibles directamente en Darknet. Puede utilizar tanto la CLI de Darknet como la CLI de DarkHelp juntas, no son mutuamente excluyentes.
Para la mayoría de los comandos que se muestran a continuación, necesitará el archivo .weights con los archivos .names y .cfg correspondientes. Puede entrenar su propia red (¡muy recomendable!) o descargar una red neuronal que alguien ya haya entrenado y puesto a disposición de forma gratuita en Internet. Ejemplos de conjuntos de datos previamente entrenados incluyen:
1. LEGO Gears (encontrar objetos en una imagen)
2. Rolodex (buscar texto en una imagen)
3. MSCOCO (detección de objetos estándar de clase 80)
Los comandos para ejecutar incluyen:
1. Enumere algunos comandos y opciones posibles para ejecutar:
`golpear
ayuda de la red oscura
`
2. Verifique la versión:
`golpear
versión de la red oscura
`
3. Predice usando una imagen:
-V2:
`golpear
Prueba del detector darknet cars.data cars.cfg cars_best.weights image1.jpg
`
-V3:
`golpear
darknet02displayimágenes anotadas cars.cfg image1.jpg
`
- Ayuda oscura:
`golpear
DarkHelp cars.cfg cars.cfg cars_best.weights imagen1.jpg
`
4. Coordenadas de salida:
-V2:
`golpear
prueba del detector darknet animales.datos animales.cfg animalesmejor.pesos -extoutput perro.jpg
`
-V3:
`golpear
darknet01inference_images animales perro.jpg
`
- Ayuda oscura:
`golpear
DarkHelp --json animales.cfg animales.nombres animales_mejores.pesos perro.jpg
`
5. Trabajar con vídeos:
-V2:
`golpear
Demostración del detector darknet animales.datos animales.cfg animalesmejores.pesos -extoutput test.mp4
`
-V3:
`golpear
darknet03display_videos animales.cfg prueba.mp4
`
- Ayuda oscura:
`golpear
DarkHelp animales.cfg animales.nombres animales_mejores.pesos prueba.mp4
`
6. Lectura desde una cámara web:
-V2:
`golpear
Demostración del detector darknet animales.datos animales.cfg animales_best.weights -c 0
`
-V3:
`golpear
darknet08display_webcam animales
`
7. Guarde los resultados en un vídeo:
-V2:
`golpear
demostración del detector darknet animales.datos animales.cfg animalesbest.pesos prueba.mp4 -outfilename res.avi
`
-V3:
`golpear
darknet05procesovideosmultiproceso animales.cfg animales.nombres animales_mejores.pesos prueba.mp4
`
- Ayuda oscura:
`golpear
DarkHelp animales.cfg animales.nombres animales_mejores.pesos prueba.mp4
`
8. JSON:
-V2:
`golpear
Demostración del detector darknet animales.datos animales.cfg animalesbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
`
-V3:
`golpear
darknet06imagestojson animales image1.jpg
`
- Ayuda oscura:
`golpear
DarkHelp --json animales.nombres animales.cfg animales_mejor.pesos imagen1.jpg
`
9. Ejecutando en una GPU específica:
`golpear
Demostración del detector darknet animales.datos animales.cfg animales_mejores.pesos -i 1 prueba.mp4
`
10. Para comprobar la precisión de la red neuronal:
`golpear
Mapa del detector de darknet conducción.datos conducción.cfg conducción_mejor.pesos...
`
Producción:
`
Id. Nombre AvgPrecision TP FN FP TN Precisión ErrorRate Precisión Recuperación Especificidad FalsePosRate
-- ---- ------------ ------ ------ ------ ------ -------- --------- --------- ------ ----------- ------------
0 vehículo 91,2495 32648 3903 5826 65129 0,9095 0,0905 0,8486 0,8932 0,9179 0,0821
1 motocicleta 80,4499 2936 513 569 5393 0,8850 0,1150 0,8377 0,8513 0,9046 0,0954
2 bicicletas 89,0912 570 124 104 3548 0,9475 0,0525 0,8457 0,8213 0,9715 0,0285
3 personas 76,7937 7072 1727 2574 27523 0,8894 0,1106 0,7332 0,8037 0,9145 0,0855
4 muchos vehículos 64,3089 1068 509 733 11288 0,9087 0,0913 0,5930 0,6772 0,9390 0,0610
5 luz verde 86,8118 1969 239 510 4116 0,8904 0,1096 0,7943 0,8918 0,8898 0,1102
6 luz amarilla 82,0390 126 38 30 1239 0,9525 0,0475 0,8077 0,7683 0,9764 0,0236
7 luz roja 94,1033 3449 217 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885
`
11. Para comprobar la precisión mAP@IoU=75:
`golpear
Mapa del detector de darknet animales.datos animales.cfg animalesbest.weights -iouthresh 0,75
`
12. Recalcular anclajes:
- Mejor hecho en DarkMark.
- En Darknet, utiliza:
`golpear
detector de red oscura calcanchors animales.data -numof_clusters 6 -ancho 320 -alto 256
`
13. Entrene una nueva red:
`golpear
cd ~/nn/animales/
detector de red oscura -mapa -dont_show entrenar animales.datos animales.cfg
`
Capacitación
Enlaces rápidos a secciones relevantes de las preguntas frecuentes de Darknet/YOLO:
1. ¿Cómo debo configurar mis archivos y directorios?
2. ¿Qué archivo de configuración debo utilizar?
3. ¿Qué comando debo usar al entrenar mi propia red?
La forma más sencilla de anotar y entrenar es mediante el uso de DarkMark para crear todos los archivos Darknet necesarios. Esta es definitivamente la forma recomendada de entrenar una nueva red neuronal.
Si prefiere configurar manualmente los distintos archivos para entrenar una red personalizada:
1. Crea una nueva carpeta para tu proyecto:
- Para este ejemplo se creará una red neuronal para detectar animales, por lo que se crea el siguiente directorio: ~/nn/animals/.
2. Copie un archivo de configuración de Darknet como plantilla:
- Por ejemplo, copie cfg/yolov4-tiny.cfg a la carpeta del proyecto. Ahora tendrás ~/nn/animals/animals.cfg.
3. Cree un archivo de texto animales.nombres:
- Este archivo contendrá la lista de clases que desea detectar, una por línea. Por ejemplo:
`
perro
gato
pájaro
caballo
`
4. Cree un archivo de texto animales.data:
- Este archivo especifica las rutas a los datos de entrenamiento y validación, así como los nombres y directorios de respaldo. Por 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. Crea una carpeta para tus imágenes y anotaciones:
- Por ejemplo, esto podría ser ~/nn/animals/dataset. Cada imagen necesitará un archivo .txt correspondiente que describa las anotaciones de esa imagen. El formato de los archivos de anotaciones .txt es muy específico. No puede crear estos archivos a mano ya que cada anotación debe contener las coordenadas exactas de la anotación. Consulte DarkMark u otro software similar para anotar sus imágenes. El formato de anotación de YOLO se describe en las preguntas frecuentes de Darknet/YOLO.
6. Cree los archivos de texto "entrenamiento" y "válido":
- Estos dos archivos de texto deben enumerar individualmente todas las imágenes que Darknet debe usar para entrenar y validar al calcular el% de mAP. Exactamente una imagen por línea. La ruta y los nombres de los archivos pueden ser relativos o absolutos.
7. Modifique su archivo .cfg:
- lote: establecido en 64.
- subdivisiones: comience con 1. Consulte las preguntas frecuentes de Darknet/YOLO si necesita ajustar esto según la disponibilidad de memoria.
- maxbatches: un buen valor inicial es 2000 numberof_classes. Para este ejemplo, tenemos 4 animales, entonces 4 2000 = 8000.
- pasos: establecido en 80% y 90% de maxbatches. Para este ejemplo, usaríamos pasos = 6400,7200 ya que maxbatches se configuró en 8000.
- ancho y alto: Estas son las dimensiones de la red. Las preguntas frecuentes de Darknet/YOLO explican cómo calcular el mejor tamaño a utilizar.
- clases: modifique esta línea con el número de clases en su archivo .names. Para este ejemplo, usaríamos clases=4.
- filtros: en la sección [convolucional] anterior a cada sección [yolo], modifique filtros=... con el valor (númerodeclases + 5) * 3. Para este ejemplo, usaríamos filtros=27.
8. Comienza a entrenar:
`golpear
cd ~/nn/animales/
detector de red oscura -mapa -dont_show entrenar animales.datos animales.cfg
`
Ser paciente. Los mejores pesos se guardarán como animales_best.weights. El progreso del entrenamiento se puede observar viendo el archivo chart.png. Consulte las preguntas frecuentes de Darknet/YOLO para conocer parámetros adicionales que quizás desee utilizar al entrenar una nueva red.
Si desea ver más detalles durante el entrenamiento, agregue el parámetro --verbose. Por ejemplo:
`golpear
detector de red oscura -map -dont_show --verbose train animales.data animales.cfg
`
Otras herramientas y enlaces
1. DarkMark: Para gestionar tus proyectos Darknet/YOLO, anotar imágenes, verificar tus anotaciones y generar los archivos necesarios para entrenar con Darknet.
2. DarkHelp: para una CLI alternativa sólida a Darknet, para usar mosaicos de imágenes, para el seguimiento de objetos en sus videos o para una API C++ sólida que se puede usar fácilmente en aplicaciones comerciales.
3. Preguntas frecuentes sobre Darknet/YOLO: para ayudar a responder sus preguntas.
4. Canal de YouTube de Stéphane: para vídeos tutoriales y de ejemplo.
5. Servidor de discordia Darknet/YOLO: para chatear con otros usuarios de Darknet/YOLO y solicitar ayuda.
Hoja de ruta
Última actualización 2024-10-30:
Terminado
1. Cambie qsort() por std::sort() cuando se use durante el entrenamiento.
2. Deshágase de check_mistakes, getchar() y system().
3. Convierta Darknet para usar el compilador C++.
4. Repare la compilación de Windows.
5. Arreglar la compatibilidad con Python.
6. Cree una biblioteca en la red oscura.
7. Vuelva a habilitar las etiquetas en las predicciones (código "alfabético").
8. Vuelva a habilitar el código CUDA/GPU.
9. Vuelva a habilitar CUDNN.
10. Vuelva a habilitar la mitad CUDNN.
11. No codifique la arquitectura CUDA.
12. Mejor información de la versión CUDA.
13. Vuelva a habilitar AVX.
14. Elimine las soluciones antiguas y Makefile.
15. Haga que OpenCV no sea opcional.
16. Elimine la dependencia de la antigua biblioteca pthread.
17. Retire el STB.
18. Vuelva a escribir CMakeLists.txt para utilizar la nueva detección CUDA.
19. Elimine el antiguo código "alfabeto" y elimine las más de 700 imágenes en datos/etiquetas.
20. Construya fuera de fuente.
21. Tener una mejor salida del número de versión.
22. Optimizaciones del rendimiento relacionadas con la formación (tarea en curso).
23. Optimizaciones de rendimiento relacionadas con la inferencia (tarea en curso).
24. Pase por referencia cuando sea posible.
25. Limpiar archivos .hpp.
26. Vuelva a escribir darknet.h.
27. No convierta cv::Mat a void*, utilícelo como un objeto C++ adecuado.
28. Arreglar o ser coherente en cómo se utiliza la estructura de la imagen interna.
29. Corrección de compilación para dispositivos Jetson basados en ARM.
30. Los nuevos dispositivos Jetson Orin están funcionando.
31. Reparar la API de Python en V3.
Metas a corto plazo
1. Cambie printf() por std::cout.
2. Mire el soporte de la cámara Zed antigua.
3. Análisis de línea de comando mejor y más consistente.
Metas a medio plazo
1. Elimine todo el código char* y reemplácelo con std::string.
2. No oculte las advertencias ni borre las advertencias del compilador.
3. Mejor uso de cv::Mat en lugar de la estructura de imagen personalizada en C.
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.
7. Limpieza de código continua.
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. Considere agregar soporte para GPU que no sean NVIDIA.
4. Cuadros delimitadores girados o algún tipo de soporte en "ángulo".
5. Puntos clave/esqueletos.
6. Mapas de calor.
7. Segmentación.
