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 alvos em tempo real de última geração que roda na estrutura Darknet.
Leia como Hank.ai ajuda a comunidade Darknet/YOLO
Anunciando Darknet V3 "Jazz"
Confira o site Darknet/YOLO
Por favor, leia as perguntas frequentes da Darknet/YOLO
Junte-se ao servidor Darknet/YOLO Discord
Artigos
1. Artigo YOLOv7
2. Papel em escala-YOLOv4
3. Artigo YOLOv4
4. Artigo YOLOv3
Informações gerais
A estrutura Darknet/YOLO ainda é mais rápida e precisa do que outras estruturas e versões YOLO.
Esta estrutura é totalmente gratuita e de código aberto. Você pode integrar Darknet/YOLO em projetos e produtos existentes - incluindo produtos comerciais - sem licenciamento ou taxas.
Darknet V3 ("Jazz"), lançado em outubro de 2024, pode executar com precisão vídeos de conjuntos de dados LEGO em até 1000 FPS usando GPUs NVIDIA RTX 3090, o que significa que cada quadro de vídeo é capturado pela Darknet em 1 milissegundo ou menos /YOLO Ler, redimensionar e processar .
Se você precisar de ajuda ou quiser discutir Darknet/YOLO, entre no servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW
A versão CPU do Darknet/YOLO pode ser executada em dispositivos simples, como Raspberry Pi, servidores em nuvem e de colaboração, 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 bem em Linux, Windows e Mac. Veja as instruções de construção abaixo.
Versão Darknet
As ferramentas Darknet originais escritas por Joseph Redmon em 2013-2017 não tinham números de versão. Consideramos esta versão como 0.x.
O próximo repositório Darknet popular mantido por Alexey Bochkovskiy de 2017-2021 também não tem número de versão. Acreditamos que esta versão seja 1.x.
O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette desde 2023 é o primeiro a ter um comando de versão. De 2023 até o final de 2024, retorna para a versão 2.x “OAK”.
O objetivo é tentar quebrar o mínimo possível a funcionalidade existente enquanto se familiariza com a base de código.
1. Reescreva as etapas de construção para que tenhamos uma maneira unificada de construir no Windows e Linux usando CMake.
2. Converta a base de código para usar um 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 a rede.
A última ramificação da base de código é a versão 2.1 na ramificação v2.
A próxima fase de desenvolvimento começa em meados de 2024 e será lançada em outubro de 2024. O comando version agora retorna 3.x "JAZZ".
Você sempre pode fazer check-out da ramificação v2 anterior se precisar executar o comando a seguir. Informe-nos para que possamos investigar a adição de comandos ausentes.
1. Muitos comandos antigos e não mantidos foram removidos.
2. Muitas otimizações de desempenho, incluindo processos de treinamento e inferência.
3. A API C tradicional foi modificada; os aplicativos que usam a API Darknet original precisarão fazer 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
Por conveniência, várias versões populares do YOLO são pré-treinadas no conjunto de dados MSCOCO. Este conjunto de dados possui 80 categorias e pode ser visto 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. Para obter mais informações, consulte as perguntas frequentes do Darknet/YOLO.
Os pesos pré-treinados do MSCOCO podem ser baixados de vários locais diferentes ou deste 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 apenas para fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO estão localizados no diretório cfg. Comando 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 deve-se treinar sua própria rede. MSCOCO é frequentemente usado para confirmar se está tudo bem.
construir
Vários métodos de construção do passado (pré-2023) foram fundidos numa solução unificada. Darknet requer C++17 ou superior, OpenCV e uso de CMake para gerar os arquivos de projeto necessários.
Você não precisa saber C++ para construir, instalar ou executar Darknet/YOLO, assim como não precisa ser mecânico para dirigir um carro.
Google Colab
As instruções do Google Colab são iguais às instruções do Linux. Existem vários notebooks Jupyter mostrando como realizar determinadas tarefas, como treinar uma nova rede.
Consulte o notebook no subdiretório colab ou siga as instruções do Linux abaixo.
Método Linux CMake
Tutorial de construção Darknet para Linux
Opcional: se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN neste momento. Se instalado, o Darknet usará sua GPU para acelerar o processamento de imagens (e vídeos).
Você deve excluir o arquivo CMakeCache.txt no diretório de construção Darknet para forçar o CMake a reencontrar todos os arquivos necessários.
Lembre-se de reconstruir o Darknet.
Darknet pode ser executado sem ele, mas se você quiser treinar uma rede personalizada, você precisa de CUDA ou CUDA+cuDNN.
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.
Depois de instalar o CUDA, certifique-se de que nvcc e nvidia-smi possam ser executados. Pode ser necessário modificar a variável PATH.
Se você instalar CUDA ou CUDA+cuDNN posteriormente, ou se atualizar para uma versão mais recente do software NVIDIA, faça o seguinte:
Estas instruções assumem (mas não exigem!) um sistema rodando Ubuntu 22.04. Se estiver usando outra distribuição, ajuste conforme necessário.
`bash
sudo apt-get install build-essential git libopencv-dev cmake mkdir ~/srccd ~/src git clone https://github.com/hank-ai/darknetcd darknet mkdir buildcd build cmake -DCMAKEBUILDTYPE=Release .. make -j4 package sudo dpkg -i darknet-VERSION.deb
`
Se estiver usando uma versão mais antiga do CMake, você precisará atualizar o CMake antes de executar o comando cmake acima. A atualização do CMake no Ubuntu pode ser feita usando o seguinte comando:
`bash
sudo apt-get purge cmake sudo snap install cmake --classic
`
Se estiver usando o bash como seu shell de comando, você precisará reiniciar o shell neste momento. Se você usar peixe, ele deverá seguir o novo caminho imediatamente.
Usuários avançados:
Se você deseja construir um arquivo de instalação RPM em vez de um arquivo DEB, consulte as linhas relevantes em CM_package.cmake. Antes de executar make -j4 package você precisa editar estas duas linhas:
`bash
SET (CPACKGENERATOR "DEB")#SET (CPACKGENERATOR "RPM")
`
Para distribuições como Centos e OpenSUSE, você precisa alterar essas duas linhas em CM_package.cmake para:
`bash
SET (CPACKGENERATOR "DEB")SET (CPACKGENERATOR "RPM")
`
Para instalar o pacote de instalação, uma vez compilado, use o gerenciador de pacotes usual da sua distribuição. Por exemplo, em um sistema baseado em Debian como o Ubuntu:
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
A instalação do pacote .deb copiará os seguintes arquivos:
1. /usr/bin/darknet é o arquivo executável normal do Darknet. Execute a versão darknet da CLI para confirmar se ela está instalada corretamente.
2. /usr/include/darknet.h é a API Darknet para desenvolvedores C, C++ e Python.
3. /usr/include/darknet_version.h contém informações de versão para desenvolvedores.
4. /usr/lib/libdarknet.so é uma biblioteca para desenvolvedores C, C++ e Python.
5. /opt/darknet/cfg/... é o local onde todos os modelos .cfg são armazenados.
Você terminou agora! Darknet é construído e instalado em /usr/bin/. Execute o seguinte comando para testar: versão darknet.
Se você não tem /usr/bin/darknet, você não o instalou, apenas o construiu! Certifique-se de instalar o arquivo .deb ou .rpm conforme descrito acima.
Métodos CMake do Windows
Estas instruções pressupõem uma nova instalação do Windows 11 22H2.
Abra uma janela normal do prompt de comando cmd.exe e execute o seguinte comando:
`bash
winget instalar Git.Git winget instalar Kitware.CMake winget instalar nsis.nsis winget instalar Microsoft.VisualStudio.2022.Community
`
Neste ponto, precisamos modificar a instalação do Visual Studio para incluir suporte para aplicativos C++:
1. Clique no menu Iniciar do Windows e execute a instalação do Visual Studio.
2. Clique em Editar.
3. Escolha o desenvolvimento de desktop usando C++.
4. Clique em “Editar” no canto inferior direito e clique em “Sim”.
Depois que tudo for baixado e instalado, clique no menu Iniciar do Windows novamente e selecione Prompt de comando do desenvolvedor para VS 2022. Não use o PowerShell para executar essas etapas, você terá problemas!
Usuários avançados:
Em vez de executar o prompt de comando do desenvolvedor, você pode usar um prompt de comando normal ou fazer login no dispositivo usando ssh e executar "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat" manualmente.
Depois de executar o prompt de comando do desenvolvedor conforme descrito acima (não o PowerShell!), Execute o seguinte comando para instalar o Microsoft VCPKG e use-o para construir o OpenCV:
`bash
cd c: mkdir c: srccd c: src git clone https://github.com/microsoft/vcpkgcd 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 com esta última etapa, pois pode demorar muito para ser executada. Requer baixar e construir muitas coisas.
Usuários avançados:
Observe que existem muitos outros módulos opcionais que você pode querer adicionar ao construir o OpenCV. Execute .vcpkg.exe e pesquise opencv para ver a lista completa.
Opcional: se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN neste momento. Se instalado, o Darknet usará sua GPU para acelerar o processamento de imagens (e vídeos).
Você deve excluir o arquivo CMakeCache.txt no diretório de construção Darknet para forçar o CMake a reencontrar todos os arquivos necessários.
Lembre-se de reconstruir o Darknet.
Darknet pode ser executado sem ele, mas se você quiser treinar uma rede personalizada, você precisa de CUDA ou CUDA+cuDNN.
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#download-windows para baixar e instalar o cuDNN.
Depois de instalar o CUDA, certifique-se de executar nvcc.exe e nvidia-smi.exe. Pode ser necessário modificar a variável PATH.
Depois de baixar o cuDNN, descompacte e copie os diretórios bin, include e lib para C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/[versão]/.
Se você instalar CUDA ou CUDA+cuDNN posteriormente, ou se atualizar para uma versão mais recente do software NVIDIA, faça o seguinte:
CUDA deve ser instalado após o Visual Studio. Se você atualizar o Visual Studio, lembre-se de reinstalar o CUDA.
Depois que todas as etapas anteriores forem concluídas com sucesso, você precisará clonar o Darknet e construí-lo. Nesta etapa também precisamos informar ao CMake onde o vcpkg está localizado para que ele possa encontrar o OpenCV e outras dependências:
`bash
cd c:src git clone https://github.com/hank-ai/darknet.gitcd darknetmkdir buildcd build cmake -DCMAKEBUILDTYPE=Release -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake .. msbuild. exe /property:Platform=x64;Configuration=Liberar /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
Se você receber um erro sobre alguma DLL CUDA ou cuDNN ausente (como cublas64_12.dll), copie manualmente o arquivo CUDA .dll 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
`
(Este é um exemplo! Verifique qual versão você está executando e execute o comando apropriado para o que você instalou.)
Após copiar os arquivos, execute novamente o último 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:
Observe que a saída do comando cmake é um arquivo de solução normal do Visual Studio, Darknet.sln. Se você for um desenvolvedor de software que usa frequentemente a GUI do Visual Studio em vez de msbuild.exe para criar projetos, poderá ignorar a linha de comando e carregar o projeto Darknet no Visual Studio.
Agora você deve ter o seguinte arquivo que pode ser executado: C:srcDarknetbuildsrc-cliReleasedarknet.exe. Execute o seguinte comando para testar: Versão C:srcDarknetbuildsrc-cliReleasedarknet.exe.
Para instalar corretamente o Darknet, bibliotecas, incluir arquivos e DLLs necessárias, execute o assistente de instalação NSIS criado na última etapa. Verifique o arquivo darknet-VERSION.exe no diretório de construção. Por exemplo:
`bash
darknet-2.0.31-win64.exe
`
A instalação do pacote de instalação NSIS irá:
1. Crie um diretório chamado Darknet, por exemplo C:Program FilesDarknet.
2. Instale o aplicativo CLI, darknet.exe e outros aplicativos de amostra.
3. Instale os arquivos .dll de terceiros necessários, como os do OpenCV.
4. Instale os arquivos Darknet .dll, .lib e .h necessários para usar darknet.dll de outro aplicativo.
5. Instale o arquivo .cfg do modelo.
Você terminou agora! Após a conclusão do assistente de instalação, Darknet será instalado em C:Program FilesDarknet. Execute o seguinte comando para testar: Versão C:Program FilesDarknetbindarknet.exe.
Se você não possui C:/Program Files/darknet/bin/darknet.exe, você não o instalou, apenas o construiu! Certifique-se de concluir cada painel do Assistente de Instalação NSIS conforme descrito nas etapas anteriores.
Usando Darknet
CLI
A seguir não está uma lista completa de todos os comandos suportados pelo Darknet.
Além da CLI Darknet, observe a CLI do projeto DarkHelp, que fornece uma alternativa à CLI Darknet/YOLO. DarkHelp CLI também possui vários recursos avançados nã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ê precisa de um arquivo .weights com os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar uma rede neural da Internet que foi treinada por outros e está disponível gratuitamente. Exemplos de conjuntos de dados de pré-treinamento incluem:
1. LEGO Gears (encontre objetos nas imagens)
2. Rolodex (encontre texto na imagem)
3. MSCOCO (detecção de alvo padrão de 80 categorias)
Os comandos a serem executados incluem:
Liste alguns comandos e opções que podem ser executados:
`bash
ajuda darknet
`
Verifique a versão:
`bash
versão darknet
`
Use imagens para fazer previsões:
V2:
`bash
teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg
`
V3:
`bash
darknet02displayannotatedimages cars.cfg image1.jpg
`
Ajuda Negra:
`bash
DarkHelp carros.cfg carros.cfg carros_best.weights image1.jpg
`
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 Negra:
`bash
DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg
`
Usar 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 Negra:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
Lendo da webcam:
V2:
`bash
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
`
V3:
`bash
darknet08display_webcam animais
`
Salve os resultados no 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 Negra:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
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 Negra:
`bash
DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg
`
Execute em uma GPU específica:
V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4
`
Para verificar a precisão da rede neural:
`bash
mapa do detector darknet driving.data driving.cfg driving_best.weights ... 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 sinal 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
`
Para verificar a precisão de mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
O recálculo dos pontos de ancoragem é melhor feito no DarkMark, pois ele será executado 100 vezes seguidas e selecionará o melhor ponto de ancoragem de todos os pontos de ancoragem calculados. Mas se você quiser rodar uma versão mais antiga no Darknet, faça o seguinte:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
Treine uma nova rede:
`bash
detector darknet -map -dont_show trainanimais.dataanimais.cfg (veja também a seção de treinamento abaixo)
`
trem
Links rápidos para seções relevantes do FAQ Darknet/YOLO:
1. Como devo configurar meus arquivos e diretórios?
2. Qual perfil devo usar?
3. Qual comando você deve usar ao treinar sua própria rede?
Usar o DarkMark para criar todos os arquivos Darknet necessários é a maneira mais fácil de anotar e treinar. Esta é definitivamente a forma recomendada para treinar novas redes neurais.
Se quiser configurar manualmente os vários arquivos para treinar uma rede personalizada, faça o seguinte:
1. Crie uma nova pasta para armazenar esses arquivos. Para este exemplo, será criada uma rede neural para detectar animais, portanto será criado o seguinte diretório: ~/nn/animals/.
2. Copie um dos arquivos de configuração Darknet que deseja usar como modelo. Por exemplo, consulte cfg/yolov4-tiny.cfg. Coloque-o na pasta que você criou. Para este exemplo, agora temos ~/nn/animals/animals.cfg.
3. Crie um arquivo de texto Animals.names na mesma pasta onde você colocou o arquivo de configuração. Para este exemplo, agora temos ~/nn/animals/animals.names.
4. Use seu editor de texto para editar o arquivo pets.names. Liste as categorias que deseja usar. Você precisa de exatamente uma entrada por linha, sem linhas em branco e sem comentários. Neste exemplo, o arquivo .names conterá exatamente 4 linhas:
`
cachorro
gato
pássaro
cavalo
`
5. Crie um arquivo de texto Animals.data na mesma pasta. Para este exemplo, o arquivo .data conterá:
`
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
`
6. Crie uma pasta para armazenar suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset. Cada imagem requer um arquivo .txt correspondente que descreve as anotações dessa imagem. O formato dos arquivos de comentários .txt é muito específico. Você não pode criar esses arquivos manualmente porque 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.
7. Crie arquivos de texto "treinados" e "válidos" nomeados no arquivo .data. Esses dois arquivos de texto precisam listar todas as imagens que Darknet deve usar para treinamento e validação de mAP%, respectivamente. Há exatamente uma imagem por linha. Caminhos e nomes de arquivos podem ser relativos ou absolutos.
8. Use um editor de texto para modificar seu arquivo .cfg.
- Certifique-se de lote=64.
- Preste atenção às subdivisões. Dependendo do tamanho da rede e da quantidade de memória disponível na GPU, pode ser necessário aumentar as subdivisões. O valor ideal é 1, então comece com isso. Se 1 não funcionar para você, consulte as perguntas frequentes do Darknet/YOLO.
- Nota maxbatches=.... Ao começar, um bom valor é 2.000 para o número de categorias. Neste exemplo temos 4 animais, então 4 2.000 = 8.000. Isso significa que usaremos maxbatches=8000.
- Observe steps=.... Isso deve ser definido como 80% e 90% de maxbatches. Para este exemplo, usaremos steps=6400,7200 já que maxbatches está definido como 8000.
- Observe que width=... e height=.... são dimensões de rede. O FAQ Darknet/YOLO explica como calcular o tamanho ideal a ser usado.
- Em cada seção [yolo] anterior à seção [convolucional], procure todas as instâncias das linhas filter=.... O valor a ser usado é (número de categorias + 5) 3. Isso significa que, para este exemplo, (4 + 5) 3 = 27. Portanto, usamos filtros=27 nas linhas apropriadas.
9. Comece a treinar! Execute o seguinte comando:
`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. Você pode observar o progresso do treinamento 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
Para gerenciar seu projeto Darknet/YOLO, anotar imagens, validar suas anotações e gerar os arquivos necessários para treinamento com Darknet, consulte DarkMark.
Para uma CLI alternativa Darknet poderosa para junção de imagens, rastreamento de objetos em vídeos ou uma API C++ poderosa que pode ser facilmente usada em aplicativos comerciais, consulte DarkHelp.
Confira as perguntas frequentes do Darknet/YOLO para ver se ele pode ajudar a responder sua pergunta.
Confira os diversos tutoriais e vídeos de exemplo no canal de Stéphane no YouTube
Se você tiver dúvidas de suporte ou quiser conversar com outros usuários Darknet/YOLO, entre no servidor Darknet/YOLO Discord.
roteiro
Última atualização: 30/10/2024:
Concluído
1. Substitua qsort() por std::sort() durante o treinamento (algum outro código obscuro ainda existe)
2. Exclua check_mistakes, getchar() e system()
3. Converta Darknet para usar um compilador C++ (g++ no Linux, VisualStudio no Windows)
4. Corrija a compilação do Windows
5. Corrigir 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. Exclua a solução antiga e o Makefile
15. Torne o OpenCV não opcional
16. Remova a dependência da antiga biblioteca pthread
17. Excluir STB
18. Reescreva CMakeLists.txt para usar a nova instrumentação CUDA
19. Remova o antigo código “alfabeto” e exclua mais de 700 imagens em dados/rótulos
20. Construindo além do código-fonte
21. Tenha melhor saída de número de versão
22. Otimização de desempenho relacionada ao treinamento (tarefas em andamento)
23. Otimização de desempenho relacionada à inferência (tarefas em andamento)
24. Use referências por valor sempre que possível
25. Limpe os arquivos .hpp
26. Reescreva darknet.h
27. Não converta cv::Mat em void*, em vez disso use-o como um objeto C++ correto
28. Corrija ou mantenha as estruturas internas da imagem usadas de forma consistente
29. Corrigir compilação para dispositivos Jetson baseados em ARM
- É improvável que os dispositivos Jetson originais sejam consertados, pois não são mais suportados pela NVIDIA (sem compilador C++ 17)
- Novo dispositivo Jetson Orin em execução
30. Corrigir API Python em V3
31. É necessário melhor suporte para Python (algum desenvolvedor de Python quer ajuda?)
metas de curto prazo
1. Substitua printf() por std::cout (trabalho em andamento)
2. Investigue o suporte para câmeras Zed antigas
3. Análise de linha de comando melhor e mais consistente (trabalho em andamento)
metas de médio prazo
1. Remova todos os códigos char* e substitua-os por std::string
2. Não oculte avisos e limpe os avisos do compilador (em andamento)
3. Melhor uso de cv::Mat em vez de estruturas de imagem personalizadas em C (trabalho em andamento)
4. Substitua a funcionalidade de lista antiga por std::vector ou std::list
5. Corrigido suporte para imagens em tons de cinza de 1 canal
6. Adicione suporte para imagens de canal N onde N > 3 (por exemplo, imagens com profundidade extra ou canais quentes)
7. Limpeza contínua de código (em andamento)
objetivos de longo prazo
1. Corrija problemas de CUDA/CUDNN em todas as GPUs
2. Reescreva o código CUDA+cuDNN
3. Investigue a adição de suporte para GPUs não NVIDIA
4. Caixa delimitadora girada ou algum tipo de suporte de "ângulo"
5. Pontos-chave/esqueleto
6. Mapa de calor (em andamento)
7. Divisão
