Estrutura de detecção de objetos Darknet e YOLO
Darknet é uma estrutura de rede neural de código aberto criada usando C, C++ e CUDA. Ele serve de base para o YOLO (You Only Look Once), um sistema de detecção de objetos em tempo real de última geração, conhecido por sua velocidade e precisão.
Leia sobre como Hank.ai está fortalecendo a comunidade Darknet/YOLO: [link para o blog Hank.ai]
Explore o site oficial da Darknet/YOLO: [link para o site da Darknet]
Mergulhe nas perguntas frequentes abrangentes sobre Darknet/YOLO: [link para FAQ]
Envolva-se com a vibrante comunidade Darknet/YOLO no Discord: [link para o servidor Discord]
Artigos
1. YOLOv7: [link para o artigo]
2. Scaled-YOLOv4: [link para o artigo]
3. YOLOv4: [link para o artigo]
4. YOLOv3: [link para o artigo]
Informações gerais
A estrutura Darknet/YOLO continua a dominar outras estruturas e versões YOLO em termos de velocidade e precisão. Sua natureza de código aberto e total isenção de taxas de licenciamento permitem uma integração perfeita em projetos e produtos comerciais existentes.
Darknet V3 ("Jazz"), lançado em outubro de 2024, atinge um desempenho notável, processando os vídeos do conjunto de dados LEGO a surpreendentes 1000 FPS usando uma GPU NVIDIA RTX 3090. Isso se traduz em um tempo de processamento inferior a 1 milissegundo por quadro de vídeo.
Junte-se ao servidor Darknet/YOLO Discord ativo em [link para o servidor Discord] para suporte, discussões e aprendizagem colaborativa.
Darknet/YOLO atende a uma ampla variedade de dispositivos, desde Raspberry Pi até equipamentos de treinamento de última geração, suportando versões de CPU e GPU. A versão GPU requer uma GPU compatível com CUDA da NVIDIA.
Darknet/YOLO possui compatibilidade com sistemas operacionais Linux, Windows e Mac. Encontre instruções detalhadas de construção abaixo.
Versão Darknet
A ferramenta Darknet original, desenvolvida por Joseph Redmon entre 2013 e 2017, não tinha número de versão. Designamos esta versão como 0.x.
Alexey Bochkovskiy continuou mantendo o popular repositório Darknet de 2017 a 2021, novamente sem um número de versão. Nós nos referimos a isso como versão 1.x.
O repositório Darknet, patrocinado por Hank.ai e mantido por Stéphane Charette desde 2023, introduziu o comando “versão”. Entre 2023 e o final de 2024, retornou a versão 2.x "OAK".
Os objetivos de desenvolvimento eram minimizar a interrupção das funcionalidades existentes e, ao mesmo tempo, nos familiarizarmos com a base de código. As principais melhorias incluem:
Processo de compilação unificado: etapas de compilação reescritas para um processo de compilação consistente baseado em CMake no Windows e no Linux.
Base de código C++: conversão da base de código para aproveitar o compilador C++.
Gráfico de treinamento aprimorado: visualização melhorada do chart.png durante o treinamento.
Correções de bugs e otimizações: Melhorias relacionadas ao desempenho, com foco na redução do tempo de treinamento.
A última ramificação desta base de código é a versão 2.1, residindo 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.
Você sempre pode acessar o branch "v2" anterior para executar comandos dessas versões. Informe-nos se encontrar algum comando ausente e investigaremos sua reintegração.
Mudanças significativas no Darknet V3 incluem:
Remoção de comandos: Remoção de comandos desatualizados e usados com pouca frequência.
Otimizações de desempenho: melhorias no desempenho de treinamento e inferência.
Modificação da API legada: Modificação da API C legada; aplicativos que usam a API Darknet original podem exigir pequenos ajustes.
Nova API C/C++: Introdução de uma nova API Darknet V3 C e C++.
Código de amostra atualizado: Inclusão de novos aplicativos e código de amostra no diretório "src-examples".
Para obter informações detalhadas sobre a nova API: [link para a documentação da API Darknet V3]
Explore o código de amostra atualizado: [link para arquivos da API Darknet V3]
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 abrange 80 classes, facilmente identificáveis no arquivo de texto "cfg/coco.names".
Além do MSCOCO, Darknet/YOLO fornece pesos pré-treinados para conjuntos de dados mais simples, como LEGO Gears e Rolodex, permitindo experimentar vários cenários. Consulte as perguntas frequentes do Darknet/YOLO para obter detalhes abrangentes.
Os pesos pré-treinados do MSCOCO podem ser acessados de diversas fontes, incluindo este repositório:
YOLOv2 (novembro de 2016):
YOLOv2-tiny: [link para pesos]
YOLOv2-full: [link para pesos]
YOLOv3 (maio de 2018):
YOLOv3-tiny: [link para pesos]
YOLOv3-full: [link para pesos]
YOLOv4 (maio de 2020):
YOLOv4-tiny: [link para pesos]
YOLOv4-full: [link para pesos]
YOLOv7 (agosto de 2022):
YOLOv7-tiny: [link para pesos]
YOLOv7-full: [link para pesos]
Esses pesos pré-treinados destinam-se principalmente a fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO estão localizados no diretório “cfg”. Comandos de exemplo:
`
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 é recomendável treinar suas próprias redes. O MSCOCO serve principalmente como referência para confirmar o funcionamento correto da sua configuração.
Prédio
Os vários métodos de construção usados antes de 2023 foram consolidados em uma única solução unificada. Darknet depende de C++17 ou posterior, OpenCV, e utiliza CMake para gerar os arquivos de projeto necessários.
Construir, instalar e executar Darknet/YOLO não requer conhecimento em C++, semelhante a dirigir um carro sem ser mecânico.
Google Colab
As instruções do Google Colab são idênticas às 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 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 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.
1. Pré-requisitos de instalação:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clone o repositório Darknet:
`bash
mkdir ~/srccd ~/src
clone do git https://github.com/hank-ai/darknetcd darknet
`
3. Crie um diretório de construção:
`bash
compilação mkdir buildcd
`
4. Configure o CMake:
`bash
cmake -DCMAKEBUILDTYPE=Liberar ..
`
5. Construir Darknet:
`bash
faça -j4
`
6. Pacote Darknet:
`bash
pacote
`
7. Instale o pacote:
`bash
sudo dpkg -i darknet-VERSION.deb
`
Se você estiver usando uma versão mais antiga do CMake, precisará atualizar o CMake antes de executar o comando cmake acima. A atualização do CMake no Ubuntu pode ser feita com os seguintes comandos:
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Se estiver usando o bash como seu shell de comando, você desejará reiniciá-lo neste momento. Se estiver usando peixe, ele deve seguir imediatamente o novo caminho.
Usuários avançados:
Se você preferir um pacote de instalação RPM em vez de um arquivo DEB, modifique as linhas relevantes em "CM_package.cmake". Antes de executar o "make -j4 package", ajuste estas linhas:
`cmake
SET (CPACKGENERATOR "DEB")#SET (CPACKGENERATOR "RPM")
`
Para distribuições como Centos e OpenSUSE, modifique essas linhas da seguinte forma:
`cmake
DEFINIR (CPACK_GENERATOR "DEB")
DEFINIR (CPACK_GENERATOR "RPM")
`
Instale o pacote compilado usando o gerenciador de pacotes da sua distribuição. Para sistemas baseados em Debian como 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 principal executável do Darknet. Execute "darknet version" na CLI para confirmar a instalação bem-sucedida.
/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.
Parabéns! Darknet foi construído e instalado em /usr/bin/. Execute "darknet version" para verificar a instalação.
Se você não possui /usr/bin/darknet, isso significa que você apenas o construiu, 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. Instale os pré-requisitos usando Winget:
`bash
winget instalar Git.Git
winget instalar Kitware.CMake
winget instalar nsis.nsis
instalar winget Microsoft.VisualStudio.2022.Community
`
2. Modifique a instalação do Visual Studio:
- 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 em “Sim”.
3. Instale o Microsoft VCPKG:
- Assim que a instalação terminar, 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 causará problemas!
- Usuários avançados: em vez de usar o prompt de comando do desenvolvedor, você pode executar um prompt de comando normal ou ssh no dispositivo e executar manualmente "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat."
4. Instale OpenCV usando VCPKG:
`bash
CDC:
mkdir c:srccd c:src
clone do git 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 durante esta etapa, pois pode levar um tempo significativo para baixar e construir dependências.
Usuários avançados:
- Observe que existem muitos outros módulos opcionais que você pode querer adicionar ao construir o OpenCV. Execute .vcpkg.exe search 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.
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#download-windows para baixar e instalar o cuDNN.
3. Verifique a instalação do CUDA:
Depois de instalar o CUDA, certifique-se de executar nvcc.exe e nvidia-smi.exe. Talvez seja necessário ajustar sua variável PATH.
4. Integre cuDNN:
Descompacte o arquivo cuDNN baixado e copie os diretórios "bin", "include" e "lib" em C:Program FilesNVIDIA GPU Computing ToolkitCUDA[versão]. Talvez seja necessário substituir os arquivos existentes.
5. Instale o CUDA após o Visual Studio:
- CUDA deve ser instalado após o Visual Studio. Se você atualizar o Visual Studio, lembre-se de reinstalar o CUDA.
6. Clone Darknet e construa:
`bash
cd c:src
clone do git https://github.com/hank-ai/darknet.gitcd darknet
compilação mkdir buildcd
cmake -DCMAKEBUILDTYPE=Liberar -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
7. Lidar com 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 relevantes no mesmo diretório 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 CUDA e execute o comando apropriado.)
- Execute novamente o último comando msbuild.exe para gerar o pacote de instalação do NSIS.
Usuários avançados:
A saída do comando cmake é um arquivo de solução regular do Visual Studio (Darknet.sln). Se preferir usar a GUI do Visual Studio em vez de msbuild.exe para compilação, você pode carregar o projeto Darknet no Visual Studio e ignorar as etapas da linha de comando.
Agora você deve ter o executável C:srcDarknetbuildsrc-cliReleasedarknet.exe. Execute a versão C:srcDarknetbuildsrc-cliReleasedarknet.exe para testar a instalação.
Para instalar o Darknet corretamente, incluindo as bibliotecas, incluir arquivos e DLLs necessárias, execute o assistente de instalação NSIS criado na última etapa. Localize o arquivo darknet-VERSION.exe no diretório de construção, por exemplo, darknet-2.0.31-win64.exe.
O pacote de instalação do NSIS irá:
Crie um diretório chamado "Darknet" (por exemplo, C:Program FilesDarknet).
Instale o aplicativo CLI (darknet.exe) e outros aplicativos de amostra.
Instale os arquivos .dll de terceiros necessários (por exemplo, do OpenCV).
Instale os arquivos Darknet .dll, .lib e .h necessários para usar darknet.dll de outros aplicativos.
Instale arquivos .cfg de modelo.
Agora você terminou! Assim que o assistente de instalação for concluído, Darknet será instalado em C:Program FilesDarknet. Execute a versão C:Program FilesDarknetbindarknet.exe para verificar a instalação.
Se você não tiver C:/Program Files/darknet/bin/darknet.exe, isso indica que você apenas o construiu, não o instalou. Certifique-se de passar por cada painel do assistente de instalação do NSIS conforme descrito anteriormente.
Usando Darknet
CLI
Esta não é uma lista exaustiva de todos os comandos suportados pelo Darknet.
Além da CLI Darknet, observe a CLI do projeto DarkHelp, que oferece uma interface alternativa para Darknet/YOLO. Inclui vários recursos avançados não disponí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 os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar uma rede neural pré-treinada de recursos disponíveis publicamente. Alguns exemplos incluem:
LEGO Gears (detecção de objetos em imagens)
Rolodex (detecção de texto em imagens)
MSCOCO (detecção de objetos padrão de classe 80)
Aqui estão alguns exemplos de comandos e seu uso:
Comandos básicos:
Ajuda:
`bash
ajuda darknet
`
Versão:
`bash
versão darknet
`
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
`
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
`
Entrada da 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 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
`
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
`
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:
mapa:
`bash
mapa do detector darknet driving.data driving.cfg driving_best.weights ...
`
- Este comando exibirá a precisão média (AP) para cada classe no conjunto de dados.
mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
- Este comando calcula o mAP em um limite de IoU de 0,75.
Calculando âncoras:
A melhor prática para recálculo de âncoras é usar o DarkMark, pois ele executa 100 cálculos consecutivos e seleciona as âncoras ideais. No entanto, você pode usar o método Darknet mais antigo:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
Treinando uma nova rede:
Treinamento básico:
`bash
detector darknet -map -dont_show trem animais.data animais.cfg
`
- Os melhores pesos serão salvos como pets_best.weights, e o progresso do treinamento ficará visível em chart.png.
Treinamento detalhado:
`bash
detector darknet -map -dont_show --verbose trem animais.data animais.cfg
`
- Este comando fornece informações mais detalhadas durante o treinamento.
Treinamento
Links rápidos para seções relevantes do FAQ Darknet/YOLO:
Configuração de arquivos e diretórios: [link para a seção FAQ]
Escolhendo o arquivo de configuração correto: [link para a seção FAQ]
Comando de treinamento: [link para a seção FAQ]
A maneira mais direta de anotar e treinar é usar DarkMark para criar todos os arquivos Darknet necessários. Esta é a abordagem recomendada para treinar uma nova rede neural.
Configuração de treinamento manual:
1. Crie uma pasta: Crie uma nova pasta para armazenar seus arquivos de treinamento. Por exemplo, ~/nn/animais/.
2. Copie o arquivo de configuração: Copie um arquivo de configuração Darknet como modelo (por exemplo, cfg/yolov4-tiny.cfg) para sua pasta. Agora você tem ~/nn/animals/animals.cfg.
3. Crie o arquivo .names: Crie um arquivo de texto Animals.names na mesma pasta.
- Edite o arquivo para listar as classes que deseja detectar. Cada aula deve estar em uma linha separada, sem linhas em branco ou comentários. Por exemplo:
`
cachorro
gato
pássaro
cavalo
`
4. Crie o arquivo .data: Crie um arquivo de texto Animals.data na mesma pasta.
- O arquivo .data define os conjuntos de dados de treinamento e validação, nomes de classes e diretório de backup. Por exemplo:
`
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
`
5. Crie a pasta de imagens e anotações: Crie uma pasta (por exemplo, ~/nn/animals/dataset) para armazenar suas imagens e anotações.
- Cada imagem requer um arquivo .txt correspondente contendo anotações. O formato da anotação é específico; não pode ser criado manualmente. Use DarkMark ou software similar para anotar imagens.
- O formato de anotação YOLO é explicado no FAQ Darknet/YOLO.
6. Crie os arquivos “train” e “valid”: Crie os arquivos de texto “train” e “valid” mencionados no arquivo .data.
- Esses arquivos listam as imagens utilizadas para treinamento e validação, respectivamente. Cada imagem deve estar em uma linha separada. Você pode usar caminhos relativos ou absolutos.
7. Modifique o arquivo de configuração:
- Abra seu arquivo .cfg com um editor de texto e faça os seguintes ajustes:
- batch=64: Este valor geralmente é adequado.
- subdivisões: comece com subdivisões=1. Talvez seja necessário aumentar esse valor dependendo da memória da GPU e das dimensões da rede. Consulte as Perguntas frequentes sobre Darknet/YOLO para obter orientação.
- maxbatches: Defina como 2.000 * número de classes. Por exemplo, com 4 classes, maxbatches=8000.
- etapas: defina como 80% e 90% de maxbatches. Por exemplo, com maxbatches=8000, steps=6400,7200.
- largura e altura: Estas são as dimensões da rede. Consulte as perguntas frequentes da Darknet/YOLO para obter conselhos sobre cálculo de dimensões.
- classes: altere a linha classes=... para corresponder ao número de classes em seu arquivo .names (neste exemplo, classes=4).
- filtros: modifique a linha filter=... em cada seção [convolutional] antes de cada seção [yolo]. O valor é calculado como (número de classes + 5) * 3. Por exemplo, com 4 classes, filtros=27.
8. Comece a treinar:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
- O treinamento pode demorar um pouco. Os melhores pesos serão salvos como Animals_best.weights. O progresso do treinamento é visível no arquivo chart.png. Consulte as perguntas frequentes do Darknet/YOLO para parâmetros de treinamento adicionais.
- Se quiser informações de treinamento mais detalhadas, adicione o parâmetro --verbose:
`bash
detector darknet -map -dont_show --verbose trem animais.data animais.cfg
`
Outras ferramentas e links
DarkMark: Esta ferramenta auxilia no gerenciamento de seus projetos Darknet/YOLO, anotando imagens, verificando anotações e gerando os arquivos necessários para o treinamento Darknet.
DarkHelp: uma CLI alternativa robusta para Darknet que fornece recursos como mosaico de imagens, rastreamento de objetos em vídeos e uma API C++ robusta para aplicativos comerciais.
Perguntas frequentes sobre Darknet/YOLO: Um recurso valioso para responder às suas perguntas sobre Darknet/YOLO.
Canal de Stéphane no YouTube: Encontre vários tutoriais e vídeos de exemplo.
Servidor Darknet/YOLO Discord: Junte-se ao servidor para fazer perguntas de suporte e conectar-se com outros usuários Darknet/YOLO.
Roteiro
Última atualização: 30/10/2024
Concluído
Trocar qsort(): substituído qsort() por std::sort() em partes relevantes da base de código. (Algumas instâncias restantes ainda usam qsort())
Remover funções desatualizadas: removidos check_mistakes, getchar() e system().
Base de código C++: Darknet convertido para usar o compilador C++ (g++ no Linux, VisualStudio no Windows).
Compilação do Windows: Corrigido o processo de compilação do Windows.
Suporte Python: Integração Python corrigida.
Biblioteca Darknet: Construída a biblioteca Darknet.
Rótulos de previsão: rótulos reativados nas previsões (o código "alfabeto").
Código CUDA/GPU: funcionalidade CUDA/GPU reativada.
CUDNN: Suporte CUDNN reativado.
CUDNN half: suporte de meia precisão CUDNN reativado.
Arquitetura CUDA: Removida a codificação da arquitetura CUDA.
Informações da versão CUDA: informações aprimoradas da versão CUDA.
AVX: Suporte AVX reativado.
Arquivos legados removidos: soluções antigas e Makefile removidas.
Dependência do OpenCV: Tornou o OpenCV uma dependência obrigatória.
Biblioteca pthread: Removida a dependência da antiga biblioteca pthread.
STB: dependência de STB removida.
CMakeLists.txt: CMakeLists.txt reescrito para usar o novo método de detecção CUDA.
Arquivos desatualizados removidos: removido o código antigo do "alfabeto" e excluído mais de 700 imagens em dados/rótulos.
Compilação fora da fonte: compilações fora da fonte habilitadas.
Número da versão: saída aprimorada do número da versão.
Desempenho do treinamento: Otimizações de desempenho para treinamento (tarefa em andamento).
Desempenho de inferência: Otimizações de desempenho para inferência (tarefa em andamento).
Passagem por referência: Usada passagem por referência sempre que possível para melhorar a eficiência.
Limpeza de código: arquivos .hpp limpos.
Darknet.h reescrito: arquivo de cabeçalho da API Darknet atualizado.
Uso de cv::Mat: Usado cv::Mat como um objeto C++ adequado em vez de convertê-lo em void*.
Estrutura da imagem: Corrigidas inconsistências e problemas relacionados à estrutura interna da imagem.
Suporte Jetson: compilações corrigidas para dispositivos Jetson baseados em ARM.
- É improvável que dispositivos Jetson mais antigos sejam corrigidos devido à descontinuação do suporte da NVIDIA (sem compilador C++ 17).
- Novos dispositivos Jetson Orin estão funcionando.
API Python em V3: corrigida a API Python em Darknet V3.
Metas de curto prazo
Trocar printf(): Substitua printf() por std::cout (em andamento).
Suporte para câmera Zed: revisite e melhore o suporte para a câmera Zed.
Análise de linha de comando: implemente uma análise de linha de comando mais robusta e consistente (em andamento).
Metas de médio prazo
Remover código char: Elimine todo o código char e substitua-o por std::string.
Avisos do compilador: não oculte avisos e resolva os avisos do compilador (em andamento).
Uso de cv::Mat: Melhore o uso de cv::Mat em vez da estrutura de imagem personalizada em C (em andamento).
Funcionalidade de lista: Substitua a funcionalidade de lista antiga por std::vector ou std::list.
Suporte a imagens em escala de cinza: corrige o suporte para imagens em escala de cinza de 1 canal.
Suporte de imagem de canal N: Adicione suporte para imagens com mais de 3 canais (por exemplo, canais de profundidade ou térmicos).
Limpeza contínua de código: continue com a limpeza contínua de código (em andamento).
Metas de longo prazo
Problemas de CUDA/CUDNN: Resolva problemas de compatibilidade de CUDA/CUDNN em diferentes GPUs.
Reescrever o código CUDA/CUDNN: Reescrever o código CUDA/CUDNN para melhorar o desempenho e a compatibilidade.
Suporte a GPUs não NVIDIA: investigue o suporte para GPUs não NVIDIA.
Caixas delimitadoras giradas: implemente suporte para caixas delimitadoras giradas ou informações de ângulo.
Pontos-chave/esqueletos: adicione suporte para pontos-chave e esqueletos.
Mapas de calor: implemente suporte a mapas de calor (em andamento).
Segmentação: adicione suporte para segmentação.
