Marco de detección de objetos Darknet y YOLO
Logotipos de !darknet y hank.ai
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 dentro del marco Darknet.
Lea cómo Hank.ai está ayudando a la comunidad Darknet/YOLO: https://hank.ai/
Anuncio de Darknet V3 "Jazz": https://darknetcv.ai/
Lea las preguntas frecuentes de Darknet/YOLO: https://darknetcv.ai/faq/
Únase al servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW
Papeles
1. Documento YOLOv7: https://arxiv.org/abs/2207.02670
2. Papel escalado-YOLOv4: https://arxiv.org/abs/2103.05293
3. Documento YOLOv4: https://arxiv.org/abs/2004.10934
4. Documento YOLOv3: https://pjreddie.com/media/files/papers/YOLOv3.pdf
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. Esto significa que Darknet/YOLO lee, redimensiona y procesa cada fotograma de vídeo en 1 milisegundo o menos.
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
1. Versión 0.x: la herramienta Darknet original escrita por Joseph Redmon en 2013-2017.
2. Versión 1.x: el próximo repositorio popular de Darknet mantenido por Alexey Bochkovskiy entre 2017 y 2021.
3. Versión 2.x "OAK": El repositorio de Darknet patrocinado por Hank.ai y mantenido por Stéphane Charette a partir de 2023. Fue el primero con un comando de versión. Esta versión trajo los siguientes cambios:
- Se reescribieron los pasos de compilación para un enfoque unificado de CMake tanto en Windows como en Linux.
- Convirtió el código base para usar el compilador C++.
- Generación de chart.png mejorada durante el entrenamiento.
- Corrección de errores y optimizaciones de rendimiento relacionadas con el tiempo de entrenamiento.
4. Versión 2.1: la última rama del código base 2.x, que se encuentra en la rama v2.
5. Versión 3.x "JAZZ": la siguiente fase de desarrollo, lanzada en octubre de 2024.
- Se eliminaron muchos comandos antiguos y no mantenidos.
- Implementé optimizaciones de rendimiento para entrenamiento e inferencia.
- Modificó la API C heredada. Las aplicaciones que utilizan la API Darknet original necesitarán modificaciones menores. https://darknetcv.ai/api/api.html
- Se introdujo una nueva API Darknet V3 C y C++: https://darknetcv.ai/api/api.html
- Se agregaron nuevas aplicaciones y código de muestra en src-examples: https://darknetcv.ai/api/files.html
Siempre puedes consultar la rama v2 anterior si necesitas ejecutar uno de los comandos de esa versión. Háganos saber si encuentra algún comando faltante para que podamos investigar cómo agregarlo nuevamente.
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, incluido este repositorio:
YOLOv2 (noviembre de 2016):
yolov2-tiny.pesos
yolov2-pesos.completos
YOLOv3 (mayo de 2018):
yolov3-tiny.pesos
yolov3-pesos.completos
YOLOv4 (mayo de 2020):
yolov4-tiny.pesos
yolov4-pesos.completos
YOLOv7 (agosto de 2022):
yolov7-tiny.pesos
yolov7-pesos.completos
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 le anima a entrenar sus propias redes. MSCOCO se utiliza principalmente para confirmar que todo funciona correctamente.
Edificio
Los diversos métodos de compilación disponibles en el pasado (anteriores a 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 es necesario saber C++ para compilar, instalar o ejecutar Darknet/YOLO, del mismo modo que no es necesario ser mecánico para conducir un automóvil.
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 diversas tareas, como entrenar una nueva red.
Consulte los cuadernos en el subdirectorio colab o siga las instrucciones de Linux a continuación.
Método CMake de Linux
Tutorial de compilación de Darknet para Linux
1. Opcional: si tiene una GPU NVIDIA moderna, puede instalar CUDA o CUDA+cuDNN en este punto. Si está instalado, Darknet utilizará su GPU para acelerar el procesamiento de imágenes (y videos).
2. Instale los paquetes necesarios:
`golpear
sudo apt-get install build-essential git libopencv-dev cmake
`
3. Clonar el repositorio Darknet:
`golpear
mkdir ~/srccd ~/src
clon de git https://github.com/hank-ai/darknet
`
4. Crear directorio de compilación:
`golpear
cd red oscura
compilación mkdir
compilación de cd
`
5. Genere archivos de proyecto CMake:
`golpear
cmake -DCMAKEBUILDTYPE=Lanzar ..
`
Importante: Debe eliminar el archivo CMakeCache.txt de su directorio de compilación Darknet para obligar a CMake a volver a encontrar todos los archivos necesarios.
6. Construya la red oscura:
`golpear
hacer el paquete -j4
`
7. Instale el paquete Darknet:
`golpear
sudo dpkg -i darknet-VERSIÓN.deb
`
Instalación de CUDA y cuDNN (opcional)
Darknet puede ejecutarse sin CUDA, pero si desea entrenar una red personalizada, se requiere CUDA o CUDA+cuDNN.
1. Instale CUDA:
- Visite https://developer.nvidia.com/cuda-downloads para descargar e instalar CUDA.
- Asegúrate de poder ejecutar nvcc y nvidia-smi. Es posible que deba modificar su variable PATH.
2. Instale cuDNN:
- Visite https://developer.nvidia.com/rdp/cudnn-download o https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview para Descargue e instale cuDNN.
Actualización de CUDA o cuDNN
Si instala CUDA o CUDA+cuDNN más adelante, o actualiza a una versión más reciente del software NVIDIA:
1. Reconstruir Darknet:
- Elimina el archivo CMakeCache.txt de tu directorio de compilación de Darknet.
- Ejecute cmake y vuelva a realizar comandos.
Usuarios avanzados
Para crear un archivo de instalación RPM en lugar de un archivo DEB, edite las líneas relevantes en CM_package.cmake antes de ejecutar el paquete make -j4.
`cmake
# CONFIGURAR (CPACK_GENERATOR "DEB")
ESTABLECER (CPACK_GENERATOR "RPM")
`
Para instalar el paquete de instalación una vez que haya terminado de compilarse, utilice el administrador de paquetes habitual para su distribución. Por ejemplo, en sistemas basados en Debian como Ubuntu:
`golpear
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Probando la instalación
Después de la instalación, debería tener los siguientes archivos:
/usr/bin/darknet: El ejecutable de Darknet. Ejecute la versión de darknet desde la CLI para confirmar que esté instalada correctamente.
/usr/include/darknet.h: La API Darknet para desarrolladores de C, C++ y Python.
/usr/include/darknet_version.h: contiene información de versión para desarrolladores.
/usr/lib/libdarknet.so: la biblioteca con la que se vinculan los desarrolladores de C, C++ y Python.
/opt/darknet/cfg/...: Donde se almacenan todas las plantillas .cfg.
Ejecute el siguiente comando para probar la instalación:
`golpear
versión de la red oscura
`
Método CMake de Windows
Tutorial de compilación de Darknet para Windows
1. Instale el software requerido:
- Abra una ventana normal del símbolo del sistema cmd.exe y ejecute los siguientes comandos:
`golpear
instalación de alas Git.Git
Instalación de Winget Kitware.CMake
instalación de alas nsis.nsis
Winget instala 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, luego haga clic en "Sí".
3. Instale Microsoft VCPKG:
- Una vez que todo esté descargado e instalado, haga clic nuevamente en el menú "Inicio de Windows" y seleccione "Símbolo del sistema del desarrollador para VS 2022". ¡No utilice PowerShell para estos pasos!
- Ejecute los siguientes comandos:
`golpear
Centros para el Control y la Prevención de Enfermedades:
mkdirc:src
cdc:src
clon de git https://github.com/microsoft/vcpkg
cd vcpkg
arranque-vcpkg.bat
.vcpkg.exe instalación integrada
.vcpkg.exe integra powershell
.vcpkg.exe instalar opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
Importante: tenga paciencia en este último paso, ya que puede tardar mucho en ejecutarse. Necesita descargar y construir muchas cosas.
4. Opcional: instale CUDA y cuDNN
- Si tienes una GPU NVIDIA moderna, puedes instalar CUDA o CUDA+cuDNN en este punto. Si está instalado, Darknet utilizará su GPU para acelerar el procesamiento de imágenes (y videos).
- Debe eliminar el archivo CMakeCache.txt de su directorio de compilación Darknet para obligar a CMake a volver a encontrar todos los archivos necesarios.
- Recuerda reconstruir Darknet.
5. Instale CUDA:
- Visite https://developer.nvidia.com/cuda-downloads para descargar e instalar CUDA.
- Asegúrese de poder ejecutar nvcc.exe y nvidia-smi.exe. Es posible que deba modificar su variable PATH.
6. Instale cuDNN:
- Visite https://developer.nvidia.com/rdp/cudnn-download o https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows para descargar e instalar cuDNN.
- Una vez que descargue cuDNN, descomprima y copie los directorios bin, include y lib en C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[versión]/. Es posible que necesites sobrescribir algunos archivos.
7. Clona el repositorio Darknet y compila:
`golpear
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=Versión PACKAGE.vcxproj
`
8. Copie las DLL de CUDA (opcional):
- Si recibe un error sobre algunas DLL CUDA o cuDNN que faltan, como cublas64_12.dll, copie manualmente los archivos CUDA .dll en el mismo directorio de salida que darknet.exe. Por ejemplo:
`golpear
copie "C:Archivos de programaNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
9. Vuelva a ejecutar msbuild.exe para generar el paquete de instalación de NSIS:
`golpear
msbuild.exe /property:Platform=x64;Configuration=Versión PACKAGE.vcxproj
`
Usuarios avanzados
En lugar de ejecutar el símbolo del sistema del desarrollador, puede usar un símbolo del sistema normal o ssh en el dispositivo y ejecutar manualmente Archivos de programa Microsoft Visual Studio2022 CommunityCommon7ToolsVsDevCmd.bat.
Puede agregar muchos otros módulos opcionales al crear OpenCV. Ejecute .vcpkg.exe busque opencv para ver la lista completa.
La salida del comando cmake es un archivo de solución normal de Visual Studio, Darknet.sln. Puede ignorar la línea de comandos y cargar el proyecto Darknet en Visual Studio si es un desarrollador de software que utiliza regularmente la GUI de Visual Studio.
Probando la instalación
Ahora debería tener el siguiente archivo: C:srcDarknetbuildsrc-cliReleasedarknet.exe. Ejecute el siguiente comando para probar la instalación:
`golpear
C:srcDarknetbuildsrc-cliReleasedarknet.exe versión
`
Para instalar correctamente Darknet, las bibliotecas, los archivos de inclusión y las DLL necesarias, ejecute el asistente de instalación de NSIS que se creó en el último paso. Vea el archivo darknet-VERSION.exe en el directorio de compilación. Por ejemplo:
`golpear
darknet-2.0.31-win64.exe
`
La instalación del paquete de instalación de NSIS:
Cree un directorio llamado Darknet, como C:Program FilesDarknet.
Instale la aplicación CLI, darknet.exe y otras aplicaciones de muestra.
Instale los archivos .dll de terceros necesarios, como los de OpenCV.
Instale los archivos Darknet .dll, .lib y .h necesarios para usar darknet.dll desde otra aplicación.
Instale los archivos .cfg de plantilla.
Ejecute el siguiente comando para probar la instalación después de ejecutar el asistente de NSIS:
`golpear
C: Archivos de programa Versión Darknetbindarknet.exe
`
Usando la red oscura
CLI
La siguiente no es una lista completa de todos los comandos admitidos por Darknet.
Además de la CLI de Darknet, 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 la CLI de Darknet y 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:
LEGO Gears (encontrar objetos en una imagen)
Rolodex (buscar texto en una imagen)
MSCOCO (detección de objetos estándar de clase 80)
Comandos para ejecutar
1. Obtenga ayuda:
`golpear
ayuda de la red oscura
`
2. Verificar versión:
`golpear
versión de la red oscura
`
3. Predecir usando una imagen:
-V2:
`golpear
Prueba del detector darknet cars.data cars.cfg cars_best.weights image1.jpg
`
-V3:
`golpear
darknet02displayimagenes 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. Salida 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:
- V2:
`golpear
Demostración del detector darknet animales.datos animales.cfg animales_mejores.pesos -i 1 prueba.mp4
`
10. Comprobación de 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. Comprobación de la precisión mAP@IoU=75:
`golpear
Mapa del detector de darknet animales.datos animales.cfg animalesbest.weights -iouthresh 0,75
`
12. Recalcular anclajes:
- DarkMark: Es mejor recalcular los anclajes en DarkMark, ya que se ejecuta 100 veces consecutivas y selecciona los mejores anclajes de todos los calculados.
- Darknet: Si quieres utilizar el método antiguo en Darknet:
`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?
Uso de DarkMark para anotaciones y entrenamiento (recomendado)
La forma más sencilla de anotar y entrenar es con DarkMark, que crea todos los archivos Darknet necesarios. Esto es muy recomendable para entrenar una nueva red neuronal.
Configuración manual de archivos para entrenar una red personalizada
Si prefiere la configuración manual, siga estos pasos:
1. Cree una nueva carpeta:
- Crea una nueva carpeta para almacenar tus archivos de entrenamiento. Por ejemplo, podría crear ~/nn/animals/ para entrenar una red para la detección de animales.
2. Copie una plantilla de archivo de configuración:
- Copie uno de los archivos de configuración de Darknet de cfg/ como plantilla. Por ejemplo, podrías usar cfg/yolov4-tiny.cfg. Colóquelo en la carpeta que creó. Ahora deberías tener ~/nn/animals/animals.cfg.
3. Cree un archivo animales.names:
- Cree un archivo de texto llamado animales.nombres en la misma carpeta que el archivo de configuración.
4. Edite el archivo animales.names:
- Lista las clases que deseas detectar, una entrada por línea, sin líneas en blanco ni comentarios. Por ejemplo:
`
perro
gato
pájaro
caballo
`
5. Cree un archivo animales.data:
- Crea un archivo de texto llamado animales.data en la misma carpeta.
- Por ejemplo, el archivo animales.data podría contener:
`
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
`
6. Cree una carpeta de conjunto de datos:
- Crea una carpeta para almacenar tus imágenes y anotaciones. Por ejemplo, podrías crear ~/nn/animals/dataset.
7. Anotar imágenes:
- Cada imagen necesita su correspondiente archivo .txt con anotaciones. El formato de estos archivos .txt es específico y requiere las coordenadas exactas para las anotaciones. Utilice DarkMark o software similar para anotar sus imágenes.
8. Cree animalestrain.txt y animalesvalid.txt:
- Estos archivos de texto enumeran las imágenes utilizadas para el entrenamiento y la validación, respectivamente. Cada imagen debe estar en una línea separada, con rutas relativas o absolutas.
9. Modifique el archivo de configuración:
- Abra animales.cfg con un editor de texto y realice las siguientes modificaciones:
- lote=64: asegúrese de que este valor esté establecido.
- subdivisiones: el mejor valor a utilizar es 1. Es posible que deba aumentar este valor según la memoria de su GPU y las dimensiones de la red.
- maxbatches: establezca esto en un valor razonable, normalmente 2000 veces el número de clases. Para este ejemplo, utilice maxbatches=8000 (4 clases * 2000).
- pasos: configúrelos en 80% y 90% de los lotes máximos. Para este ejemplo, utilice los pasos = 6400,7200 (ya que maxbatches = 8000).
- ancho y alto: configúrelos según las dimensiones de red que desee. Consulte las preguntas frecuentes de Darknet/YOLO para obtener orientación sobre cómo elegir el mejor tamaño.
- clases: busque todas las instancias de esta línea y modifíquela para que coincida con el número de clases en su archivo .names (en este ejemplo, clases=4).
- filtros: busque todas las instancias de esta línea en las secciones [convolucionales] antes de cada sección [yolo]. El valor a usar es (número de clases + 5) 3. Para este ejemplo, use filtros = 27 (4 + 5 3).
10. Comience a entrenar:
`golpear
cd ~/nn/animales/
detector de red oscura -mapa -dont_show entrenar animales.datos animales.cfg
`
11. Seguimiento del progreso de la formación:
- ¡Ser paciente! Los mejores pesos se guardarán como animales_best.weights.
- Puedes monitorear el progreso del entrenamiento viendo el archivo chart.png.
- Consulte las preguntas frecuentes de Darknet/YOLO para conocer parámetros adicionales que quizás desee utilizar durante el entrenamiento.
12. Agregar detalles al resultado del entrenamiento:
`golpear
detector de red oscura -map -dont_show --detallado tren animales.datos animales.cfg
`
Otras herramientas y enlaces
DarkMark: para gestionar proyectos Darknet/YOLO, anotar imágenes, verificar anotaciones y generar archivos para la capacitación de Darknet.
DarkHelp: para una CLI alternativa sólida a Darknet, que utiliza mosaicos de imágenes, seguimiento de objetos en videos y una API C++ sólida que se puede usar en aplicaciones comerciales.
Preguntas frecuentes sobre Darknet/YOLO: https://darknetcv.ai/faq/
Canal de YouTube de Stéphane: https://www.youtube.com/channel/UCYQ2k0L3X0c56l9gE2r1RQ
Servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW
Hoja de ruta
Última actualización 2024-10-30:
Terminado
Se cambió qsort() por std::sort() cuando se usaba durante el entrenamiento (quedan algunos oscuros).
Se eliminaron check_mistakes, getchar() y system().
Se convirtió Darknet para usar el compilador C++ (g++ en Linux, VisualStudio en Windows).
Se corrigió la compilación de Windows.
Se corrigió el soporte de Python.
Biblioteca Darknet construida.
Etiquetas reactivadas en las predicciones (código "alfabeto").
Código CUDA/GPU rehabilitado.
CUDNN rehabilitado.
Se volvió a habilitar la mitad CUDNN.
No codifique la arquitectura CUDA.
Información de versión CUDA mejorada.
AVX rehabilitado.
Se eliminaron soluciones antiguas y Makefile.
OpenCV se hizo no opcional.
Se eliminó la dependencia de la antigua biblioteca pthread.
STB eliminado.
Reescribió CMakeLists.txt para usar la nueva detección CUDA.
Se eliminó el antiguo código "alfabeto" y se eliminaron las más de 700 imágenes en datos/etiquetas.
Construido fuera de fuente.
Salida de número de versión mejorada.
Optimizaciones de rendimiento relacionadas con la formación (tarea en curso).
Optimizaciones de rendimiento relacionadas con la inferencia (tarea en curso).
Se utiliza paso por referencia siempre que sea posible.
Se limpiaron archivos .hpp.
Reescribió darknet.h.
No convierta cv::Mat a void*, utilícelo como un objeto C++ adecuado.
Se corrigió o se hizo consistente cómo se utiliza la estructura de la imagen interna.
Compilación fija para dispositivos Jetson basados en ARM.
- Es poco probable que los dispositivos Jetson originales se reparen ya que NVIDIA ya no los admite (sin compilador C++17).
- Los nuevos dispositivos Jetson Orin están funcionando.
Se corrigió la API de Python en V3.
Soporte mejorado para Python. (¿Algún desarrollador de Python quiere ayudar con esto?)
Metas a corto plazo
Cambie printf() por std::cout (en progreso).
Busque soporte para cámaras ZED antiguas.
Mejorar y realizar un análisis coherente de la línea de comandos (en curso).
Metas a mediano plazo
Elimine todo el código char* y reemplácelo con std::string.
No oculte advertencias y limpie las advertencias del compilador (en progreso).
Mejorar el uso de cv::Mat en lugar de la estructura de imagen personalizada en C (en progreso).
Reemplace la funcionalidad de lista anterior con std::vector o std::list.
Se corrigió la compatibilidad con imágenes en escala de grises de 1 canal.
Agregue soporte para imágenes de canal N donde N > 3 (por ejemplo, imágenes con una profundidad adicional o un canal térmico).
Limpieza de código en curso (en progreso).
Metas a largo plazo
Solucione problemas de CUDA/CUDNN con todas las GPU.
Vuelva a escribir el código CUDA+cuDNN.
Considere agregar soporte para GPU que no sean NVIDIA.
Cuadros delimitadores girados o algún tipo de soporte de "ángulo".
Puntos clave/esqueletos.
Mapas de calor (en progreso).
Segmentación.
