Estrutura de detecção de objetos Darknet e YOLO
Darknet é uma estrutura de rede neural de código aberto escrita em C, C++ e CUDA.
YOLO (You Only Look Once) é um sistema de detecção de objetos de última geração em tempo real, executado na estrutura Darknet.
Leia como Hank.ai está ajudando a comunidade Darknet/YOLO
Anunciando Darknet V3 "Jazz"
Veja o site Darknet/YOLO
Por favor, leia as perguntas frequentes do Darknet/YOLO
Junte-se ao servidor de discórdia Darknet/YOLO
Artigos
1. Artigo YOLOv7
2. Papel em escala-YOLOv4
3. Artigo YOLOv4
4. Artigo YOLOv3
Informações gerais
A estrutura Darknet/YOLO continua a ser mais rápida e precisa do que outras estruturas e versões do YOLO.
Esta estrutura é totalmente gratuita e de código aberto. Você pode incorporar Darknet/YOLO em projetos e produtos existentes - incluindo comerciais - sem licença ou pagamento de taxa.
Darknet V3 ("Jazz") lançado em outubro de 2024 pode executar com precisão os vídeos do conjunto de dados LEGO em até 1000 FPS ao usar uma GPU NVIDIA RTX 3090, o que significa que cada quadro de vídeo é lido, redimensionado e processado por Darknet/YOLO em 1 milissegundo ou menos.
Por favor, junte-se ao servidor Darknet/YOLO Discord se precisar de ajuda ou quiser discutir Darknet/YOLO: https://discord.gg/zSq8rtW
A versão CPU do Darknet/YOLO pode ser executada em dispositivos simples, como Raspberry Pi, servidores em nuvem e colab, desktops, laptops e equipamentos de treinamento de última geração. A versão GPU do Darknet/YOLO requer uma GPU compatível com CUDA da NVIDIA.
Darknet/YOLO é conhecido por funcionar em Linux, Windows e Mac. Veja as instruções de construção abaixo.
Versão Darknet
A ferramenta Darknet original escrita por Joseph Redmon em 2013-2017 não tinha um número de versão. Consideramos esta versão 0.x.
O próximo repositório Darknet popular mantido por Alexey Bochkovskiy entre 2017-2021 também não tinha um número de versão. Consideramos esta versão 1.x.
O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette a partir de 2023 foi o primeiro com um comando de versão. De 2023 até o final de 2024, retornou a versão 2.x "OAK".
O objetivo era tentar quebrar o mínimo das funcionalidades existentes enquanto se familiarizava com a base de código.
As principais mudanças nesta versão incluem:
1. Reescrevi as etapas de construção para ter uma maneira unificada de construir usando CMake no Windows e no Linux.
2. Converteu a base de código para usar o compilador C++.
3. Chart.png aprimorado durante o treinamento.
4. Correções de bugs e otimizações relacionadas ao desempenho, principalmente relacionadas à redução do tempo necessário para treinar uma rede.
A última ramificação desta base de código é a versão 2.1 na ramificação v2.
A próxima fase de desenvolvimento começou em meados de 2024 e foi lançada em outubro de 2024. O comando version agora retorna 3.x "JAZZ".
Você sempre pode fazer uma verificação da ramificação v2 anterior se precisar executar um desses comandos. Informe-nos para que possamos investigar a adição de comandos ausentes.
As principais mudanças nesta versão incluem:
1. Muitos comandos antigos e não mantidos foram removidos.
2. Muitas otimizações de desempenho, tanto durante o treinamento quanto durante a inferência.
3. A API C legada foi modificada; aplicativos que usam a API Darknet original precisarão de pequenas modificações: https://darknetcv.ai/api/api.html
4. Nova API Darknet V3 C e C++: https://darknetcv.ai/api/api.html
5. Novos aplicativos e código de exemplo em src-examples: https://darknetcv.ai/api/files.html
Pesos pré-treinados MSCOCO
Várias versões populares do YOLO foram pré-treinadas por conveniência no conjunto de dados MSCOCO. Este conjunto de dados possui 80 classes, que podem ser vistas no arquivo de texto cfg/coco.names.
Existem vários outros conjuntos de dados mais simples e pesos pré-treinados disponíveis para testar Darknet/YOLO, como LEGO Gears e Rolodex. Consulte as perguntas frequentes do Darknet/YOLO para obter detalhes.
Os pesos pré-treinados do MSCOCO podem ser baixados de vários locais diferentes e também estão disponíveis para download neste repositório:
1. YOLOv2, novembro de 2016
- YOLOv2-minúsculo
- YOLOv2-completo
2. YOLOv3, maio de 2018
- YOLOv3-minúsculo
- YOLOv3-completo
3. YOLOv4, maio de 2020
- YOLOv4-minúsculo
- YOLOv4-completo
4. YOLOv7, agosto de 2022
- YOLOv7-minúsculo
- YOLOv7-completo
Os pesos pré-treinados da MSCOCO são fornecidos apenas para fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO estão no diretório cfg. Comandos de exemplo:
`bash
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
`
Observe que se espera que as pessoas treinem suas próprias redes. MSCOCO normalmente é usado para confirmar se tudo está funcionando corretamente.
Prédio
Os vários métodos de construção disponíveis no passado (pré-2023) foram fundidos numa única solução unificada. Darknet requer C++17 ou mais recente, OpenCV, e usa CMake para gerar os arquivos de projeto necessários.
Você não precisa saber C++ para construir, instalar ou executar Darknet/YOLO, da mesma forma que não precisa ser mecânico para dirigir um carro.
Cuidado se você estiver seguindo tutoriais antigos com etapas de construção mais complicadas ou etapas de construção que não correspondem ao que está neste leia-me. As novas etapas de construção descritas abaixo começaram em agosto de 2023.
Os desenvolvedores de software são incentivados a visitar https://darknetcv.ai/ para obter informações sobre os componentes internos da estrutura de detecção de objetos Darknet/YOLO.
Google Colab
As instruções do Google Colab são iguais às instruções do Linux. Vários notebooks Jupyter estão disponíveis mostrando como realizar determinadas tarefas, como treinar uma nova rede.
Veja os notebooks no subdiretório colab e/ou siga as instruções do Linux abaixo.
Método Linux CMake
1. Instale os pacotes necessários:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clone o repositório Darknet:
`bash
mkdir ~/srccd ~/src
clone do git https://github.com/hank-ai/darknetcd darknet
`
3. Crie um diretório de construção e execute o CMake:
`bash
compilação mkdir buildcd
cmake -DCMAKEBUILDTYPE=Liberar ..
`
4. Construir Darknet:
`bash
faça -j4
`
5. Empacote e instale o Darknet:
`bash
pacote
sudo dpkg -i darknet-VERSION.deb
`
6. Verifique a instalação:
`bash
versão darknet
`
Método CMake do Windows
1. Instale os pacotes necessários:
`bash
winget instalar Git.Git winget instalar Kitware.CMake winget instalar nsis.nsis winget instalar Microsoft.VisualStudio.2022.Community
`
2. Modifique a instalação do Visual Studio:
- Clique no menu “Iniciar do Windows” e execute o “Visual Studio Installer”.
- Clique em Modificar.
- Selecione Desenvolvimento de desktop com C++.
- Clique em Modificar no canto inferior direito e depois clique em Sim.
3. Abra o prompt de comando do desenvolvedor para VS 2022:
- Clique no menu "Iniciar do Windows" e selecione Prompt de Comando do Desenvolvedor para VS 2022. Não use o PowerShell para essas etapas.
4. Instale o Microsoft VCPKG:
`bash
cd c:mkdir c:srccd c:src git clone https://github.com/microsoft/vcpkgcd 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
`
5. Clone o repositório Darknet:
`bash
cd c:src
clone do git https://github.com/hank-ai/darknet.gitcd darknet
`
6. Crie um diretório de construção e execute o CMake:
`bash
compilação mkdir buildcd
cmake -DCMAKEBUILDTYPE=Liberar -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
7. Construir Darknet:
`bash
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
`
8. Gere o pacote de instalação do NSIS:
`bash
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
9. Execute o assistente de instalação do NSIS:
- Abra o arquivo darknet-VERSION.exe no diretório de construção. Por exemplo: darknet-2.0.31-win64.exe.
10. Verifique a instalação:
`bash
C:Arquivos de programasDarknetbindarknet.exe versão
`
Usando Darknet
CLI
A seguir não está a lista completa de todos os comandos suportados pelo Darknet.
Além da CLI Darknet, observe também a CLI do projeto DarkHelp, que fornece uma CLI alternativa para Darknet/YOLO. O DarkHelp CLI também possui vários recursos avançados que não estão disponíveis diretamente no Darknet. Você pode usar o Darknet CLI e o DarkHelp CLI juntos, eles não são mutuamente exclusivos.
Para a maioria dos comandos mostrados abaixo, você precisará do arquivo .weights com os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar uma rede neural que alguém já treinou e disponibilizou gratuitamente na internet. Exemplos de conjuntos de dados pré-treinados incluem:
1. LEGO Gears (encontrar objetos em uma imagem)
2. Rolodex (encontrar texto em uma imagem)
3. MSCOCO (detecção de objetos padrão de classe 80)
Os comandos a serem executados incluem:
1. Liste alguns comandos e opções possíveis para executar:
`bash
ajuda darknet
`
2. Verifique a versão:
`bash
versão darknet
`
3. Preveja usando uma imagem:
-V2:
`bash
teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg
`
-V3:
`bash
darknet02displayannotatedimages cars.cfg image1.jpg
`
- DarkHelp:
`bash
DarkHelp carros.cfg carros.cfg carros_best.weights image1.jpg
`
4. Coordenadas de saída:
-V2:
`bash
teste de detector darknet animais.dados animais.cfg animaisbest.weights -extoutput dog.jpg
`
-V3:
`bash
darknet01inference_images animais cachorro.jpg
`
- DarkHelp:
`bash
DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg
`
5. Trabalhando com vídeos:
-V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights -extoutput test.mp4
`
-V3:
`bash
darknet03display_videos animais.cfg teste.mp4
`
- DarkHelp:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
6. Lendo de uma webcam:
-V2:
`bash
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
`
-V3:
`bash
darknet08display_webcam animais
`
7. Salve os resultados em um vídeo:
-V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test.mp4 -outfilename res.avi
`
-V3:
`bash
darknet05processvideosanimais multithread.cfg animais.nomes animais_best.teste de pesos.mp4
`
- DarkHelp:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
8. JSON:
-V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
`
-V3:
`bash
darknet06imagestojson animais imagem1.jpg
`
- DarkHelp:
`bash
DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg
`
9. Executando em uma GPU específica:
`bash
demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4
`
10. Para verificar a precisão da rede neural:
`bash
mapa do detector darknet driving.data driving.cfg driving_best.weights ...
`
Saída:
`
Id Nome AvgPrecision TP FN FP TN Precisão ErrorRate Precisão Recall Especificidade FalsePosRate
------ ------------ ------ ------ ------ ------ -------- --------- --------- ------ ----------- ------------
0 veí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 pessoas 76,7937 7072 1727 2574 27523 0,8894 0,1106 0,7332 0,8037 0,9145 0,0855
4 muitos veí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 amarela 82,0390 126 38 30 1239 0,9525 0,0475 0,8077 0,7683 0,9764 0,0236
7 luz vermelha 94,1033 3449 217 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885
`
11. Para verificar a precisão mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
12. Recálculo de âncoras:
- Melhor feito no DarkMark.
- No Darknet, use:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
13. Treine uma nova rede:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
Treinamento
Links rápidos para seções relevantes do FAQ Darknet/YOLO:
1. Como devo configurar meus arquivos e diretórios?
2. Qual arquivo de configuração devo usar?
3. Qual comando devo usar ao treinar minha própria rede?
A maneira mais simples de anotar e treinar é usar o DarkMark para criar todos os arquivos Darknet necessários. Esta é definitivamente a forma recomendada para treinar uma nova rede neural.
Se preferir configurar manualmente os vários arquivos para treinar uma rede personalizada:
1. Crie uma nova pasta para o seu projeto:
- Para este exemplo será criada uma rede neural para detectar animais, então é criado o seguinte diretório: ~/nn/animals/.
2. Copie um arquivo de configuração Darknet como modelo:
- Por exemplo, copie cfg/yolov4-tiny.cfg para a pasta do projeto. Agora você terá ~/nn/animals/animals.cfg.
3. Crie um arquivo de texto Animals.names:
- Este arquivo conterá a lista de classes que você deseja detectar, uma por linha. Por exemplo:
`
cachorro
gato
pássaro
cavalo
`
4. Crie um arquivo de texto Animals.data:
- Este arquivo especifica os caminhos para os dados de treinamento e validação, bem como os nomes e diretórios de backup. Por exemplo:
`
aulas=4
trem=/home/nomedeusuário/nn/animals/animals_train.txt
válido=/home/nomedeusuário/nn/animals/animals_valid.txt
nomes=/home/nomedeusuário/nn/animais/animais.nomes
backup=/home/nomedeusuário/nn/animais
`
5. Crie uma pasta para suas imagens e anotações:
- Por exemplo, pode ser ~/nn/animals/dataset. Cada imagem precisará de um arquivo .txt correspondente que descreva as anotações dessa imagem. O formato dos arquivos de anotação .txt é muito específico. Você não pode criar esses arquivos manualmente, pois cada anotação precisa conter as coordenadas exatas da anotação. Consulte DarkMark ou outro software semelhante para fazer anotações em suas imagens. O formato de anotação YOLO é descrito nas Perguntas frequentes do Darknet/YOLO.
6. Crie os arquivos de texto “train” e “valid”:
- Esses dois arquivos de texto precisam listar individualmente todas as imagens que Darknet deve usar para treinar e para validação no cálculo do mAP%. Exatamente uma imagem por linha. O caminho e os nomes dos arquivos podem ser relativos ou absolutos.
7. Modifique seu arquivo .cfg:
- lote: definido como 64.
- subdivisões: comece com 1. Consulte o FAQ Darknet/YOLO se precisar ajustar isso com base na disponibilidade de memória.
- maxbatches: um bom valor inicial é 2.000 numberof_classes. Neste exemplo, temos 4 animais, então 4 2.000 = 8.000.
- passos: Defina para 80% e 90% de maxbatches. Para este exemplo, usaríamos steps=6400,7200 já que maxbatches foi definido como 8000.
- largura e altura: Estas são as dimensões da rede. O FAQ Darknet/YOLO explica como calcular o melhor tamanho a ser usado.
- classes: Modifique esta linha com o número de classes em seu arquivo .names. Para este exemplo, usaríamos classes=4.
- filtros: Na seção [convolucional] anterior a cada seção [yolo], modifique filtros=... com o valor (número de classes + 5) * 3. Para este exemplo, usaríamos filtros=27.
8. Comece a treinar:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
Ser paciente. Os melhores pesos serão salvos como Animals_best.weights. O andamento do treinamento pode ser observado visualizando o arquivo chart.png. Consulte o FAQ Darknet/YOLO para parâmetros adicionais que você pode querer usar ao treinar uma nova rede.
Se quiser ver mais detalhes durante o treinamento, adicione o parâmetro --verbose. Por exemplo:
`bash
detector darknet -map -dont_show --verbose trem animais.data animais.cfg
`
Outras ferramentas e links
1. DarkMark: Para gerenciar seus projetos Darknet/YOLO, anotar imagens, verificar suas anotações e gerar os arquivos necessários para treinar com Darknet.
2. DarkHelp: Para uma CLI alternativa robusta ao Darknet, para usar imagens lado a lado, para rastreamento de objetos em seus vídeos ou para uma API C++ robusta que pode ser facilmente usada em aplicativos comerciais.
3. Perguntas frequentes sobre Darknet/YOLO: Para ajudar a responder suas perguntas.
4. Canal de Stéphane no YouTube: Para tutoriais e exemplos de vídeos.
5. Servidor de discórdia Darknet/YOLO: Para conversar com outros usuários Darknet/YOLO e pedir suporte.
Roteiro
Última atualização em 30/10/2024:
Concluído
1. Troque qsort() por std::sort() quando usado durante o treinamento.
2. Livre-se de check_mistakes, getchar() e system().
3. Converta Darknet para usar o compilador C++.
4. Corrija a compilação do Windows.
5. Corrija o suporte a Python.
6. Construa uma biblioteca darknet.
7. Reative os rótulos nas previsões (código "alfabeto").
8. Reative o código CUDA/GPU.
9. Reative o CUDNN.
10. Reative a metade CUDNN.
11. Não codifique a arquitetura CUDA.
12. Melhores informações sobre a versão CUDA.
13. Reative o AVX.
14. Remova soluções antigas e Makefile.
15. Torne o OpenCV não opcional.
16. Remova a dependência da antiga biblioteca pthread.
17. Remova o STB.
18. Reescreva CMakeLists.txt para usar a nova detecção CUDA.
19. Remova o código "alfabeto" antigo e exclua as mais de 700 imagens em dados/rótulos.
20. Construa fora do código-fonte.
21. Tenha melhor saída de número de versão.
22. Otimizações de desempenho relacionadas ao treinamento (tarefa contínua).
23. Otimizações de desempenho relacionadas à inferência (tarefa em andamento).
24. Passagem por referência sempre que possível.
25. Limpe os arquivos .hpp.
26. Reescreva darknet.h.
27. Não converta cv::Mat para void* mas use-o como um objeto C++ adequado.
28. Corrija ou seja consistente na forma como a estrutura interna da imagem é usada.
29. Correção de compilação para dispositivos Jetson baseados em ARM.
30. Novos dispositivos Jetson Orin estão funcionando.
31. Corrija a API Python na V3.
Metas de curto prazo
1. Troque printf() por std::cout.
2. Procure suporte para câmeras Zed antigas.
3. Análise de linha de comando melhor e mais consistente.
Metas de médio prazo
1. Remova todo o código char* e substitua por std::string.
2. Não oculte avisos e limpe os avisos do compilador.
3. Melhor uso de cv::Mat em vez da estrutura de imagem personalizada em C.
4. Substitua a funcionalidade de lista antiga por std::vector ou std::list.
5. Corrigido suporte para imagens em escala de cinza de 1 canal.
6. Adicione suporte para imagens de canal N onde N > 3.
7. Limpeza contínua de código.
Metas de longo prazo
1. Corrija problemas de CUDA/CUDNN com todas as GPUs.
2. Reescreva o código CUDA + cuDNN.
3. Considere adicionar suporte para GPUs que não sejam NVIDIA.
4. Caixas delimitadoras giradas ou algum tipo de suporte de "ângulo".
5. Pontos-chave/esqueletos.
6. Mapas de calor.
7. Segmentação.
