Repositório principal Data.gov
Este é o repositório principal da plataforma Data.gov. Ele é usado principalmente para rastrear o trabalho da equipe, mas também para hospedar código de todo o datagov (modelos de ações do GitHub, saída, etc.).
Se você estiver procurando documentação para ambientes cloud.gov, consulte os repositórios de aplicativos.
Ações e modelos do GitHub
Várias ações do GitHub foram refatoradas para usar modelos neste repositório. Você pode encontrar esses modelos aqui e exemplos de como invocá-los no Inventário e no Catálogo.
Estrutura de detecção de objetos Darknet e YOLO
Darknet é uma estrutura de rede neural de código aberto construída com 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 como Hank.ai está apoiando a comunidade Darknet/YOLO.
Conheça o site Darknet/YOLO.
Explore as perguntas frequentes da Darknet/YOLO.
Junte-se ao servidor Darknet/YOLO Discord.
Artigos
1. Artigo YOLOv7 (link para artigo)
2. Papel Scaled-YOLOv4 (link para artigo)
3. Artigo YOLOv4 (link para artigo)
4. Artigo YOLOv3 (link para artigo)
Informações gerais
A estrutura Darknet/YOLO continua a ser mais rápida e precisa do que outras estruturas e versões do YOLO. É totalmente gratuito e de código aberto, permitindo incorporar Darknet/YOLO em seus projetos e produtos sem quaisquer restrições ou taxas de licenciamento.
Darknet V3 ("Jazz"), lançado em outubro de 2024, pode processar vídeos do conjunto de dados LEGO em até 1000 FPS usando uma GPU NVIDIA RTX 3090. Isso significa que cada quadro de vídeo é processado em menos de 1 milissegundo.
Junte-se ao servidor Darknet/YOLO Discord para ajuda e discussão: https://discord.gg/zSq8rtW
A versão CPU do Darknet/YOLO pode ser 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 requer uma GPU NVIDIA compatível com CUDA.
Darknet/YOLO é conhecido por funcionar em Linux, Windows e Mac. As instruções de construção são fornecidas abaixo.
Versão Darknet
Versão 0.x: A ferramenta Darknet original criada por Joseph Redmon entre 2013-2017.
Versão 1.x: O popular repositório Darknet mantido por Alexey Bochkovskiy de 2017-2021.
Versão 2.x ("OAK"): O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette a partir de 2023. Esta versão introduziu um comando de versão.
Versão 2.1: A última ramificação da base de código da versão 2, disponível na ramificação v2.
Versão 3.x ("JAZZ"): A última fase de desenvolvimento lançada em outubro de 2024.
Principais mudanças na versão 3.x:
1. Muitos comandos antigos e não mantidos foram removidos.
2. Otimizações significativas de desempenho para treinamento e inferência.
3. API C legada modificada; aplicativos que usam a API Darknet original podem exigir pequenos ajustes.
4. Introduzida a 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
Várias versões populares do YOLO são pré-treinadas no conjunto de dados MSCOCO por conveniência. Este conjunto de dados contém 80 classes, listadas no arquivo de texto cfg/coco.names.
Outros conjuntos de dados mais simples e pesos pré-treinados, como LEGO Gears e Rolodex, estão disponíveis para teste Darknet/YOLO. Consulte as perguntas frequentes do Darknet/YOLO para obter detalhes.
Você pode baixar pesos pré-treinados MSCOCO de vários locais, 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
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 você é incentivado a treinar suas próprias redes. MSCOCO é usado principalmente para confirmar se tudo está funcionando corretamente.
Prédio
Os métodos de construção disponíveis antes de 2023 foram combinados em uma solução única e unificada. Darknet requer C++17 ou mais recente, OpenCV, e usa CMake para gerar arquivos de projeto.
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 idênticas às instruções do Linux. Vários notebooks Jupyter que demonstram tarefas como treinar uma nova rede estão disponíveis no subdiretório colab. Você também pode seguir as instruções do Linux abaixo.
Método Linux CMake
1. Opcional: Se você tiver uma GPU NVIDIA moderna, instale CUDA ou CUDA+cuDNN. Darknet utilizará sua GPU para processamento mais rápido de imagens e vídeos.
2. Exclua o arquivo CMakeCache.txt do diretório de construção Darknet para forçar o CMake a reencontrar todos os arquivos necessários.
3. Reconstrua o Darknet.
4. Instale o CUDA (opcional): Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.
5. Instale o cuDNN (opcional): 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 baixar e instalar o cuDNN.
6. Verifique a instalação do CUDA: Certifique-se de poder executar nvcc e nvidia-smi. Talvez seja necessário modificar sua variável PATH.
7. Instale dependências e clone 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
compilação de CD
`
8. Configure o CMake:
`bash
cmake -DCMAKEBUILDTYPE=Liberar ..
`
9. Construir Darknet:
`bash
faça o pacote -j4
`
10. Instale DarkNet:
`bash
sudo dpkg -i darknet-VERSION.deb
`
11. Instalação de teste:
`bash
versão darknet
`
Notas Adicionais:
Se você estiver usando uma versão mais antiga do CMake, atualize-a antes de executar o comando cmake:
`bash
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Reinicie seu shell se estiver usando o bash, ou o fish deverá atualizar automaticamente o caminho.
Para construir um arquivo de instalação RPM em vez de um arquivo DEB, modifique o arquivo CM_package.cmake.
Depois que o pacote de instalação for compilado, use o gerenciador de pacotes da sua distribuição para instalá-lo (por exemplo, sudo dpkg -i darknet-2.0.1-Linux.deb em sistemas baseados em Debian).
Método CMake do Windows
1. Instale as ferramentas necessárias:
`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:
- Abra o "Instalador do Visual Studio".
- Clique em "Modificar".
- Selecione "Desenvolvimento Desktop com C++".
- Clique em “Modificar” no canto inferior direito e depois em “Sim”.
3. Abra o prompt de comando do desenvolvedor para VS 2022: não use o PowerShell.
4. Instale o Microsoft VCPKG:
`bash
cd c:mkdir c:srccd c:src
clone do git https://github.com/microsoft/vcpkgcd vcpkg
bootstrap-vcpkg.bat
.vcpkg.exe integrar
instalar .vcpkg.exe integrar powershell.vcpkg.exe instalar opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
5. Opcional: Instale CUDA ou CUDA+cuDNN (como nas instruções do Linux).
6. Exclua CMakeCache.txt (como nas instruções do Linux).
7. Reconstrua o Darknet (como nas instruções do Linux).
8. Instale o CUDA (opcional): Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.
9. Instale o cuDNN (opcional): 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.
10. Verifique a instalação do CUDA: certifique-se de poder executar o nvcc.exe. Talvez seja necessário modificar sua variável PATH.
11. Descompacte e copie os arquivos cuDNN: Depois de baixado, descompacte e copie os diretórios bin, include e lib para C:/Arquivos de programas/NVIDIA GPU Computing Toolkit/CUDA/[versão]/. Talvez seja necessário substituir alguns arquivos.
12. Clone Darknet e construa:
`bash
cd c:src
clone do git https://github.com/hank-ai/darknet.gitcd darknet
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
`
13. Copie DLLs CUDA (opcional): Se você encontrar erros sobre DLLs CUDA ou cuDNN ausentes (por exemplo, cublas64_12.dll), copie manualmente as DLLs CUDA para o diretório de saída Darknet.exe:
`bash
copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Certifique-se de substituir o número da versão pelo que você está usando.)
14. Execute novamente o comando msbuild.exe para gerar o pacote de instalação do NSIS:
`bash
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
15. Instalação de teste:
`bash
C: versão srcDarknetbuildsrc-cliReleasedarknet.exe
`
16. Execute o assistente de instalação NSIS: Isso instalará o aplicativo CLI, DLLs necessárias, bibliotecas, arquivos de inclusão e arquivos de configuração de modelo.
Notas Adicionais:
O comando cmake gera um arquivo de solução do Visual Studio (Darknet.sln). Você pode usar a GUI do Visual Studio para compilar o projeto em vez de msbuild.exe.
O pacote de instalação do NSIS (por exemplo, darknet-VERSION.exe) pode ser encontrado no diretório build.
Usando Darknet
CLI
A lista a seguir não é exaustiva de todos os comandos Darknet.
Ajuda darknet: exibe informações de ajuda.
Versão darknet: Verifique a versão Darknet.
Comandos de previsão:
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
`
Processamento de vídeo:
V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animaisbest.weights -extoutput test.mp4
`
V3:
`bash
darknet03display_videos animais.cfg teste.mp4
`
Ajuda escura:
`bash
DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
Entrada da webcam:
V2:
`bash
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
`
V3:
`bash
darknet08display_webcam animais
`
Salvar 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
`
Especifique a GPU:
V2:
`bash
demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4
`
Cálculo de precisão:
mapa:
`bash
mapa do detector darknet driving.data driving.cfg driving_best.weights ...
`
mAP@IoU=75:
`bash
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
`
Recalcular âncoras:
DarkMark (recomendado): Use DarkMark para executar 100 cálculos consecutivos e selecionar as melhores âncoras.
Rede Escura:
`bash
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
Treine uma nova rede:
Usando DarkMark (recomendado): Use DarkMark para criar todos os arquivos necessários para treinamento.
Configuração manual:
1. Crie uma nova pasta para seu projeto (por exemplo, ~/nn/animals/).
2. Copie um arquivo de configuração como modelo (por exemplo, cfg/yolov4-tiny.cfg) para a pasta.
3. Crie um arquivo de texto Animals.names com os nomes de suas classes, um por linha.
4. Crie um arquivo de texto Animals.data com o seguinte formato:
`
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
`
5. Crie uma pasta para imagens e anotações (por exemplo, ~/nn/animals/dataset).
6. Anote suas imagens e gere os arquivos de anotação .txt correspondentes usando DarkMark ou software semelhante.
7. Crie os arquivos Animalstrain.txt e Animalsvalid.txt, listando imagens para treinamento e validação respectivamente, uma por linha.
8. Modifique o arquivo de configuração:
- Definir lote = 64.
- Ajuste as subdivisões conforme necessário.
- Defina max_batches=8000 (ou 2.000 x número de classes).
- Definir etapas=6400,7200 (80% e 90% de max_batches).
- Defina largura e altura de acordo com as dimensões da sua rede.
- Atualize as classes com o número de classes no seu arquivo .names.
- Atualize os filtros em cada seção [convolucional] antes das seções [yolo]: (número de classes + 5) * 3.
9. Comece a treinar:
`bash
cd ~/nn/animais/
detector darknet -map -dont_show trem animais.data animais.cfg
`
Dicas adicionais de treinamento:
Use o parâmetro --verbose para obter informações de treinamento mais detalhadas:
`bash
detector darknet -map -dont_show --verbose trem animais.data animais.cfg
`
Outras ferramentas e links
DarkMark: gerencie projetos Darknet/YOLO, anote imagens, verifique anotações e gere arquivos de treinamento.
DarkHelp: CLI alternativa robusta para Darknet, suporte para mosaico de imagens, rastreamento de objetos e uma API C++ para aplicativos comerciais.
Perguntas frequentes sobre Darknet/YOLO: recurso abrangente para respostas a perguntas comuns.
Canal de Stéphane no YouTube: tutoriais e vídeos de exemplo no Darknet/YOLO.
Servidor Darknet/YOLO Discord: Fórum da comunidade para suporte e discussão.
Roteiro
Tarefas concluídas:
Substituído qsort() por std::sort() para melhorar a eficiência.
Funções obsoletas removidas como check_mistakes, getchar() e system().
Darknet convertido para usar o compilador C++ (g++ no Linux, VisualStudio no Windows).
Corrigidos problemas de compilação do Windows.
Suporte Python restaurado.
Construiu a biblioteca Darknet.
Rótulos de previsão reativados (código alfabético).
Suporte reativado para CUDA/GPU, CUDNN e CUDNN half.
Arquitetura CUDA codificada removida.
Informações aprimoradas sobre a versão CUDA.
Suporte AVX reativado.
Removidas soluções antigas e Makefile.
Tornou o OpenCV uma dependência não opcional.
Removida a dependência da antiga biblioteca pthread.
Dependência de STB removida.
CMakeLists.txt reescrito para usar a nova detecção CUDA.
Removido o código do alfabeto antigo e excluídas imagens desnecessárias.
Compilações fora do código-fonte ativadas.
Saída de número de versão aprimorada.
Treinamento otimizado e desempenho de inferência.
Implementado passagem por referência quando aplicável.
Arquivos .hpp limpos.
Reescreveu darknet.h.
Usado cv::Mat como um objeto C++ adequado em vez de converter para void*.
Corrigidas inconsistências no uso da estrutura interna da imagem.
Corrigidos problemas de compilação para dispositivos Jetson baseados em ARM (exceto para modelos mais antigos não suportados).
API Python corrigida na versão 3.
Metas de curto prazo:
Substitua printf() por std::cout.
Investigue o suporte para câmeras Zed mais antigas.
Melhore e padronize a análise de linha de comando.
Metas de médio prazo:
Remova todo o código char* e substitua por std::string.
Elimine avisos do compilador e garanta um estilo de código consistente.
Melhore o uso de cv::Mat sobre a estrutura de imagem C personalizada.
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.
Adicione suporte para imagens de canal N (por exemplo, com profundidade adicional ou canais térmicos).
Limpeza de código contínua.
Metas de longo prazo:
Resolva problemas de CUDA/CUDNN em todas as GPUs.
Reescreva o código CUDA + cuDNN.
Explore o suporte para GPUs não NVIDIA.
Implemente caixas delimitadoras giradas ou suporte de "ângulo".
Adicione pontos-chave/esqueletos, mapas de calor e suporte de segmentação.
