Estrutura de detecção de objetos Darknet e YOLO
Downcodes小编 Lista atualizada de rastreadores públicos de BitTorrent
Listas
Essas listas são atualizadas automaticamente todos os dias. Última atualização 31/10/2024:
Você está tendo problemas de DNS? Estas listas contêm os mesmos rastreadores, mas com endereços IP em vez de domínios:
Notas
Contribuir
Contato
ngosang [@] hotmail [.es]
Ferramentas de terceiros
Ferramentas online de terceiros
exemplo:
Licença Apache-2.0
Índice
Estrutura de detecção de objetos Darknet e YOLO
Artigos
Informações gerais
Versão Darknet
Pesos pré-treinados MSCOCO
Prédio
Google Colab
Método Linux CMake
Método CMake do Windows
Usando Darknet
CLI
Treinamento
Outras ferramentas e links
Roteiro
Metas de curto prazo
Metas de médio prazo
Metas de longo prazo
Estrutura de detecção de objetos Darknet e YOLO
Darknet é uma estrutura de rede neural de código aberto, escrita principalmente em C, C++ e CUDA.
YOLO (You Only Look Once) é um sistema de detecção de objetos em tempo real de última geração que opera dentro da estrutura Darknet.
Leia sobre como Hank.ai está apoiando a comunidade Darknet/YOLO.
Explore o site Darknet/YOLO.
Consulte o FAQ Darknet/YOLO para obter respostas a perguntas comuns.
Junte-se ao servidor Darknet/YOLO Discord para discussões e assistência.
Artigos
1. Artigo YOLOv7
2. Papel em escala-YOLOv4
3. Artigo YOLOv4
4. Artigo YOLOv3
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 em seus projetos e produtos, mesmo comerciais, sem precisar de licença ou incorrer em taxas.
Darknet V3 ("Jazz"), lançado em outubro de 2024, pode executar com eficiência os vídeos do conjunto de dados LEGO em até 1000 FPS usando uma GPU NVIDIA RTX 3090. Isso significa que Darknet/YOLO pode processar cada quadro de vídeo (ler, redimensionar e processar) em 1 milissegundo ou menos.
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 é executada em vários dispositivos, incluindo Raspberry Pi, servidores em nuvem e Colab, desktops, laptops e plataformas de treinamento de última geração. A versão GPU necessita de uma GPU NVIDIA compatível com CUDA.
Darknet/YOLO é conhecido por ser compatível com Linux, Windows e Mac. Consulte as instruções de construção abaixo para obter detalhes.
Versão Darknet
A ferramenta Darknet original desenvolvida por Joseph Redmon entre 2013 e 2017 não tinha um número de versão. Consideramos esta versão 0.x.
O popular repositório Darknet subsequente, mantido por Alexey Bochkovskiy de 2017 a 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 desde 2023 foi o primeiro a incluir um comando de versão. Ele retornou a versão 2.x "OAK" de 2023 até o final de 2024.
O objetivo principal era minimizar a interrupção da funcionalidade existente enquanto nos familiarizamos com a base de código.
Principais mudanças:
Compilação unificada: etapas de compilação reescritas para estabelecer um método único e consistente usando CMake para Windows e Linux.
Migração C++: Converteu a base de código para utilizar o compilador C++.
Gráfico aprimorado: melhorou a visualização do chart.png durante o treinamento.
Correções de bugs e otimizações: Resolvemos vários bugs e implementamos otimizações de desempenho, 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 etapa de desenvolvimento começou em meados de 2024 e culminou com o lançamento da versão 3.x "JAZZ" em outubro de 2024.
Principais melhorias no Darknet V3 ("Jazz"):
Desempenho: Otimizações significativas de desempenho durante o treinamento e a inferência.
Mudanças na API: Modificada a API C herdada. Os aplicativos que utilizam a API Darknet original exigirão pequenos ajustes. Veja: https://darknetcv.ai/api/api.html
Nova API: Introduzida uma nova API Darknet V3 C e C++: https://darknetcv.ai/api/api.html
Exemplos atualizados: Adicionados novos aplicativos e código de amostra no diretório src-examples: https://darknetcv.ai/api/files.html
Você sempre pode reverter para a ramificação v2 anterior se precisar executar comandos específicos. Informe-nos se encontrar algum comando ausente para que possamos explorar a incorporação deles novamente.
Remoções de chave Darknet V3 ("Jazz"):
Comandos desatualizados: muitos comandos obsoletos e sem manutenção foram removidos.
Pesos pré-treinados MSCOCO
Por conveniência, várias versões populares do YOLO foram pré-treinadas no conjunto de dados MSCOCO. Este conjunto de dados abrange 80 classes, que podem ser encontradas no arquivo de texto cfg/coco.names.
Além do MSCOCO, vários outros conjuntos de dados mais simples e pesos pré-treinados estão disponíveis para testar Darknet/YOLO, como LEGO Gears e Rolodex. Verifique as perguntas frequentes do Darknet/YOLO para obter detalhes.
Os pesos pré-treinados do MSCOCO podem ser baixados de várias fontes, incluindo este repositório:
YOLOv2, novembro de 2016:
YOLOv2-tiny
YOLOv2-completo
YOLOv3, maio de 2018:
YOLOv3-minúsculo
YOLOv3-completo
YOLOv4, maio de 2020:
YOLOv4-tiny
YOLOv4-completo
YOLOv7, agosto de 2022:
YOLOv7-tiny
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 residem 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
`
Lembre-se de que os usuários são incentivados a treinar suas próprias redes. MSCOCO é usado principalmente para validar se tudo está funcionando corretamente.
Prédio
Os diversos 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 utiliza CMake para gerar os arquivos de projeto necessários.
Você não precisa de proficiência em 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 refletem as instruções do Linux. Vários notebooks Jupyter demonstram diversas tarefas, como treinar uma nova rede.
Explore os notebooks no subdiretório colab ou siga as instruções do Linux fornecidas abaixo.
Método Linux CMake
Tutorial de construção Darknet para Linux
Opcional: se você possui uma GPU NVIDIA moderna, instale CUDA ou CUDA+cuDNN neste momento. Se instalado, o Darknet aproveitará sua GPU para acelerar o processamento de imagens (e vídeos).
Você deve excluir o arquivo CMakeCache.txt do diretório de construção Darknet para forçar o CMake a redescobrir todos os arquivos necessários.
Lembre-se de reconstruir o Darknet.
Darknet pode funcionar sem eles, mas CUDA ou CUDA+cuDNN é necessário se você pretende treinar uma rede customizada.
1. Instale o CUDA: Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.
2. Instale o cuDNN: Visite 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 para baixar e instalar o cuDNN.
Depois de instalar o CUDA, certifique-se de executar nvcc e nvidia-smi. Talvez seja necessário modificar sua variável PATH.
Se você instalar CUDA ou CUDA+cuDNN posteriormente ou se atualizar para uma versão mais recente do software NVIDIA:
Atualizar CMake: Se a sua versão do CMake estiver desatualizada, atualize-a usando os seguintes comandos:
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Reinicie o Shell: Se estiver usando o bash como shell de comando, reinicie o shell. Se estiver usando fish, o caminho deverá ser atualizado automaticamente.
Construindo Darknet:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
mkdir ~/srccd ~/src
clone do git https://github.com/hank-ai/darknetcd darknet
compilação mkdir buildcd
cmake -DCMAKEBUILDTYPE=Liberar ..
faça -j4
pacote
sudo dpkg -i darknet-VERSION.deb
`
Usuários avançados:
Instalação RPM: Para criar um arquivo de instalação RPM em vez de um arquivo DEB, modifique as linhas relevantes em CM_package.cmake. Antes de executar o pacote make -j4, edite estas linhas:
`cmake
SET (CPACKGENERATOR "DEB")#SET (CPACKGENERATOR "RPM")
`
Para distribuições como CentOS e OpenSUSE, ajuste as linhas para:
`cmake
DEFINIR (CPACK_GENERATOR "DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Pacote de instalação: Instale o pacote após a conclusão da construção usando o gerenciador de pacotes da sua distribuição. Para sistemas baseados em Debian (por exemplo, Ubuntu):
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
A instalação do pacote .deb copiará os seguintes arquivos:
/usr/bin/darknet: O executável padrão do Darknet. Execute a versão darknet da CLI para confirmar sua instalação correta.
/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 para vinculação no desenvolvimento em C, C++ e Python.
/opt/darknet/cfg/...: Armazena todos os modelos .cfg.
Parabéns! Darknet foi construído e instalado em /usr/bin/. Execute a versão darknet para verificar.
Se você não tiver /usr/bin/darknet, você apenas construiu o Darknet, não o instalou. Certifique-se de instalar o arquivo .deb ou .rpm conforme descrito acima.
Método CMake do Windows
Estas instruções pressupõem uma nova instalação do Windows 11 22H2.
1. Pré-requisitos de instalação: Abra um prompt de comando cmd.exe padrão e execute estes comandos:
`bash
winget instalar Git.Git
winget instalar Kitware.CMake
winget instalar nsis.nsis
instalar winget Microsoft.VisualStudio.2022.Community
`
2. Modifique o Visual Studio: Configure o Visual Studio para oferecer suporte a aplicativos C++:
Clique no menu “Iniciar do Windows” e execute o “Visual Studio Installer”.
Selecione "Modificar".
Escolha “Desenvolvimento de desktop com C++”.
Clique em “Modificar” no canto inferior direito e clique em “Sim”.
3. Prompt de comando do desenvolvedor: após a conclusão da instalação, clique no menu “Iniciar do Windows” e selecione “Prompt de comando do desenvolvedor para VS 2022”. Não use o PowerShell para essas etapas, pois isso pode causar problemas!
Usuários avançados:
Em vez de usar o prompt de comando do desenvolvedor, você pode optar por um prompt de comando normal ou conectar-se via SSH e executar manualmente "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".
4. Instale o Microsoft VCPKG: Execute os seguintes comandos no prompt de comando do desenvolvedor (não no PowerShell) para instalar o Microsoft VCPKG, que será usado 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 durante a última etapa, pois pode levar um tempo considerável para ser concluída. Envolve baixar e construir vários componentes.
Usuários avançados:
Observe que existem muitos módulos opcionais que você pode incluir 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 do 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 funcionar sem ele, mas se você quiser treinar uma rede personalizada, será necessário 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. Talvez seja necessário modificar sua variável PATH.
Depois de baixar o cuDNN, descompacte e copie os diretórios bin, include e lib em C:/Arquivos de Programas/NVIDIA GPU Computing Toolkit/CUDA/[versão]/. Pode ser necessário substituir alguns arquivos.
Se você instalar CUDA ou CUDA+cuDNN posteriormente ou atualizar para uma versão mais recente do software NVIDIA:
CUDA deve ser instalado após o Visual Studio. Se você atualizar o Visual Studio, lembre-se de reinstalar o CUDA.
5. Clone e construa Darknet: Assim que as etapas anteriores forem concluídas com sucesso, clone Darknet e construa-o. Durante esta etapa, especifique o local do VCPKG para o CMake localizar o OpenCV e outras dependências:
`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
`
Se você encontrar um erro 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
`
(Este é um exemplo! Verifique sua versão em execução e use o comando apropriado para sua instalação.)
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 padrão do Visual Studio (Darknet.sln). Se você for um desenvolvedor de software que prefere usar a GUI do Visual Studio em vez de msbuild.exe para criar projetos, poderá ignorar as etapas da linha de comando e carregar o projeto Darknet no Visual Studio.
Agora você deve ter o executável C:srcDarknetbuildsrc-cliReleasedarknet.exe. Execute-o para testar: versão C: srcDarknetbuildsrc-cliReleasedarknet.exe.
Para instalar corretamente o Darknet, suas bibliotecas, incluir arquivos e DLLs necessárias, execute o assistente de instalação NSIS gerado na última etapa. Encontre 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á:
Crie um diretório chamado Darknet, como C:Program FilesDarknet.
Instale o aplicativo CLI (darknet.exe) e outros aplicativos de amostra.
Instale os arquivos .dll de terceiros necessários, como os do OpenCV.
Instale os arquivos Darknet .dll, .lib e .h necessários para usar darknet.dll de outro aplicativo.
Instale os arquivos .cfg do modelo.
Agora você terminou! Após a conclusão do assistente de instalação, Darknet será instalado em C:Program FilesDarknet. Teste-o executando: C:Program FilesDarknetbindarknet.exe versão.
Se C:/Program Files/darknet/bin/darknet.exe estiver faltando, o Darknet será apenas compilado, não instalado. Certifique-se de concluir cada painel do assistente de instalação do NSIS da etapa anterior.
Usando Darknet
CLI
A seguir não é uma lista abrangente de todos os comandos suportados pelo Darknet.
Além da CLI Darknet, lembre-se da CLI do projeto DarkHelp, que oferece uma CLI alternativa para Darknet/YOLO. A CLI DarkHelp inclui vários recursos avançados não acessíveis diretamente no Darknet. Você pode utilizar o Darknet CLI e o DarkHelp CLI simultaneamente; eles não são mutuamente exclusivos.
Para a maioria dos comandos abaixo, você precisará do arquivo .weights junto com seus arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) Ou baixar uma rede neural pré-treinada que alguém disponibilizou gratuitamente online. Alguns conjuntos de dados pré-treinados incluem:
LEGO Gears (detecção de objetos em uma imagem)
Rolodex (detecção de texto em uma imagem)
MSCOCO (detecção de objetos padrão de classe 80)
Comandos para executar:
Lista de comandos e opções possíveis:
`bash
ajuda darknet
`
Confira a versão:
`bash
versão darknet
`
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
`
Ajuda escura:
`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 escura:
`bash
DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg
`
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
`
Ajuda escura:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
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
`
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 multithread.cfg animais.nomes animais_best.teste de pesos.mp4
`
Ajuda escura:
`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 escura:
`bash
DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg
`
Executando em uma GPU específica:
V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4
`
Verificando 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 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
`
Para verificar a precisão mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
Recálculo de âncoras: O recálculo de âncoras é melhor executado no DarkMark, pois ele será executado 100 vezes consecutivas e selecionará as melhores âncoras de todas as opções calculadas. No entanto, se você quiser usar o método Darknet mais antigo:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
Treinando uma nova rede:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
(Consulte a seção de treinamento abaixo para obter detalhes adicionais.)
Treinamento
Links rápidos para seções relevantes do FAQ Darknet/YOLO:
Configuração de arquivos e diretórios: como devo configurar meus arquivos e diretórios?
Arquivos de configuração: Qual arquivo de configuração devo usar?
Comando de treinamento: Qual comando devo usar ao treinar minha própria rede?
A maneira mais simples de anotar e treinar é com DarkMark. Simplifica o processo de criação de todos os arquivos Darknet necessários. O uso do DarkMark é fortemente recomendado para treinar novas redes neurais.
Se você preferir a configuração manual dos arquivos para treinamento de rede personalizado:
1. Crie uma pasta: Estabeleça uma nova pasta para armazenar os arquivos. Neste exemplo, criaremos uma rede neural para detectar animais; portanto, o seguinte diretório é criado: ~/nn/animals/.
2. Copiar arquivo de configuração: Copie um arquivo de configuração Darknet que deseja usar como modelo. Por exemplo, consulte cfg/yolov4-tiny.cfg. Coloque-o na pasta criada. Neste exemplo, agora temos ~/nn/animals/animals.cfg.
3. Crie Animals.names: Crie um arquivo de texto chamado Animals.names na mesma pasta do arquivo de configuração. Este exemplo agora tem ~/nn/animals/animals.names.
4. Edite Animals.names: Edite o arquivo Animals.names usando seu editor de texto. Liste as classes que você pretende usar. Cada aula deverá ocupar uma linha separada, sem linhas em branco ou comentários. Neste exemplo, o arquivo .names conterá quatro linhas:
`
cachorro
gato
pássaro
cavalo
`
5. Crie Animals.data: 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. Pasta Dataset: Crie uma pasta para armazenar suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset. Cada imagem requer um arquivo .txt correspondente descrevendo suas anotações. O formato dos arquivos de anotação .txt é muito específico. Você não pode criar esses arquivos manualmente porque cada anotação requer coordenadas precisas. Utilize DarkMark ou software similar para fazer anotações em suas imagens. O formato de anotação YOLO é descrito nas Perguntas frequentes do Darknet/YOLO.
7. Arquivos "train" e "valid": Crie os arquivos de texto "train" e "valid" mencionados no arquivo .data. Esses dois arquivos precisam listar individualmente todas as imagens que a Darknet usará para treinamento e validação no cálculo do mAP%. Inclua uma imagem por linha. O caminho e os nomes dos arquivos podem ser relativos ou absolutos.
8. Modifique o arquivo .cfg: Use um editor de texto para modificar seu arquivo .cfg.
Certifique-se de que lote = 64.
Observe as subdivisões. Com base nas dimensões da sua rede e na capacidade de memória da GPU, pode ser necessário aumentar as subdivisões. O valor ideal é 1, então comece com ele. Consulte o FAQ Darknet/YOLO se 1 não funcionar para você.
Preste atenção em maxbatches=..... Um bom valor inicial é 2.000 vezes o número de classes. Neste exemplo, temos 4 animais, então 4 * 2.000 = 8.000, ou seja, maxbatches = 8.000.
Nota steps=..... Defina isso para 80% e 90% de maxbatches. Neste exemplo, com maxbatches definido como 8.000, usaríamos steps=6400,7200.
Observe width=... e height=..... Estas são as dimensões da rede. O FAQ Darknet/YOLO explica como determinar o melhor tamanho.
Procure todas as ocorrências da linha classes=... e modifique-a com o número de classes em seu arquivo .names. Neste exemplo, usaríamos classes=4.
Pesquise todas as ocorrências da linha filter=... na seção [convolutional] anterior a cada seção [yolo]. O valor deve ser (numberofclasses + 5) 3. Neste exemplo, (4 + 5) 3 = 27. Portanto, use filtros=27 nas linhas apropriadas.
9. Comece o treinamento: Execute os seguintes comandos:
`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 progresso do treinamento pode ser monitorado visualizando o arquivo chart.png. Consulte o FAQ Darknet/YOLO para parâmetros adicionais que podem ser úteis ao treinar uma nova rede.
Para ver mais detalhes do 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 seus projetos Darknet/YOLO, anotar imagens, verificar anotações e gerar os arquivos necessários para treinamento com Darknet, consulte DarkMark.
Para uma CLI alternativa robusta ao Darknet, para utilizar ladrilhos de imagens, rastreamento de objetos em vídeos ou uma API C++ robusta para aplicativos comerciais, explore DarkHelp.
Verifique se o FAQ Darknet/YOLO pode responder às suas perguntas.
Veja vários tutoriais e vídeos de exemplo no canal de Stéphane no YouTube.
Se você tiver uma consulta de suporte ou quiser interagir com outros usuários Darknet/YOLO, junte-se ao servidor Darknet/YOLO Discord.
Roteiro
Última atualização em 30/10/2024:
Concluído:
1. Substituído qsort() por std::sort() durante o treinamento (algumas instâncias obscuras permanecem).
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. Construiu a biblioteca Darknet.
7. Rótulos reativados nas previsões (código "alfabeto").
8. Código CUDA/GPU reativado.
9. CUDNN reativado.
10. Metade CUDNN reativada.
11. Evitou codificar a arquitetura CUDA.
12. Informações aprimoradas sobre a versão CUDA.
13. AVX reativado.
14. Removidas soluções antigas e Makefile.
15. Tornou o OpenCV obrigatório.
16. Removida a dependência da antiga biblioteca pthread.
17. STB removido.
18. CMakeLists.txt reescrito para incorporar a nova detecção CUDA.
19. Removido o antigo código do "alfabeto" e excluído as mais de 700 imagens em dados/rótulos.
20. Construído fora da fonte.
21. Saída de número de versão aprimorada.
22. Implementei otimizações de desempenho relacionadas ao treinamento (tarefa contínua).
23. Implementadas otimizações de desempenho relacionadas à inferência (tarefa em andamento).
24. Usado passagem por referência sempre que possível.
25. Arquivos .hpp limpos.
26. Darknet.h reescrito.
27. Evitou lançar cv::Mat para void* e usou-o como um objeto C++ adequado.
28. Corrigida ou garantida consistência na forma como a estrutura interna da imagem é utilizada.
29. Corrigida compilação para dispositivos Jetson baseados em ARM.
30. É improvável que os dispositivos Jetson originais sejam consertados porque a NVIDIA não os suporta mais (sem compilador C++ 17).
31. Os novos dispositivos Jetson Orin estão funcionais.
32. Corrigida a API Python na V3.
Metas de curto prazo:
1. Substitua printf() por std::cout (em andamento).
2. Revisite o suporte antigo da câmera Zed.
3. Melhorar e aprimorar a consistência da análise da linha de comando (em andamento).
Metas de médio prazo:
1. Remova todo o código char* e substitua-o por std::string.
2. Elimine avisos ocultos e limpe os avisos do compilador (em andamento).
3. Melhor utilização 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 canal térmico).
7. Limpeza contínua de código (em andamento).
Metas de longo prazo:
1. Resolva problemas de CUDA/CUDNN em todas as GPUs.
2. Reescreva o código CUDA+cuDNN.
3. Investigue a adição de suporte para GPUs que não sejam NVIDIA.
4. Introduza caixas delimitadoras giradas ou alguma forma de suporte de "ângulo".
5. Incorpore pontos-chave/esqueletos.
6. Integrar mapas de calor (em andamento).
7. Implementar segmentação.
