Sistema de financiamento coletivo RaiseDreams v191113
191113
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 que roda dentro da estrutura Darknet.
Saiba como Hank.ai está capacitando a comunidade Darknet/YOLO!
Anunciando Darknet V3 "Jazz"
Visite o site Darknet/YOLO
Explore as perguntas frequentes da Darknet/YOLO
Junte-se ao servidor Darknet/YOLO Discord
Artigos
1. Artigo YOLOv7: Link para o artigo
2. Papel em escala-YOLOv4: link para papel
3. Artigo YOLOv4: Link para o artigo
4. Artigo YOLOv3: Link para o artigo
Informações gerais
A estrutura Darknet/YOLO supera consistentemente outras estruturas e versões YOLO em velocidade e precisão.
Esta estrutura é totalmente gratuita e de código aberto. Você pode integrar Darknet/YOLO perfeitamente em seus projetos e produtos existentes, inclusive comerciais, sem quaisquer taxas de licenciamento.
Darknet V3 ("Jazz"), lançado em outubro de 2024, atinge desempenho notável, executando os vídeos do conjunto de dados LEGO a até 1000 FPS em uma GPU NVIDIA RTX 3090. Isso se traduz no processamento Darknet/YOLO de cada quadro de vídeo, incluindo redimensionamento e processamento, em menos de 1 milissegundo.
Junte-se ao servidor Darknet/YOLO Discord para suporte e discussão: https://discord.gg/zSq8rtW
A versão CPU do Darknet/YOLO opera com eficiência em vários dispositivos, incluindo Raspberry Pi, servidores em nuvem e colab, desktops, laptops e plataformas de treinamento de última geração. No entanto, a versão GPU do Darknet/YOLO requer uma GPU da NVIDIA compatível com CUDA.
Darknet/YOLO é compatível com os sistemas operacionais Linux, Windows e Mac. Consulte as instruções de construção abaixo para obter orientação detalhada.
Versão Darknet
A ferramenta Darknet original desenvolvida por Joseph Redmon entre 2013-2017 não tinha um número de versão. Nos referimos a esta versão como 0.x.
O popular repositório Darknet subsequente mantido por Alexey Bochkovskiy de 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, introduziu pela primeira vez um comando de versão. De 2023 até o final de 2024, retornou a versão 2.x “OAK”.
A equipe de desenvolvimento se concentrou em minimizar a interrupção das funcionalidades existentes enquanto se familiarizava com a base de código.
As principais mudanças implementadas durante este período incluem:
1. Processo de construção unificado: etapas de construção reescritas para agilizar o processo usando CMake para Windows e Linux.
2. Conversão C++: A base de código foi convertida para utilizar o compilador C++.
3. Aprimoramento do gráfico: A visualização do chart.png foi aprimorada durante o treinamento.
4. Correções de bugs e otimizações: Inúmeras correções de bugs e otimizações relacionadas ao desempenho foram implementadas, focadas principalmente na redução do tempo de treinamento.
A ramificação final desta base de código é a versão 2.1, localizada na ramificação v2.
A próxima fase de desenvolvimento começou em meados de 2024 e culminou com o lançamento da versão 3.x "JAZZ" em outubro de 2024. O comando version agora retorna 3.x.
Você sempre pode reverter para a ramificação v2 anterior se precisar executar comandos específicos dessa versão. Informe a equipe de desenvolvimento se você encontrar algum comando ausente e eles investigarão como adicioná-los novamente.
Mudanças significativas introduzidas na versão 3.x "JAZZ":
1. Remoção de comandos: muitos comandos desatualizados e sem suporte foram removidos.
2. Otimizações de desempenho: Inúmeras otimizações de desempenho foram aplicadas tanto para treinamento quanto para inferência.
3. Modificação da API: A API C legada passou por modificações. Aplicativos que usam a API Darknet original podem exigir pequenos ajustes. https://darknetcv.ai/api/api.html
4. Nova API C/C++: Darknet V3 apresenta uma nova API C e C++. https://darknetcv.ai/api/api.html
5. Código de amostra aprimorado: Novos aplicativos e código de amostra estão disponíveis 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 inclui 80 classes, listadas no arquivo de texto cfg/coco.names.
Além do MSCOCO, vários conjuntos de dados mais simples e pesos pré-treinados estão disponíveis para testar Darknet/YOLO, como LEGO Gears e Rolodex. Consulte as Perguntas frequentes sobre Darknet/YOLO para obter mais detalhes.
Os pesos pré-treinados do MSCOCO podem ser baixados de várias fontes, incluindo este repositório:
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
Os pesos pré-treinados da MSCOCO são fornecidos apenas para fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO residem no diretório cfg.
Aqui estão alguns exemplos de comandos:
`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
`
Os usuários são incentivados a treinar suas próprias redes. O MSCOCO serve principalmente como uma ferramenta para verificar se tudo está funcionando corretamente.
Prédio
Os vários métodos de construção empregados antes de 2023 foram consolidados em uma solução unificada. Darknet requer C++17 ou uma versão mais recente, OpenCV, e aproveita o CMake para gerar os arquivos de projeto necessários.
Construir Darknet/YOLO não requer conhecimento de C++. É análogo a dirigir um carro sem ser mecânico.
Google Colab
As instruções do Google Colab refletem as do Linux. Vários notebooks Jupyter estão disponíveis para demonstrar tarefas específicas, como treinar uma nova rede.
Explore os notebooks no subdiretório colab ou siga as instruções do Linux abaixo.
Método Linux CMake
Tutorial de construção Darknet para Linux
1. Pré-requisitos: Certifique-se de ter os seguintes pacotes instalados:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clone Darknet: Clone o repositório Darknet:
`bash
mkdir ~/srccd ~/src
clone do git https://github.com/hank-ai/darknet
cd rede escura
`
3. Criar diretório de construção: Crie um diretório de construção:
`bash
compilação mkdir
compilação de CD
`
4. Configure com CMake: Execute o CMake para configurar a compilação:
`bash
cmake -DCMAKEBUILDTYPE=Liberar ..
`
5. Construir: Construir o projeto:
`bash
faça -j4
`
6. Pacote: Crie um pacote Debian:
`bash
fazer pacote
`
7. Instalar: Instale o pacote:
`bash
sudo dpkg -i darknet-VERSION.deb
`
Opcional: CUDA/cuDNN para aceleração de GPU
1. Instale CUDA: Se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA para aceleração de GPU. Baixe e instale o CUDA em https://developer.nvidia.com/cuda-downloads.
2. Instale o cuDNN: 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- visão geral da instalação do gerenciador de pacotes.
3. Verifique a instalação do CUDA: Certifique-se de que você pode executar nvcc e nvidia-smi após instalar o CUDA. Pode ser necessário ajustar sua variável PATH.
4. Configuração do CMake (se o CUDA for instalado após o CMake): Se você instalar o CUDA ou CUDA + cuDNN após configurar o CMake, será necessário excluir o arquivo CMakeCache.txt no diretório de construção Darknet para forçar o CMake a reencontrar os arquivos necessários. Em seguida, execute novamente o CMake e reconstrua o Darknet.
Usuários avançados
Pacote RPM: para construir um arquivo de instalação RPM em vez de um arquivo DEB, modifique as seguintes linhas em CM_package.cmake:
`cmake
#SET(CPACK_GENERATOR"DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Distribuições como Centos e OpenSUSE: Para distribuições como Centos e OpenSUSE, altere as linhas em CM_package.cmake para:
`cmake
#SET(CPACK_GENERATOR"DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Pacote de instalação: Para instalar o pacote após a compilação, use o gerenciador de pacotes da sua distribuição. Por exemplo, em sistemas baseados em Debian como Ubuntu, use sudo dpkg -i darknet-2.0.1-Linux.deb.
Arquivos principais instalados:
/usr/bin/darknet: O principal executável do Darknet. Confirme a instalação executando a versão darknet na CLI.
/usr/include/darknet.h: A API Darknet para desenvolvedores C, C++ e Python.
/usr/include/darknet_version.h: Contém informações de versão para desenvolvedores.
/usr/lib/libdarknet.so: A biblioteca a ser vinculada para desenvolvedores C, C++ e Python.
/opt/darknet/cfg/...: Armazena todos os modelos .cfg.
Método CMake do Windows
Tutorial de construção para Windows (assumindo uma nova instalação do Windows 11 22H2)
1. Pré-requisitos de instalação: Instale os componentes necessários usando winget:
`bash
winget instalar Git.Git
winget instalar Kitware.CMake
winget instalar nsis.nsis
instalar winget Microsoft.VisualStudio.2022.Community
`
2. Instale o suporte do Visual Studio C++: Modifique a instalação do Visual Studio para incluir o suporte do C++:
* Abra o menu “Iniciar do Windows” e execute o “Visual Studio Installer”.
* Clique em "Modificar".
* Selecione "Desenvolvimento Desktop com C++".
* Clique em “Modificar” no canto inferior direito e depois em “Sim”.
3. Prompt de comando do desenvolvedor: Inicie o “Prompt de comando do desenvolvedor para VS 2022” no menu “Iniciar do Windows”. Não use o PowerShell para estas etapas!
4. Instale o Microsoft VCPKG: Instale o VCPKG para construir o OpenCV:
`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
`
* Seja paciente, esta etapa pode levar um tempo significativo, pois é necessário baixar e construir vários componentes.
5. Opcional: CUDA/cuDNN para aceleração de GPU: siga as mesmas etapas descritas na seção Linux.
6. Clone Darknet: Clone o repositório Darknet:
`bash
cd c:src
clone do git https://github.com/hank-ai/darknet.git
cd rede escura
compilação mkdir
compilação de CD
`
7. Configure com CMake: Configure a compilação usando CMake:
`bash
cmake -DCMAKEBUILDTYPE=Liberar -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
8. Construa com msbuild: Construa o projeto usando msbuild:
`bash
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
Solução de problemas: DLLs CUDA/cuDNN ausentes
Se você encontrar erros sobre DLLs CUDA ou cuDNN ausentes (por exemplo, cublas64_12.dll), copie manualmente os arquivos .dll CUDA para o mesmo diretório de saída que darknet.exe. Por exemplo:
`bash
copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
* Lembre-se de ajustar o comando com base na sua versão CUDA.
Execute novamente o comando msbuild.exe após copiar as DLLs.
Usuários avançados
Solução Visual Studio: CMake gera um arquivo de solução Visual Studio (Darknet.sln). Os desenvolvedores de software que preferem usar a GUI do Visual Studio podem carregar o projeto Darknet no Visual Studio em vez de usar a linha de comando.
Verificação e instalação
Verificação: Execute o seguinte comando para verificar se Darknet foi construído corretamente:
`bash
C: versão srcDarknetbuildsrc-cliReleasedarknet.exe
`
Instalação: Execute o assistente de instalação NSIS gerado na última etapa para instalar corretamente Darknet, bibliotecas, incluir arquivos e DLLs necessárias. Localize o arquivo darknet-VERSION.exe no diretório de construção. Por exemplo: darknet-2.0.31-win64.exe.
Arquivos principais instalados:
C:Arquivos de programasDarknetbin/darknet.exe: O aplicativo Darknet CLI.
C:Arquivos de ProgramasDarknet/bin: Contém outros aplicativos de amostra.
C:Arquivos de programasDarknet: Inclui arquivos .dll de terceiros necessários (OpenCV), arquivos Darknet .dll, .lib e .h e arquivos .cfg de modelo.
Usando Darknet
CLI
A lista a seguir não esgota todos os comandos suportados pelo Darknet.
Além da CLI Darknet, considere a CLI do projeto DarkHelp, que oferece uma CLI alternativa com vários recursos avançados não disponíveis diretamente na Darknet. Você pode usar as duas CLIs simultaneamente.
Pré-requisitos essenciais:
Para a maioria dos comandos, você precisa de um arquivo .weights junto com os arquivos .names e .cfg correspondentes.
Treine sua própria rede (altamente recomendado!) ou baixe uma rede pré-treinada da internet.
Exemplos de conjuntos de dados pré-treinados:
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 de exemplo:
1. Obtenha ajuda:
`bash
ajuda darknet
`
2. Verifique a versão:
`bash
versão darknet
`
3. Previsão de imagem:
V2:
`bash
teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg
`
V3:
`bash
darknet02displayannotatedimages cars.cfg image1.jpg
`
Ajuda escura:
`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
`
Ajuda escura:
`bash
DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg
`
5. Processamento de vídeo:
V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights -extoutput test.mp4
`
V3:
`bash
darknet03display_videos animais.cfg teste.mp4
`
Ajuda escura:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
6. Processamento de webcam:
V2:
`bash
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
`
V3:
`bash
darknet08display_webcam animais
`
7. Saída de 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
`
Ajuda escura:
`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
`
Ajuda escura:
`bash
DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg
`
9. GPU específica:
V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4
`
10. Avaliação de Precisão:
mapa:
`bash
mapa do detector darknet driving.data driving.cfg driving_best.weights ...
`
mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
11. Cálculo da Âncora:
DarkMark: Use DarkMark para recalcular âncoras para desempenho ideal.
Darknet (método mais antigo):
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
12. Treinando uma Nova Rede:
DarkMark (recomendado): Use DarkMark para anotação e treinamento.
Configuração manual:
1. Criação de diretório: Crie uma pasta para seu projeto (por exemplo, ~/nn/animals/).
2. Arquivo de configuração: Copie um arquivo de configuração Darknet como modelo (por exemplo, cfg/yolov4-tiny.cfg).
3. Arquivo .names: Crie um arquivo de texto .names listando suas classes (por exemplo, ~/nn/animals/animals.names).
4. Arquivo .data: Crie um arquivo de texto .data na mesma pasta do arquivo de configuração (por exemplo, ~/nn/animals/animals.data).
5. Pasta Dataset: Crie uma pasta para suas imagens e anotações (por exemplo, ~/nn/animals/dataset).
6. Anotações .txt: Gere arquivos .txt para cada imagem, contendo coordenadas de anotação. Use DarkMark ou outras ferramentas de anotação.
7. Arquivos train/valid: Crie arquivos Animalstrain.txt e Animalsvalid.txt listando suas imagens de treinamento e validação.
8. Modifique o arquivo .cfg: ajuste o arquivo de configuração com base no seu conjunto de dados.
* Definir lote = 64.
* Ajuste as subdivisões com base na memória da sua GPU.
Defina max_batches para um número de 2.000 classes.
* Defina etapas para 80% e 90% de max_batches.
* Ajuste a largura e a altura com base nas dimensões da rede.
* Defina classes=... como o número de classes em seu arquivo .names.
Ajuste filtros=... nas seções [convolucionais] antes de cada seção [yolo] para (número de classes + 5) 3.
9. Treinamento: Comece o treinamento:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
* Os melhores pesos serão salvos como Animals_best.weights.
* Visualize o arquivo chart.png para monitorar o progresso do treinamento.
Outras ferramentas e links
Recursos principais:
DarkMark: Para gerenciar projetos Darknet/YOLO, anotar imagens, verificar anotações e gerar arquivos de treinamento.
DarkHelp: uma CLI alternativa robusta ao Darknet, com recursos como mosaico de imagens, rastreamento de objetos em vídeos e uma API C++ robusta adequada para aplicações comerciais.
Perguntas frequentes sobre Darknet/YOLO: Encontre respostas para perguntas e soluções comuns.
Canal de Stéphane no YouTube: explore tutoriais e vídeos de exemplo.
Servidor Darknet/YOLO Discord: Conecte-se com outros usuários Darknet/YOLO para suporte e discussões.
Roteiro
Última atualização em 30/10/2024:
Tarefas concluídas:
1. Substituído qsort() por std::sort() nas seções de treinamento relevantes.
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 código antigo do "alfabeto" e imagens excluídas em dados/rótulos.
20. Compilação fora do código-fonte habilitada.
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. Implementação de passagem por referência quando aplicável.
25. Arquivos .hpp limpos.
26. Darknet.h reescrito.
27. Eliminada a conversão de cv::Mat para void*, usando-o como um objeto C++ adequado.
28. Melhor consistência na forma como a estrutura interna da imagem é usada.
29. Corrigida compilação para dispositivos Jetson baseados em ARM.
30. API Python corrigida na V3.
Metas de curto prazo:
1. Substitua printf() por std::cout (em andamento).
2. Investigue o suporte a câmeras Zed antigas.
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 avisos do compilador (em andamento).
3. Melhorar o uso de cv::Mat em vez da estrutura de imagem customizada 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 canais térmicos).
7. Limpeza contínua de código (em andamento).
Metas de longo prazo:
1. Resolva problemas de CUDA/CUDNN em todas as GPUs.
2. Reescrevendo o código CUDA+cuDNN.
3. Explore o suporte para GPUs não NVIDIA.
4. Implemente caixas delimitadoras giradas ou suporte de "ângulo".
5. Suporte para pontos-chave/esqueletos.
6. Suporte para mapas de calor (em andamento).
7. Segmentação.
