rusthw

Estrutura de detecção de objetos Darknet e YOLO

Darknet é uma estrutura de rede neural de código aberto desenvolvida principalmente em C e C++, com suporte para aceleração CUDA.

YOLO (You Only Look Once), um sistema de detecção de objetos em tempo real de última geração, é uma implementação proeminente na estrutura Darknet.

Leia mais sobre como Hank.ai está contribuindo para a comunidade Darknet/YOLO:

Anunciando Darknet V3 "Jazz": https://darknetcv.ai/blog/announcing-darknet-v3-jazz

Site Darknet/YOLO: https://darknetcv.ai/

Perguntas frequentes sobre Darknet/YOLO: https://darknetcv.ai/faq/

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

Artigos

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

2. Escalado-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

Informações gerais

A estrutura Darknet/YOLO mantém sua posição como um dos sistemas de detecção de objetos mais rápidos e precisos.

Principais vantagens do Darknet/YOLO:

Gratuito e de código aberto: Darknet/YOLO é totalmente de código aberto, permitindo integração gratuita em projetos existentes, inclusive comerciais.

Alto desempenho: Darknet V3 (“Jazz”), lançado em outubro de 2024, demonstra desempenho notável, atingindo até 1000 FPS no conjunto de dados LEGO com uma GPU NVIDIA RTX 3090.

Versatilidade: A versão CPU do Darknet/YOLO pode ser implantada em várias plataformas, incluindo Raspberry Pi, servidores em nuvem, desktops, laptops e plataformas de treinamento poderosas. A versão GPU requer uma GPU NVIDIA compatível com CUDA.

Compatibilidade entre plataformas: Darknet/YOLO é conhecido por operar perfeitamente em Linux, Windows e Mac.

Versão Darknet

Darknet 0.x: Refere-se à ferramenta Darknet original desenvolvida por Joseph Redmon entre 2013 e 2017. Faltava um número de versão formal.

Darknet 1.x: Esta versão foi mantida por Alexey Bochkovskiy de 2017 a 2021. Também faltava um número de versão formal.

Darknet 2.x "OAK": Esta versão foi patrocinada por Hank.ai e mantida por Stéphane Charette a partir de 2023. Esta foi a primeira versão a introduzir um comando de versão. Ele retornou a versão 2.x até o final de 2024.

Darknet 3.x "JAZZ": Esta versão, lançada em outubro de 2024, marcou uma fase significativa de desenvolvimento, introduzindo uma nova API C e C++, desempenho aprimorado e inúmeras correções de bugs.

Pesos pré-treinados MSCOCO

Várias versões populares do YOLO foram pré-treinadas no conjunto de dados MSCOCO. Este conjunto de dados consiste em 80 classes, que podem ser encontradas no arquivo cfg/coco.names.

Pesos pré-treinados disponíveis para download:

1. YOLOv2 (novembro de 2016)

* YOLOv2-tiny

* YOLOv2-completo

2. YOLOv3 (maio de 2018)

* YOLOv3-tiny

* YOLOv3-completo

3. YOLOv4 (maio de 2020)

* YOLOv4-tiny

* YOLOv4-completo

4. YOLOv7 (agosto de 2022)

* YOLOv7-tiny

* YOLOv7-completo

Exemplo de uso:

`

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

`

Nota: Os pesos pré-treinados da MSCOCO são fornecidos principalmente para fins de demonstração. O treinamento de redes personalizadas é fortemente incentivado, sendo o MSCOCO normalmente usado para verificar a funcionalidade do sistema.

Construindo Darknet

Darknet depende de C++ 17 ou mais recente, OpenCV, e utiliza CMake para gerar arquivos de projeto.

Processo de construção:

1. Google Colab: As instruções do Google Colab são iguais às instruções do Linux. Consulte o subdiretório colab para notebooks Jupyter que apresentam tarefas específicas.

2. Método Linux CMake:

* Pré-requisitos:

* Ferramentas essenciais para construção: 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

* Instalação:

* Crie diretórios de trabalho: mkdir ~/srccd ~/src

* Clone o repositório: git clone https://github.com/hank-ai/darknet

* Navegue até o diretório Darknet: cd darknet

* Crie um diretório de compilação: mkdir build

* Construir Darknet:

* compilação de CD

* cmake -DCMAKEBUILDTYPE=Liberar ..

*faça -j4

* pacote

* Instale o pacote: sudo dpkg -i darknet-VERSION.deb

* Opcional: Instalação CUDA/cuDNN

* Baixe e instale o CUDA em https://developer.nvidia.com/cuda-downloads

* Baixe e instale o cuDNN em https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager- visão geral da instalação

* Certifique-se de poder executar nvcc e nvidia-smi. Pode ser necessário modificar sua variável PATH.

* Se instalar CUDA ou cuDNN posteriormente ou atualizar para uma versão mais recente, certifique-se de reconstruir o Darknet após modificar seu ambiente.

3. Método CMake do Windows:

* Pré-requisitos:

* Git: winget instala Git.Git

* CMake: winget instala Kitware.CMake

* NSIS: winget instalar nsis.nsis

* Visual Studio 2022 Community Edition: instalação winget Microsoft.VisualStudio.2022.Community

* Modifique a instalação do Visual Studio para incluir suporte a C++:

* Abra o instalador do Visual Studio

* Clique em "Modificar"

* Selecione "Desenvolvimento Desktop com C++"

* Clique em "Modificar" e depois em "Sim"

* Instalação:

* Abra o prompt de comando do desenvolvedor para VS 2022 (não PowerShell).

* Instale o Microsoft VCPKG:

* CDC:

* mkdir c:srccd c:src

* clone do 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

* Clone Darknet e construa:

* cd c:src

* clone do git https://github.com/hank-ai/darknet.git

*cd rede escura

* compilação mkdir

* compilação de CD

* cmake -DCMAKEBUILDTYPE=Liberar -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=Liberar PACKAGE.vcxproj

* Opcional: Instalação CUDA/cuDNN

* Baixe e instale o CUDA em https://developer.nvidia.com/cuda-downloads

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

* Descompacte cuDNN e copie os diretórios bin, include e lib em C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[versão] (substituindo os arquivos existentes, se necessário).

* Certifique-se de que você pode executar o nvcc.exe. Pode ser necessário modificar sua variável PATH.

Usando Darknet

CLI (interface de linha de comando)

Uso geral: Darknet oferece uma interface de linha de comando (CLI) para interagir com suas funcionalidades. Não é exaustivo; consulte a CLI do projeto DarkHelp para recursos adicionais.

Modelos pré-treinados: para a maioria dos comandos, você precisará do arquivo .weights junto com os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado) ou utilizar modelos pré-treinados disponíveis online. Os exemplos incluem:

* LEGO Gears (detecção de objetos em imagens)

* Rolodex (detecção de texto em imagens)

* MSCOCO (detecção de objetos padrão de 80 classes)

Comandos comuns:

Ajuda: ajuda darknet

Versão: versão darknet

Previsão com uma imagem:

* V2: teste de 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 saída:

* V2: teste de detector darknet Animals.data Animals.cfg Animalsbest.weights -extoutput dog.jpg

* V3: darknet01inference_images animais cachorro.jpg

* DarkHelp: DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg

Processamento de vídeo:

* V2:

* Demonstração do detector darknet Animals.data Animals.cfg Animalsbest.weights -extoutput test.mp4 (previsão de vídeo)

* demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0 (entrada de webcam)

* demonstração do detector darknet Animals.data Animals.cfg Animalsbest.weights Test.mp4 -outfilename res.avi (salvando resultados em vídeo)

* V3:

* darknet03display_videosanimais.cfg test.mp4 (previsão de vídeo)

* animais darknet08display_webcam (entrada de webcam)

* darknet05processvideosmultithreaded Animals.cfg Animals.names Animals_best.weights Test.mp4 (salvando resultados em vídeo)

* DarkHelp:

* DarkHelp Animals.cfg Animals.names Animals_best.weights Test.mp4 (previsão de vídeo)

* DarkHelp Animals.cfg Animals.names Animals_best.weights Test.mp4 (salvando resultados em vídeo)

Saída JSON:

* V2: demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput

* V3: darknet06imagestojson animais image1.jpg

* DarkHelp: DarkHelp --json animais.names animais.cfg animais_best.weights image1.jpg

Seleção de GPU: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -i 1 Test.mp4

Avaliação de precisão:

* mapa do detector darknet driving.data driving.cfg driving_best.weights ... (mAP@IoU=50)

* mapa detector darknet Animals.data Animals.cfg Animalsbest.weights -iouthresh 0,75 (mAP@IoU=75)

Cálculo da âncora: (use DarkMark para recálculo ideal da âncora)

* detector darknet calcanchors Animals.data -numof_clusters 6 -width 320 -height 256

Treinamento em rede:

* detector darknet -map -dont_show trem animais.data animais.cfg

Treinando uma nova rede

DarkMark: A abordagem recomendada para anotação e treinamento é utilizar DarkMark, que automatiza o processo de geração dos arquivos Darknet necessários.

Configuração manual:

1. Crie um diretório de projeto: por exemplo, ~/nn/animals/ para treinar uma rede para detecção de animais.

2. Copie um arquivo de configuração: Selecione um arquivo de configuração de modelo em cfg/ (por exemplo, cfg/yolov4-tiny.cfg) e coloque-o no diretório do seu projeto.

3. Crie um arquivo .names: No mesmo diretório, crie um arquivo de texto chamado Animals.names. Liste as classes que deseja detectar, uma por linha, sem linhas em branco ou comentários. Exemplo:

`

cachorro

gato

pássaro

cavalo

`

4. Crie um arquivo .data: No mesmo diretório, crie um arquivo de texto denominado pets.data. Este arquivo contém informações sobre seus dados de treinamento. 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. Diretório do conjunto de dados: Crie um diretório para armazenar suas imagens e anotações correspondentes (por exemplo, ~/nn/animals/dataset). Cada imagem precisará de um arquivo .txt associado descrevendo as anotações. Esses arquivos .txt devem seguir um formato específico e são melhor gerados usando DarkMark ou software similar.

6. Arquivos de treinamento e validação: Crie os arquivos de texto "treinamento" e "válidos" conforme especificado em seu arquivo .data. Esses arquivos listam as imagens a serem utilizadas para treinamento e validação, respectivamente.

7. Modifique o arquivo de configuração:

* Tamanho do lote: Definir lote = 64.

* Subdivisões: Comece com subdivisões=1. Aumente conforme necessário com base na capacidade de memória da sua GPU.

Máximo de lotes: use maxbatches=2.000 número de classes. Neste caso, maxbatches=8000.

* Etapas: defina as etapas para 80% e 90% de max_batches. Exemplo: passos=6400,7200.

* Largura e Altura: Ajuste as dimensões da rede (largura e altura). Consulte as perguntas frequentes da Darknet/YOLO para obter orientação sobre como determinar os tamanhos ideais.

* Classes: Atualize classes=... para corresponder ao número de classes em seu arquivo .names (neste caso, classes=4).

Filtros: Ajuste filtros=... nas seções [convolucionais] antes de cada seção [yolo]. Calcule usando filtros = (número de classes + 5) 3. Neste caso, filtros=27.

8. Inicie o treinamento: Navegue até o diretório do seu projeto e execute o seguinte comando:

`

detector darknet -map -dont_show trem animais.data animais.cfg

`

* Saída detalhada: para informações de treinamento mais detalhadas, use --verbose.

* Progresso: Os melhores pesos serão salvos como pets_best.weights, e o progresso do treinamento poderá ser monitorado através do arquivo chart.png.

Outras ferramentas e links

DarkMark: Para gerenciamento de projetos Darknet/YOLO, anotação de imagens, verificação de anotações e geração de arquivos de treinamento.

DarkHelp: uma CLI alternativa robusta ao Darknet, com recursos como mosaico de imagens, rastreamento de objetos e uma API C++ para aplicativos comerciais.

Perguntas frequentes sobre Darknet/YOLO: https://darknetcv.ai/faq/

Canal de Stéphane Charette no YouTube: Encontre tutoriais e vídeos de exemplo: https://www.youtube.com/channel/UCOQ-nJ8l6kG3153g09XwY8g

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

Roteiro

Última atualização: 30/10/2024

Concluído:

1. Substituído qsort() por std::sort() quando aplicável durante o treinamento (alguns casos restantes).

2. Removidos check_mistakes, getchar() e system().

3. Darknet convertido para usar o compilador C++ (g++ no Linux, VisualStudio no Windows).

4. Corrigida a compilação do Windows.

5. Suporte Python corrigido.

6. Biblioteca Darknet construída.

7. Rótulos reativados nas previsões (código "alfabeto").

8. Código CUDA/GPU reativado.

9. CUDNN reativado.

10. Metade CUDNN reativada.

11. Removida a arquitetura CUDA codificada.

12. Informações aprimoradas sobre a versão CUDA.

13. AVX reativado.

14. Removidas soluções antigas e Makefile.

15. Tornou o OpenCV não opcional.

16. Removida a dependência da antiga biblioteca pthread.

17. STB removido.

18. CMakeLists.txt reescrito para usar a nova detecção CUDA.

19. Removido o antigo código do "alfabeto" e excluído mais de 700 imagens em dados/rótulos.

20. Implementação de compilação fora do código-fonte.

21. Saída aprimorada do número da versão.

22. Otimizações de desempenho relacionadas ao treinamento (em andamento).

23. Otimizações de desempenho relacionadas à inferência (em andamento).

24. Empregue passagem por referência sempre que possível.

25. Arquivos .hpp limpos.

26. Reescreveu darknet.h.

27. Usado cv::Mat como um objeto C++ adequado em vez de converter para void*.

28. Corrigido ou padronizado como a estrutura interna da imagem é usada.

29. Corrigida a compilação para dispositivos Jetson baseados em ARM (novos dispositivos Jetson Orin estão funcionando).

30. API Python aprimorada na V3.

Metas de curto prazo:

1. Substitua printf() por std::cout (em andamento).

2. Investigue o suporte antigo para câmeras ZED.

3. Melhorar e padronizar a análise de linha de comando (em andamento).

Metas de médio prazo:

1. Remova todo o código char* e substitua por std::string.

2. Elimine os avisos do compilador e garanta o tratamento consistente dos avisos (em andamento).

3. Utilize cv::Mat de forma mais eficaz em vez de estruturas de imagem personalizadas em C (em andamento).

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 (por exemplo, imagens com profundidade adicional ou canal térmico).

7. Limpeza contínua de código (em andamento).

Metas de longo prazo:

1. Resolva problemas de CUDA/CUDNN com todas as GPUs.

2. Reescreva o código CUDA + cuDNN.

3. Explore a adição de suporte para GPUs não NVIDIA.

4. Implementar suporte para caixas delimitadoras giradas ou um atributo "ângulo".

5. Adicione suporte para pontos-chave/esqueletos.

6. Implementar mapas de calor (em andamento).

7. Implementar segmentação.