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.
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.
Leia como Hank.ai está ajudando a comunidade Darknet/YOLO: https://hank.ai/
Anunciando Darknet V3 "Jazz": https://darknetcv.ai/
Por favor, leia as Perguntas frequentes sobre Darknet/YOLO: https://darknetcv.ai/faq/
Junte-se ao servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW
Artigos
1. Artigo YOLOv7: https://arxiv.org/abs/2207.02670
2. Papel em escala-YOLOv4: https://arxiv.org/abs/2103.05293
3. Artigo YOLOv4: https://arxiv.org/abs/2004.10934
4. Artigo YOLOv3: https://pjreddie.com/media/files/papers/YOLOv3.pdf
Informações gerais
A estrutura Darknet/YOLO continua a ser mais rápida e precisa do que outras estruturas e versões do YOLO.
Esta estrutura é totalmente gratuita e de código aberto. Você pode incorporar Darknet/YOLO em projetos e produtos existentes, inclusive comerciais, sem licença ou pagamento de taxa.
Darknet V3 ("Jazz"), lançado em outubro de 2024, pode executar com precisão os vídeos do conjunto de dados LEGO em até 1000 FPS ao usar uma GPU NVIDIA RTX 3090. Isso significa que cada quadro de vídeo é lido, redimensionado e processado pelo Darknet/YOLO em 1 milissegundo ou menos.
A versão CPU do Darknet/YOLO pode ser executada em dispositivos simples, como Raspberry Pi, servidores em nuvem e colab, 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 em Linux, Windows e Mac. Veja as instruções de construção abaixo.
Versão Darknet
1. Versão 0.x: A ferramenta Darknet original escrita por Joseph Redmon em 2013-2017.
2. Versão 1.x: O próximo repositório Darknet popular mantido por Alexey Bochkovskiy entre 2017-2021.
3. Versão 2.x "OAK": O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette a partir de 2023. Foi o primeiro com um comando de versão. Esta versão trouxe as seguintes alterações:
- Reescrevi as etapas de construção para uma abordagem CMake unificada em Windows e Linux.
- Converteu a base de código para usar o compilador C++.
- Geração aprimorada de chart.png durante o treinamento.
- Correções de bugs e otimizações de desempenho relacionadas ao tempo de treinamento.
4. Versão 2.1: A última ramificação da base de código 2.x, encontrada na ramificação v2.
5. Versão 3.x "JAZZ": A próxima fase de desenvolvimento, lançada em outubro de 2024.
- Removidos muitos comandos antigos e sem manutenção.
- Implementei otimizações de desempenho para treinamento e inferência.
- Modificou a API C legada. Os aplicativos que usam a API Darknet original precisarão de pequenas modificações. https://darknetcv.ai/api/api.html
- Introduziu uma nova API Darknet V3 C e C++: https://darknetcv.ai/api/api.html
- Adicionados novos aplicativos e código de exemplo em src-examples: https://darknetcv.ai/api/files.html
Você sempre pode verificar a ramificação v2 anterior se precisar executar um dos comandos dessa versão. Informe-nos se você encontrar algum comando ausente para que possamos investigar a adição deles novamente.
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 possui 80 classes, que podem ser vistas 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. Consulte as perguntas frequentes do Darknet/YOLO para obter detalhes.
Os pesos pré-treinados do MSCOCO podem ser baixados de vários locais diferentes, 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 estão 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
`
Observe que você é incentivado a treinar suas próprias redes. MSCOCO é usado principalmente para confirmar se tudo está funcionando corretamente.
Prédio
Os vários métodos de construção disponíveis no passado (pré-2023) foram fundidos numa única solução unificada. Darknet requer C++17 ou mais recente, OpenCV, e usa 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. Vários notebooks Jupyter estão disponíveis mostrando como realizar diversas tarefas, como treinar uma nova rede.
Consulte 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. 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).
2. Instale os pacotes necessários:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
3. Clone o repositório Darknet:
`bash
mkdir ~/srccd ~/src
clone do git https://github.com/hank-ai/darknet
`
4. Crie o diretório de construção:
`bash
cd rede escura
compilação mkdir
compilação de CD
`
5. Gere arquivos de projeto CMake:
`bash
cmake -DCMAKEBUILDTYPE=Liberar ..
`
Importante: 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.
6. Construir Darknet:
`bash
faça o pacote -j4
`
7. Instale o pacote Darknet:
`bash
sudo dpkg -i darknet-VERSION.deb
`
Instalando CUDA e cuDNN (opcional)
Darknet pode ser executado sem CUDA, mas se você quiser treinar uma rede personalizada, é necessário CUDA ou CUDA+cuDNN.
1. Instale o CUDA:
- Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.
- Certifique-se de poder executar nvcc e nvidia-smi. Pode ser necessário modificar sua variável PATH.
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-installation-overview para baixe e instale o cuDNN.
Atualizando CUDA ou cuDNN
Se você instalar CUDA ou CUDA+cuDNN posteriormente ou atualizar para uma versão mais recente do software NVIDIA:
1. Reconstrua Darknet:
- Exclua o arquivo CMakeCache.txt do diretório de compilação Darknet.
- Execute o cmake e faça os comandos novamente.
Usuários avançados
Para construir um arquivo de instalação RPM em vez de um arquivo DEB, edite as linhas relevantes em CM_package.cmake antes de executar make -j4 package.
`cmake
#SET(CPACK_GENERATOR"DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Para instalar o pacote de instalação após a conclusão da construção, use o gerenciador de pacotes usual para sua distribuição. Por exemplo, em sistemas baseados em Debian, como Ubuntu:
`bash
sudo dpkg -i darknet-2.0.1-Linux.deb
`
Testando a instalação
Após a instalação, você deverá ter os seguintes arquivos:
/usr/bin/darknet: O executável Darknet. Execute a versão darknet da CLI para confirmar se ela está instalada corretamente.
/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/...: Onde todos os modelos .cfg são armazenados.
Execute o seguinte comando para testar a instalação:
`bash
versão darknet
`
Método CMake do Windows
Tutorial de construção Darknet para Windows
1. Instale o software necessário:
- Abra uma janela normal do prompt de comando cmd.exe e execute os seguintes comandos:
`bash
winget instalar Git.Git
winget instalar Kitware.CMake
winget instalar nsis.nsis
winget instalar Microsoft.VisualStudio.2022.Community
`
2. Modifique a instalação do Visual Studio:
- Clique no menu “Iniciar do Windows” e execute o “Visual Studio Installer”.
- Clique em “Modificar”.
- Selecione "Desenvolvimento de desktop com C++".
- Clique em “Modificar” no canto inferior direito e depois clique em “Sim”.
3. Instale o Microsoft VCPKG:
- Depois que tudo for baixado e instalado, clique novamente no menu “Iniciar do Windows” e selecione “Prompt de comando do desenvolvedor para VS 2022”. Não use o PowerShell para estas etapas!
- Execute os seguintes comandos:
`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
`
Importante: seja paciente nesta última etapa, pois ela pode demorar muito para ser executada. Ele precisa baixar e construir muitas coisas.
4. Opcional: Instale CUDA e cuDNN
- 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.
5. Instale o CUDA:
- Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.
- Certifique-se de que você pode executar nvcc.exe e nvidia-smi.exe. Pode ser necessário modificar sua variável PATH.
6. Instale o cuDNN:
- 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 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.
7. Clone o repositório Darknet e construa:
`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
`
8. Copie DLLs CUDA (opcional):
- Se você receber um erro sobre algumas DLLs CUDA ou cuDNN ausentes, como cublas64_12.dll, copie manualmente os arquivos 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
`
9. Execute msbuild.exe novamente para gerar o pacote de instalação NSIS:
`bash
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
Usuários avançados
Em vez de executar o prompt de comando do desenvolvedor, você pode usar um prompt de comando normal ou ssh no dispositivo e executar manualmente os arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat.
Você pode adicionar muitos outros módulos opcionais ao construir o OpenCV. Execute .vcpkg.exe search opencv para ver a lista completa.
A saída do comando cmake é um arquivo de solução normal do Visual Studio, Darknet.sln. Você pode ignorar a linha de comando e carregar o projeto Darknet no Visual Studio se for um desenvolvedor de software que usa regularmente a GUI do Visual Studio.
Testando a instalação
Agora você deve ter o seguinte arquivo: C:srcDarknetbuildsrc-cliReleasedarknet.exe. Execute o seguinte comando para testar a instalação:
`bash
C: versão srcDarknetbuildsrc-cliReleasedarknet.exe
`
Para instalar corretamente o Darknet, as bibliotecas, os arquivos incluídos e as DLLs necessárias, execute o assistente de instalação do NSIS que foi criado na última etapa. Veja 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.
Execute o seguinte comando para testar a instalação após executar o assistente NSIS:
`bash
C:Arquivos de programasDarknetbindarknet.exe versão
`
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 CLI alternativa para Darknet/YOLO. O DarkHelp CLI também possui vários recursos avançados que não estã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ê precisará do arquivo .weights com os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar uma rede neural que alguém já treinou e disponibilizou gratuitamente na internet. Exemplos de conjuntos de dados pré-treinados incluem:
LEGO Gears (encontrar objetos em uma imagem)
Rolodex (encontrar texto em uma imagem)
MSCOCO (detecção de objetos padrão de classe 80)
Comandos para executar
1. Obtenha ajuda:
`bash
ajuda darknet
`
2. Verifique a versão:
`bash
versão darknet
`
3. Prever 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. Salve os 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:
- V2:
`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 ...
`
Saída:
`
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
`
11. Verificando a precisão mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
12. Recálculo de âncoras:
- DarkMark: É melhor recalcular as âncoras no DarkMark, pois ele roda 100 vezes consecutivas e seleciona as melhores âncoras de todas as calculadas.
- Darknet: Se você quiser usar o método antigo no Darknet:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
13. Treine uma nova rede:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
Treinamento
Links rápidos para seções relevantes das perguntas frequentes da Darknet/YOLO
1. Como devo configurar meus arquivos e diretórios?
2. Qual arquivo de configuração devo usar?
3. Qual comando devo usar ao treinar minha própria rede?
Usando DarkMark para anotação e treinamento (recomendado)
A maneira mais simples de anotar e treinar é com DarkMark, que cria todos os arquivos Darknet necessários. Isso é altamente recomendado para treinar uma nova rede neural.
Configurando arquivos manualmente para treinar uma rede personalizada
Se você preferir a configuração manual, siga estas etapas:
1. Crie uma nova pasta:
- Crie uma nova pasta para armazenar seus arquivos de treino. Por exemplo, você poderia criar ~/nn/animals/ para treinar uma rede para detecção de animais.
2. Copie um modelo de arquivo de configuração:
- Copie um dos arquivos de configuração Darknet de cfg/ como modelo. Por exemplo, você poderia usar cfg/yolov4-tiny.cfg. Coloque isso na pasta que você criou. Agora você deve ter ~/nn/animals/animals.cfg.
3. Crie um arquivo Animals.names:
- Crie um arquivo de texto chamado pets.names na mesma pasta do arquivo de configuração.
4. Edite o arquivo pets.names:
- Liste as classes que deseja detectar, uma entrada por linha, sem linhas em branco ou comentários. Por exemplo:
`
cachorro
gato
pássaro
cavalo
`
5. Crie um arquivo Animals.data:
- Crie um arquivo de texto chamado pets.data na mesma pasta.
- Por exemplo, o arquivo pets.data pode conter:
`
aulas=4
trem=/home/nomedeusuário/nn/animals/animals_train.txt
válido=/home/nomedeusuário/nn/animals/animals_valid.txt
nomes=/home/nomedeusuário/nn/animais/animais.nomes
backup=/home/nomedeusuário/nn/animais
`
6. Crie uma pasta de conjunto de dados:
- Crie uma pasta para armazenar suas imagens e anotações. Por exemplo, você poderia criar ~/nn/animals/dataset.
7. Anote imagens:
- Cada imagem precisa de um arquivo .txt correspondente com anotações. O formato desses arquivos .txt é específico e requer as coordenadas exatas para as anotações. Use DarkMark ou software similar para fazer anotações em suas imagens.
8. Crie animaistrain.txt e animaisvalid.txt:
- Esses arquivos de texto listam as imagens utilizadas para treinamento e validação, respectivamente. Cada imagem deve estar em uma linha separada, com caminhos relativos ou absolutos.
9. Modifique o arquivo de configuração:
- Abra Animals.cfg com um editor de texto e faça as seguintes modificações:
- batch=64: certifique-se de que este valor esteja definido.
- subdivisões: O melhor valor a ser usado é 1. Pode ser necessário aumentar esse valor dependendo da memória da GPU e das dimensões da rede.
- maxbatches: Defina um valor razoável, normalmente 2.000 vezes o número de classes. Para este exemplo, use maxbatches=8000 (4 classes * 2000).
- etapas: defina-as para 80% e 90% de maxbatches. Para este exemplo, use steps=6400,7200 (já que maxbatches=8000).
- largura e altura: defina-as com as dimensões de rede desejadas. Consulte as perguntas frequentes da Darknet/YOLO para obter orientação sobre como escolher o melhor tamanho.
- classes: pesquise todas as instâncias desta linha e modifique-a para corresponder ao número de classes em seu arquivo .names (neste exemplo, classes=4).
- filtros: Pesquise todas as instâncias desta linha nas seções [convolucionais] antes de cada seção [yolo]. O valor a ser usado é (número de classes + 5) 3. Para este exemplo, use filtros=27 (4 + 5 3).
10. Comece o treinamento:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
11. Monitoramento do progresso do treinamento:
- Ser paciente! Os melhores pesos serão salvos como Animals_best.weights.
- Você pode monitorar o andamento do treinamento visualizando o arquivo chart.png.
- Consulte as perguntas frequentes do Darknet/YOLO para parâmetros adicionais que você pode querer usar durante o treinamento.
12. Adicionando verbosidade ao resultado do treinamento:
`bash
detector darknet -map -dont_show --verbose trem animais.data animais.cfg
`
Outras ferramentas e links
DarkMark: Para gerenciar projetos Darknet/YOLO, anotar imagens, verificar anotações e gerar arquivos para treinamento Darknet.
DarkHelp: Para uma CLI alternativa robusta ao Darknet, usando imagens lado a lado, rastreamento de objetos em vídeos e uma API C++ robusta que pode ser usada em aplicativos comerciais.
Perguntas frequentes sobre Darknet/YOLO: https://darknetcv.ai/faq/
Canal de Stéphane no YouTube: https://www.youtube.com/channel/UCYQ2k0L3X0c56l9gE2r1RQ
Servidor Discord Darknet/YOLO: https://discord.gg/zSq8rtW
Roteiro
Última atualização em 30/10/2024:
Concluído
Trocado qsort() por std::sort() onde usado durante o treinamento (alguns obscuros permanecem).
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.
Suporte corrigido para Python.
Biblioteca Darknet construída.
Rótulos reativados em previsões (código "alfabeto").
Código CUDA/GPU reativado.
CUDNN reativado.
Metade CUDNN reativada.
Não codifique a arquitetura CUDA.
Informações aprimoradas sobre a versão CUDA.
AVX reativado.
Removidas soluções antigas e Makefile.
Tornou o OpenCV não opcional.
Removida a dependência da antiga biblioteca pthread.
STB removido.
CMakeLists.txt reescrito para usar a nova detecção CUDA.
Removido o antigo código do "alfabeto" e excluído mais de 700 imagens em dados/rótulos.
Construído fora da fonte.
Saída de número de versão aprimorada.
Otimizações de desempenho relacionadas ao treinamento (tarefa contínua).
Otimizações de desempenho relacionadas à inferência (tarefa em andamento).
Usado passagem por referência sempre que possível.
Arquivos .hpp limpos.
Reescreveu darknet.h.
Não converta cv::Mat para void* mas use-o como um objeto C++ adequado.
Corrigido ou tornado consistente como a estrutura interna da imagem é usada.
Compilação corrigida 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).
- Novos dispositivos Jetson Orin estão funcionando.
API Python corrigida na V3.
Suporte aprimorado para Python. (Algum desenvolvedor Python quer ajudar com isso?)
Metas de curto prazo
Troque printf() por std::cout (em andamento).
Pesquise o antigo suporte para câmeras ZED.
Melhore e faça análise de linha de comando consistente (em andamento).
Metas de médio prazo
Remova todo o código char* e substitua por std::string.
Não oculte avisos e limpe os avisos do compilador (em andamento).
Melhorar 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.
Correção do suporte para imagens em escala de cinza de 1 canal.
Adicionado suporte para imagens de canal N onde N > 3 (por exemplo, imagens com profundidade adicional ou canal térmico).
Limpeza de código em andamento (em andamento).
Metas de longo prazo
Corrija problemas de CUDA/CUDNN com todas as GPUs.
Reescreva o código CUDA + cuDNN.
Considere adicionar suporte para GPUs que não sejam NVIDIA.
Caixas delimitadoras giradas ou algum tipo de suporte de "ângulo".
Pontos-chave/esqueletos.
Mapas de calor (em andamento).
Segmentação.
