Download do tamilmovieorg - download do código-fonte do tamilmovieorg

tamilmovieorg

Outro código-fonte

Baixar

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 principalmente em C e CUDA.

YOLO (You Only Look Once) é um sistema de detecção de objetos em tempo real que opera dentro da estrutura Darknet.

Leia como Hank.ai está ajudando a comunidade Darknet/YOLO

Anunciando Darknet V3 "Jazz"

Veja o site Darknet/YOLO

Por favor, leia as perguntas frequentes do Darknet/YOLO

Junte-se ao servidor de discórdia Darknet/YOLO

Artigos

1. Artigo YOLOv7

2. Papel em escala-YOLOv4

3. Artigo YOLOv4

4. Artigo YOLOv3

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 integrar Darknet/YOLO em projetos e produtos existentes, inclusive comerciais, sem licença ou pagamento.

Darknet V3 ("Jazz"), lançado em outubro de 2024, pode processar 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.

Junte-se ao servidor Darknet/YOLO Discord para obter ajuda ou discussões: 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 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

A ferramenta Darknet original escrita por Joseph Redmon em 2013-2017 não tinha um número de versão. Consideramos esta versão 0.x.

O próximo repositório Darknet popular mantido por Alexey Bochkovskiy entre 2017-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 a partir de 2023 foi o primeiro com um comando de versão. De 2023 até o final de 2024, retornou a versão 2.x "OAK".

O objetivo era tentar quebrar o mínimo das funcionalidades existentes enquanto se familiarizava com a base de código.

As principais mudanças no Darknet 2.x incluem:

Reescreveu as etapas de construção para uma construção unificada baseada em CMake no Windows e Linux.

Converteu a base de código para usar o compilador C++.

Aprimorada a visualização do chart.png durante o treinamento.

Correções de bugs e otimizações de desempenho, focadas principalmente na redução do tempo de treinamento.

A última ramificação desta base de código é a versão 2.1 na ramificação v2.

A próxima fase de desenvolvimento começou em meados de 2024 e foi lançada em outubro de 2024. O comando version agora retorna 3.x "JAZZ".

Você sempre pode fazer uma verificação da ramificação v2 anterior se precisar executar um desses comandos. Deixe-nos saber se você encontrar algum comando ausente.

As principais mudanças no Darknet 3.x incluem:

Remoção de muitos comandos antigos e sem manutenção.

Otimizações de desempenho significativas para treinamento e inferência.

Modificação da API C legada, exigindo pequenas modificações para aplicações que utilizam a API Darknet original. Veja a documentação atualizada da API aqui: https://darknetcv.ai/api/api.html

Introdução de uma nova API Darknet V3 C e C++: https://darknetcv.ai/api/api.html

Novos aplicativos e código de amostra no diretório src-examples: https://darknetcv.ai/api/files.html

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 contém 80 classes, que podem ser encontradas 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, 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 estão 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 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.

Cuidado se você estiver seguindo tutoriais antigos com etapas de construção mais complicadas ou etapas de construção que não correspondem ao que está neste leia-me. As novas etapas de construção descritas abaixo começaram em agosto de 2023.

Os desenvolvedores de software são incentivados a visitar https://darknetcv.ai/ para obter informações sobre os componentes internos da estrutura de detecção de objetos Darknet/YOLO.

Google Colab

As instruções do Google Colab são iguais às instruções do Linux. Vários notebooks Jupyter estão disponíveis demonstrando tarefas como treinar uma nova rede.

Veja os notebooks no subdiretório colab e/ou siga as instruções do Linux abaixo.

Método Linux CMake

Tutorial de construção Darknet para Linux

1. Instale os pacotes necessários:

`bash

sudo apt-get install build-essential git libopencv-dev cmake

`

2. Clone o repositório Darknet:

`bash

mkdir ~/src

cd ~/src

clone do git https://github.com/hank-ai/darknet

cd rede escura

`

3. Crie um diretório de construção e execute o CMake:

`bash

compilação mkdir

compilação de CD

cmake -DCMAKEBUILDTYPE=Liberar ..

`

4. Construir Darknet:

`bash

faça -j4

`

5. Opcional: Instale CUDA ou CUDA+cuDNN

Se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN. Isso permitirá que a Darknet use sua GPU para processamento mais rápido de imagens e vídeos.

- Baixe e instale o CUDA em https://developer.nvidia.com/cuda-downloads.

- Baixe e instale o cuDNN em 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.

Importante: Se você instalar CUDA ou CUDA+cuDNN após compilar o Darknet, deverá excluir o arquivo CMakeCache.txt em seu diretório de construção e executar novamente o cmake para garantir que o CMake possa encontrar os arquivos necessários.

Nota: Darknet pode ser executado sem CUDA, mas se você quiser treinar uma rede personalizada, é necessário CUDA ou CUDA+cuDNN.

6. Empacote e instale o Darknet:

`bash

fazer pacote

sudo dpkg -i darknet-VERSION.deb

`

Importante: Se você estiver usando uma versão mais antiga do CMake, pode ser necessário atualizá-la antes de executar o comando cmake. Atualize o CMake no Ubuntu usando:

`bash

sudo apt-get purge cmake

sudo snap install cmake --classic

`

Usuários avançados:

- Se você deseja construir um arquivo de instalação RPM em vez de um arquivo DEB, edite as duas linhas a seguir em CM_package.cmake antes de executar make 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 da sua distribuição. Por exemplo, em 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 executável Darknet.

- /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/...: Localização de todos os modelos .cfg.

- Agora você terminou! Darknet foi construído e instalado em /usr/bin/. Execute a versão darknet da CLI para confirmar a instalação.

Método CMake do Windows

Estas instruções pressupõem uma nova instalação do Windows 11 22H2.

1. Instale o software necessário:

`PowerShell

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 menu “Iniciar do Windows” e execute o “Visual Studio Installer”.

- Clique em “Modificar”.

- Selecione "Desenvolvimento Desktop com C++".

- Clique em “Modificar” no canto inferior direito e depois em “Sim”.

3. Instale o Microsoft VCPKG:

- Abra o menu “Iniciar do Windows” e selecione “Prompt de comando do desenvolvedor para VS 2022”. Não use o PowerShell para estas etapas.

- 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 Arquivos de ProgramasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat.

- Execute os seguintes comandos:

`PowerShell

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 esta última etapa, pois pode demorar muito para ser executada. Ele precisa baixar e construir muitas coisas.

- Usuários avançados: Observe que existem muitos outros módulos opcionais que você pode querer adicionar ao construir o OpenCV. Execute .vcpkg.exe search opencv para ver a lista completa.

4. Opcional: Instale CUDA ou CUDA+cuDNN

Se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN. Isso permitirá que a Darknet use sua GPU para processamento mais rápido de imagens e vídeos.

- Baixe e instale o CUDA em https://developer.nvidia.com/cuda-downloads.

- Baixe e instale o cuDNN em https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows.

Importante: Se você instalar CUDA ou CUDA+cuDNN após compilar o Darknet, deverá excluir o arquivo CMakeCache.txt em seu diretório de construção e executar novamente o cmake para garantir que o CMake possa encontrar os arquivos necessários.

Nota: Darknet pode ser executado sem CUDA, mas se você quiser treinar uma rede personalizada, é necessário CUDA ou CUDA+cuDNN.

5. Clone Darknet e construa-o:

`PowerShell

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

`

Importante:

- Instalação CUDA: CUDA deve ser instalado após o Visual Studio. Se você atualizar o Visual Studio, lembre-se de reinstalar o CUDA.

- DLLs ausentes: se você encontrar erros sobre DLLs CUDA ou cuDNN ausentes (por exemplo, cublas64_12.dll), copie manualmente os arquivos .dll CUDA no mesmo diretório de saída que darknet.exe. Por exemplo:

`PowerShell

copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease

`

(Este é um exemplo; verifique a versão CUDA que você está executando e ajuste o caminho de acordo.)

- Execute novamente msbuild.exe: Após copiar os arquivos .dll, execute novamente o último comando msbuild.exe para gerar o pacote de instalação NSIS:

`PowerShell

msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj

`

- Usuários avançados: observe que a saída do comando cmake é um arquivo de solução normal do Visual Studio (darknet.sln). Se você usa regularmente a GUI do Visual Studio em vez de msbuild.exe, poderá ignorar as etapas da linha de comando e carregar o projeto Darknet no Visual Studio.

- Agora você deve ter um arquivo que pode ser executado: C:srcDarknetbuildsrc-cliReleasedarknet.exe. Execute isto para testar: versão C:srcDarknetbuildsrc-cliReleasedarknet.exe.

6. Instale o Darknet:

- Execute o assistente de instalação do NSIS que foi criado na última etapa. Procure 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, como os do OpenCV.

- Instale os arquivos Darknet .dll, .lib e .h necessários para usar darknet.dll de outro aplicativo.

- Instale arquivos .cfg de modelo.

- Agora você terminou! Assim que o assistente de instalação terminar, Darknet terá sido instalado em C:Arquivos de ProgramasDarknet. Execute isto para testar: 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, considere também a CLI do projeto DarkHelp, que oferece uma CLI alternativa para Darknet/YOLO com recursos avançados não disponíveis diretamente no Darknet. Você pode usar a CLI Darknet e a CLI DarkHelp juntas.

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 pré-treinada da Internet. Exemplos de conjuntos de dados pré-treinados incluem:

LEGO Gears (para encontrar objetos em uma imagem)

Rolodex (para encontrar texto em uma imagem)

MSCOCO (detecção de objetos padrão de classe 80)

Comandos para executar:

Obtenha ajuda:

`bash

ajuda darknet

`

Confira a versão:

`bash

versão darknet

`

Preveja 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

`

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 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 neural:

`bash

mapa do detector darknet driving.data driving.cfg driving_best.weights ...

`

Exemplo de 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 bicicleta 89,0912 570 124 104 3548 0,9475 0,0525 0,8457 0,8213 0,9715 0,0285 3 pessoa 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 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

`

Verificando a precisão mAP@IoU=75:

`bash

mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75

`

Recálculo de âncoras:

É melhor recalcular as âncoras no DarkMark, pois ele executa 100 vezes consecutivas e seleciona as melhores âncoras. No entanto, se você quiser usar a versão mais antiga no Darknet:

`bash

detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256

`

Treinando uma nova rede:

`bash

detector darknet -map -dont_show trem animais.data animais.cfg

`

(Veja também a seção Treinamento abaixo)

Treinamento

Links rápidos para seções relevantes do FAQ Darknet/YOLO:

Como devo configurar meus arquivos e diretórios?

Qual arquivo de configuração devo usar?

Qual comando devo usar ao treinar minha própria rede?

A maneira mais simples de anotar e treinar é com DarkMark, que cria todos os arquivos Darknet necessários. Esta é a forma recomendada para treinar uma nova rede neural.

Se preferir configurar manualmente os vários arquivos para treinar uma rede personalizada:

1. Crie uma nova pasta:

- Escolha uma pasta para armazenar seus arquivos. Para este exemplo, criaremos uma rede neural para detectar animais, então o diretório será ~/nn/animals/.

2. Copie um arquivo de configuração Darknet:

- Copie um arquivo de configuração Darknet como modelo. Por exemplo, use cfg/yolov4-tiny.cfg. Coloque isso na pasta que você criou. Agora, você deve ter ~/nn/animals/animals.cfg.

3. Crie um arquivo de texto Animals.names:

- Crie um arquivo de texto Animals.names na mesma pasta do arquivo de configuração. Agora você tem ~/nn/animals/animals.names.

4. Edite o arquivo pets.names:

- Edite o arquivo Animals.names usando um editor de texto. Liste as classes que você deseja detectar, com exatamente uma entrada por linha, sem linhas em branco e sem comentários. Neste exemplo, o arquivo .names conterá quatro linhas:

`

cachorro

gato

pássaro

cavalo

`

5. Crie um arquivo de texto 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. Crie uma pasta para imagens e anotações:

- Crie uma pasta para armazenar suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset.

- Cada imagem precisará de um arquivo .txt correspondente descrevendo as anotações dessa imagem. O formato desses arquivos de anotação .txt é muito específico. Você não pode criá-los manualmente, pois cada anotação requer as coordenadas exatas. Use 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. Crie arquivos de texto "treinados" e "válidos":

- Crie os arquivos de texto "train" e "valid" nomeados no arquivo .data.

- Esses dois arquivos de texto devem listar todas as imagens que a Darknet usará para treinamento e validação (para cálculo de mAP%).

- Cada linha deve conter exatamente um caminho de imagem e nome de arquivo. Você pode usar caminhos relativos ou absolutos.

8. Modifique o arquivo .cfg:

- Use um editor de texto para modificar seu arquivo .cfg:

- Certifique-se de lote=64.

- Subdivisões: Dependendo das dimensões da rede e da memória da GPU, pode ser necessário ajustar as subdivisões. Comece com subdivisions=1 e consulte o FAQ Darknet/YOLO se não funcionar.

- Maxbatches: Defina um bom valor inicial para maxbatches para 2.000 vezes o número de classes. Neste exemplo, temos 4 animais, então max_batches=8000.

- Etapas: defina as etapas para 80% e 90% de max_batches. Neste caso, usaríamos passos=6400,7200.

- Largura e Altura: Estas são as dimensões da rede. O FAQ Darknet/YOLO explica como calcular o melhor tamanho.

- Classes: Pesquise todas as instâncias de classes=... e atualize-as com o número de classes em seu arquivo .names. Neste exemplo, usaríamos classes=4.

- Filtros: Pesquise todas as instâncias de filter=... nas seções [convolucionais] antes de cada seção [yolo]. O valor a ser usado é (numberofclasses + 5) 3. Para este exemplo, (4 + 5) 3 = 27. Portanto, usaríamos filter=27 nas linhas apropriadas.

9. Comece a treinar:

- Navegue até o diretório ~/nn/animals/:

`bash

cd ~/nn/animais/

`

- Execute o seguinte comando para iniciar o treinamento:

`bash

detector darknet -map -dont_show trem animais.data animais.cfg

`

- Ser paciente. Os melhores pesos serão salvos como Animals_best.weights. Você pode acompanhar o progresso do treinamento observando o arquivo chart.png. Consulte as perguntas frequentes do Darknet/YOLO para parâmetros adicionais que você pode querer usar durante o treinamento.

- 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: Para gerenciar seus projetos Darknet/YOLO, anotar imagens, verificar anotações e gerar arquivos para treinamento com 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 adequada para aplicações comerciais.

Darknet/YOLO FAQ: Um recurso abrangente para responder às suas perguntas.

Canal de Stéphane no YouTube: vários tutoriais e vídeos de exemplo.

Servidor Darknet/YOLO Discord: Junte-se à comunidade para suporte e discussões.

Roteiro

Última atualização em 30/10/2024:

Concluído:

Trocado qsort() por std::sort() durante o treinamento (alguns outros obscuros permanecem).

Check_mistakes, getchar() e system() foram removidos.

Darknet convertido para usar o compilador C++ (g++ no Linux, VisualStudio no Windows).

Corrigida a compilação do Windows.

Suporte corrigido para Python.

Construiu a biblioteca darknet.

Rótulos reativados em previsões (código "alfabeto").

Código CUDA/GPU reativado.

CUDNN reativado.

Metade CUDNN reativada.

Arquitetura CUDA codificada removida.

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.

Compilações fora do código-fonte ativadas.

Saída de número de versão aprimorada.

Implementei otimizações de desempenho relacionadas ao treinamento (em andamento).

Implementadas otimizações de desempenho relacionadas à inferência (em andamento).

Usado passagem por referência sempre que possível.

Arquivos .hpp limpos.

Reescreveu darknet.h.

Evitou lançar cv::Mat para void*, usando-o como um objeto C++ adequado.

Consistência corrigida ou aprimorada no uso da estrutura interna da imagem.

Compilações corrigidas para dispositivos Jetson baseados em ARM. (É improvável que os dispositivos Jetson originais sejam consertados, pois não são mais suportados pela NVIDIA - não há compilador C++ 17. Os novos dispositivos Jetson Orin estão funcionando).

Corrigida a API Python na V3.

Suporte aprimorado para Python. (Algum desenvolvedor Python está disposto a ajudar com isso?)

Metas de curto prazo

Substitua printf() por std::cout (em andamento).

Investigue o suporte para câmeras Zed antigas.

Melhorar e tornar a análise de linha de comando mais consistente (em andamento).

Metas de médio prazo

Remova todo o código char* e substitua por std::string.

Evite ocultar 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 tons de cinza de 1 canal.