sst

Estrutura de detecção de objetos Darknet e YOLO

Logotipos !darknet e hank.ai

Darknet é uma estrutura de rede neural de código aberto escrita em C, C++ e CUDA. Ele fornece uma base poderosa para desenvolver e implantar modelos de detecção de objetos.

YOLO (You Only Look Once) é um sistema de detecção de objetos em tempo real de última geração construído sobre a estrutura Darknet. Ele se destaca em velocidade e precisão, tornando-o uma escolha popular para diversas aplicações.

Quer saber mais sobre como Hank.ai está contribuindo para a comunidade Darknet/YOLO?

Explore o site oficial Darknet/YOLO:

Mergulhe nas perguntas frequentes abrangentes sobre Darknet/YOLO:

Junte-se à vibrante comunidade Darknet/YOLO Discord:

Artigos

YOLOv7: Link para o artigo

Scaled-YOLOv4: Link para o papel

YOLOv4: Link para o artigo

YOLOv3: Link para o artigo

Informações gerais

A estrutura Darknet/YOLO continua a ser líder em detecção de objetos, oferecendo consistentemente vantagens de velocidade e precisão em relação a outras estruturas e versões YOLO.

Principais recursos:

1. Código aberto e gratuito: esta estrutura é totalmente gratuita e de código aberto, permitindo que você a incorpore perfeitamente em seus projetos, sem quaisquer restrições de licenciamento.

2. Alto desempenho: Darknet V3 (“Jazz”), lançado em outubro de 2024, atinge desempenho impressionante, atingindo até 1000 FPS para o conjunto de dados LEGO usando uma GPU NVIDIA RTX 3090.

3. Implantação versátil: Darknet/YOLO é compatível com vários dispositivos, desde Raspberry Pi e servidores em nuvem até desktops e equipamentos de treinamento de última geração.

4. Suporte multiplataforma: É conhecido por funcionar perfeitamente em sistemas operacionais Linux, Windows e Mac.

Precisa de ajuda ou deseja discutir Darknet/YOLO? Junte-se à vibrante comunidade no Discord:

Versão Darknet

A evolução do Darknet pode ser rastreada através de suas versões:

1. Versão 0.x (2013-2017): A ferramenta Darknet original desenvolvida por Joseph Redmon não tinha um número de versão formal.

2. Versão 1.x (2017-2021): Esta versão foi mantida por Alexey Bochkovskiy e também não tinha um número de versão.

3. Versão 2.x "OAK" (2023): O repositório Darknet, patrocinado por Hank.ai e mantido por Stéphane Charette, introduziu um comando de versão. Esta versão trouxe melhorias significativas, incluindo:

* Etapas de construção unificadas usando CMake para Windows e Linux.

* Conversão para o compilador C++.

* Visualização melhorada do chart.png durante o treinamento.

* Correções de bugs e otimizações de desempenho para eficiência de treinamento.

4. Versão 2.1: A ramificação final da base de código v2.

5. Versão 3.x "JAZZ" (outubro de 2024): Esta versão mais recente introduziu:

* Otimizações de desempenho para treinamento e inferência.

* Uma API C legada modificada que requer pequenas adaptações para aplicativos que usam a API Darknet original.

* Uma nova API Darknet V3 C e C++.

* Novos aplicativos e código de exemplo no diretório src-examples.

Para compatibilidade com versões mais antigas, o branch v2 ainda está acessível. Se você precisar usar comandos específicos de versões anteriores, informe-nos e exploraremos como adicioná-los novamente.

Pesos pré-treinados MSCOCO

Várias versões populares do YOLO vêm pré-treinadas no conjunto de dados MSCOCO, oferecendo um ponto de partida conveniente para experimentar a estrutura. MSCOCO contém 80 classes, listadas no arquivo cfg/coco.names.

Pesos pré-treinados disponíveis:

YOLOv2 (novembro de 2016):

* yolov2-tiny.pesos

* yolov2-full.pesos

YOLOv3 (maio de 2018):

* yolov3-tiny.pesos

* yolov3-full.pesos

YOLOv4 (maio de 2020):

* yolov4-tiny.pesos

* yolov4-full.pesos

YOLOv7 (agosto de 2022):

* yolov7-tiny.pesos

* yolov7-full.pesos

Lembre-se: embora esses pesos pré-treinados sejam úteis para demonstrações, é essencial treinar suas próprias redes para soluções personalizadas. MSCOCO é usado principalmente para verificar se sua configuração está funcionando corretamente.

Comandos de exemplo usando pesos pré-treinados:

`bash

Exibir imagens anotadas

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

Exibir vídeos com anotações

darknet03display_videos coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi

Use DarkHelp CLI

DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights image1.jpg

DarkHelp coco.names yolov4-tiny.cfg yolov4-tiny.weights video1.avi

`

Prédio

Darknet aproveita o CMake para agilizar o processo de construção para Windows e Linux. Requer C++17 ou um compilador mais recente, junto com OpenCV.

As instruções de construção agora estão unificadas, substituindo métodos mais antigos e complexos.

Observação: se você estiver enfrentando problemas com tutoriais antigos ou etapas de criação que não estejam alinhadas com este guia, consulte as instruções mais recentes fornecidas aqui.

Os desenvolvedores de software são incentivados a visitar https://darknetcv.ai/ para obter informações sobre o funcionamento interno da estrutura Darknet/YOLO.

Google Colab

As instruções do Google Colab refletem as instruções do Linux.

Explore os notebooks no subdiretório colab 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 ~/src

cd ~/src

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

cd rede escura

compilação mkdir

compilação de CD

`

3. Configure o CMake:

`bash

cmake -DCMAKEBUILDTYPE=Liberar ..

`

4. Construir Darknet:

`bash

faça -j4

`

5. Pacote Darknet:

`bash

pacote

sudo dpkg -i darknet-VERSION.deb

`

Opcional: CUDA ou CUDA+cuDNN para aceleração de GPU

Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.

Visite https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview para fazer download e instale o cuDNN.

Após instalar o CUDA, certifique-se de que nvcc e nvidia-smi estejam acessíveis. Talvez seja necessário ajustar sua variável PATH.

Se você instalar CUDA ou CUDA+cuDNN posteriormente ou atualizar o software NVIDIA:

Exclua o arquivo CMakeCache.txt em seu diretório de construção Darknet para forçar o CMake a reencontrar as dependências.

Reconstrua o Darknet.

Para atualizar o CMake no Ubuntu:

`bash

sudo apt-get purge cmake

sudo snap install cmake --classic

`

Usuários avançados:

Para construir um arquivo de instalação RPM em vez de um arquivo DEB, modifique o CPACKGENERATOR em CMpackage.cmake para "RPM".

Para Centos e OpenSUSE, altere CPACK_GENERATOR para “RPM”.

Após construir o pacote de instalação, use o gerenciador de pacotes apropriado para instalá-lo.

Verificação:

Execute a versão darknet na linha de comando para confirmar a instalação.

Método CMake do Windows

1. Instale o software necessário:

`bash

winget instalar Git.Git

winget instalar Kitware.CMake

winget instalar nsis.nsis

instalar winget Microsoft.VisualStudio.2022.Community

`

2. Modifique a instalação do Visual Studio:

* Abra o "Instalador do Visual Studio".

* Clique em "Modificar".

* Selecione "Desenvolvimento de desktop com C++".

* Clique em “Modificar” e depois em “Sim”.

3. Abra o prompt de comando do desenvolvedor para VS 2022:

* Não use o PowerShell.

4. Instale o Microsoft VCPKG:

`bash

CDC:

mkdir c:src

cd c:src

clone do git https://github.com/microsoft/vcpkg

CD vcpkg

bootstrap-vcpkg.bat

.vcpkg.exe integrar instalação

.vcpkg.exe integrar powershell

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

`

5. Opcional: CUDA ou CUDA+cuDNN para aceleração de GPU

* Instale o CUDA seguindo as instruções em https://developer.nvidia.com/cuda-downloads.

* Instale o cuDNN usando as instruções em https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows.

Após a instalação, certifique-se de que nvcc.exe e nvidia-smi.exe estejam acessíveis. Pode ser necessário modificar sua variável PATH.

Se você instalar CUDA ou CUDA+cuDNN posteriormente ou atualizar o software NVIDIA:

* Certifique-se de que o CUDA esteja instalado após o Visual Studio.

* Reinstale o CUDA se o Visual Studio for atualizado.

6. Clone Darknet e construa-o:

`bash

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

`

7. Copie DLLs CUDA (se necessário):

* Se você receber erros sobre DLLs CUDA ou cuDNN ausentes, copie-os manualmente para o diretório de saída Darknet. Por exemplo:

`bash

copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease

`

8. Execute novamente o comando msbuild.exe para gerar o pacote de instalação do NSIS:

`bash

msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj

`

Usuários avançados:

Você pode usar o arquivo de solução Darknet.sln gerado pelo CMake na GUI do Visual Studio em vez de ferramentas de linha de comando.

Verificação:

Execute a versão C:srcDarknetbuildsrc-cliReleasedarknet.exe para confirmar a instalação.

Para instalar o Darknet, execute o assistente de instalação do NSIS:

Procure o arquivo darknet-VERSION.exe no diretório de construção.

Execute o assistente de instalação para instalar o aplicativo CLI, bibliotecas, arquivos de inclusão e DLLs necessárias.

Usando Darknet

CLI

Nota: Os comandos a seguir não são completos.

Além da CLI Darknet, considere usar a CLI do projeto DarkHelp, que oferece funcionalidades alternativas e recursos avançados.

A maioria dos comandos requer o arquivo .weights junto com seus arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede ou baixar modelos pré-treinados da Internet. 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 classe 80.

Comandos:

1. Ajuda:

`bash

ajuda darknet

`

2. Versão:

`bash

versão darknet

`

3. Previsão 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. Salvando 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 multithreaded.cfg animais.nomes animais_best.teste de pesos.mp4

`

* DarkHelp:

`bash

DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4

`

8. Saída 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. Verificando a precisão da rede neural:

`bash

mapa do detector darknet driving.data driving.cfg driving_best.weights ...

`

11. Cálculo de mAP@IoU=75:

`bash

mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75

`

12. Recálculo de âncoras:

`bash

detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256

`

13. Treinando uma nova rede:

`bash

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

`

Treinamento

Para anotação e treinamento simplificados, utilize DarkMark. É a abordagem recomendada para a criação de novas redes neurais.

Configuração manual de treinamento (se preferir):

1. Crie uma pasta de projeto:

* Por exemplo, ~/nn/animals/ para detecção de animais.

2. Copie um arquivo de configuração Darknet como modelo:

* Por exemplo, cfg/yolov4-tiny.cfg.

3. Crie um arquivo de texto Animals.names:

* Liste cada turma, uma entrada por linha, sem linhas em branco ou comentários. Exemplo:

`

cachorro

gato

pássaro

cavalo

`

4. Crie um arquivo de texto Animals.data:

`

aulas = 4

trem = /home/nomedeusuário/nn/animais/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 imagens e anotações (por exemplo, ~/nn/animals/dataset).

* Anote imagens usando DarkMark ou software similar. O formato de anotação YOLO é descrito nas Perguntas frequentes da Darknet/YOLO.

6. Crie animaistrain.txt e animaisvalid.txt:

* Liste todas as imagens utilizadas para treinamento e validação, uma imagem por linha.

7. Modifique o arquivo .cfg:

* Definir lote = 64.

* Ajuste as subdivisões com base nas dimensões da rede e na memória da GPU. Comece com subdivisões=1.

* Defina max_batches como 2.000 vezes o número de classes (por exemplo, 8.000 para 4 classes).

* Defina etapas para 80% e 90% de max_batches.

* Ajuste a largura e a altura para corresponder às dimensões de rede desejadas.

* Modifique as classes para refletir o número de classes em seu arquivo .names.

Atualize os filtros nas seções [convolucionais] antes de cada seção [yolo]: (numberofclasses + 5) 3.

8. Comece a treinar:

`bash

cd ~/nn/animais/

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

`

Para obter mais detalhes de treinamento e parâmetros avançados, consulte as perguntas frequentes do Darknet/YOLO.

Outras ferramentas e links

DarkMark: gerencie projetos Darknet/YOLO, anote imagens, verifique anotações e gere arquivos de treinamento.

DarkHelp: Fornece uma CLI alternativa para Darknet, permitindo agrupamento de imagens, rastreamento de objetos e uma API C++ robusta para aplicativos comerciais.

Darknet/YOLO FAQ: Um recurso abrangente para responder às suas perguntas.

Canal de Stéphane no YouTube: Acesse vários tutoriais e vídeos de exemplo.

Darknet/YOLO Discord Server: Conecte-se com outros usuários para suporte e discussões.

Roteiro

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

Concluído:

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

Check_mistakes, getchar() e system() foram removidos.

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

Versão corrigida do Windows.

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

Código CUDA/GPU reativado, CUDNN e metade CUDNN.

Arquitetura CUDA codificada removida.

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

AVX reativado.

Removidas soluções antigas e Makefiles.

Tornou o OpenCV uma dependência não opcional.

Removida a antiga dependência da biblioteca pthread.

STB removido.

CMakeLists.txt reescrito para melhorar a detecção de CUDA.

Removido o antigo código do "alfabeto" e imagens associadas.

Compilação fora do código-fonte implementada.

Saída de número de versão aprimorada.

Otimizações de desempenho durante o treinamento (contínuo).

Otimizações de desempenho durante a inferência (em andamento).

Implementado passagem por referência sempre que possível.

Arquivos .hpp limpos.

Reescreveu darknet.h.

Eliminada a conversão de cv::Mat para void e usada como um objeto C++.

Corrigidas inconsistências na estrutura interna da imagem.

Compilação corrigida para dispositivos Jetson baseados em ARM (novos dispositivos Jetson Orin estão funcionando).

API Python corrigida na V3.

Metas de curto prazo:

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

Revisite o suporte antigo da câmera Zed.

Melhore a consistência da análise da linha de comando (em andamento).

Metas de médio prazo:

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

Elimine avisos do compilador e melhore a clareza do código (em andamento).

Aprimore o uso de cv::Mat em vez da estrutura de imagem personalizada em C (em andamento).

Substitua a funcionalidade de lista antiga por std::vector ou std::list.

Adicionado suporte para imagens em escala de cinza de 1 canal.

Estenda o suporte para imagens de canais N (N > 3, por exemplo, canais de profundidade ou térmicos).

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

Metas de longo prazo:

Resolva problemas de CUDA/CUDNN em todas as GPUs.

Reescreva o código CUDA + cuDNN.

Explore o suporte para GPUs não NVIDIA.

Implemente caixas delimitadoras giradas ou suporte de "ângulo".

Adicione pontos-chave/esqueletos.

Introduzir mapas de calor (em andamento).

Explore a segmentação.

Fique ligado nas atualizações e contribuições para a estrutura Darknet/YOLO!