vídeo2x

Video2X: Upscaling de vídeo de alta qualidade e estrutura de interpolação de quadros

Editor de código-fonte

Importante

As versões 4 e 5 atingiram o status de fim de vida (EOL). Devido aos recursos de desenvolvimento limitados, quaisquer problemas relacionados com versões anteriores à 6 não serão mais resolvidos.

Versão 6.0.0

Baixe o instalador do Windows

Resumindo: a versão 6.0.0 é uma reescrita completa do projeto Video2X em C/C++, com uma arquitetura mais rápida e eficiente, suporte multiplataforma, qualidade de saída bastante melhorada e novos recursos para fácil configuração na GUI e no instalador do Windows .

A versão 6.0.0 é uma reescrita completa do projeto, implementada em C/C++ e inclui os seguintes recursos:

1. Arquitetura mais rápida: Ao aproveitar multi-threading e aceleração de GPU, o Video2X agora é muito mais rápido do que antes.

2. Suporte multiplataforma: Video2X agora roda em Windows, Linux e macOS.

3. Qualidade de saída aprimorada: Video2X agora oferece maior qualidade de upscaling, especialmente para vídeos de alta resolução.

4. Nova GUI: Video2X agora apresenta uma GUI amigável que simplifica o processo de configuração e uso.

5. Novo instalador: Video2X agora oferece um instalador fácil de usar que ajuda você a instalar o software de forma rápida e fácil no Windows.

O suporte para RealCUGAN e interpolação de quadros usando RIFE estará disponível em breve.

Baixe a versão do Windows

Você pode baixar a versão mais recente do Windows na página de lançamentos. Para uso básico da GUI, consulte a página wiki da GUI. Se você não conseguir fazer download diretamente do GitHub, tente usar um espelho. A GUI atualmente oferece suporte aos seguintes idiomas:

1. Inglês

2. Chinês simplificado

3. Chinês Tradicional

4. Japonês

5. Coreano

6. Francês

7. Alemão

8. Italiano

9. Espanhol

10. Português

11. Russo

Instalar no Linux

Você pode instalar o Video2X no Arch Linux usando o pacote video2x-git ou baixar os binários pré-compilados na página de lançamentos. Se você deseja compilar a partir do código-fonte, consulte o arquivo PKGBUILD para obter uma visão geral dos pacotes e comandos necessários. Se você não quiser compilar seu programa a partir do código-fonte, considere usar a imagem do contêiner abaixo.

imagem do contêiner

As imagens de contêiner Video2X estão disponíveis no registro de contêiner GitHub para fácil implantação em Linux e macOS. Se você tiver o Docker/Podman instalado, poderá iniciar a amplificação de vídeo com apenas um comando. Para obter mais informações sobre como usar a imagem Docker do Video2X, consulte a documentação.

Google Colab (obsoleto: 5.0.0-beta7)

Se você não possui sua própria GPU poderosa, pode usar o Video2X gratuitamente no Google Colab. Você pode emprestar uma GPU poderosa (NVIDIA T4, L4 ou A100) gratuitamente nos servidores do Google por até 12 horas por sessão. Use recursos gratuitos de maneira justa e não crie sessões contínuas e execute o Zoom 24 horas por dia, 7 dias por semana. Isso pode resultar em você ser banido. Se você deseja usar uma GPU melhor e obter tempos de execução mais longos, obtenha o Colab Pro/Pro+. As instruções de uso estão incorporadas no caderno Colab.

Grupo de discussão do telegrama

Junte-se ao nosso grupo de discussão do Telegram para tirar qualquer dúvida sobre o Video2X, conversar diretamente com os desenvolvedores ou discutir a tecnologia de super-resolução e o futuro do Video2X.

documento

A documentação do Video2X está hospedada na página Wiki deste repositório. Inclui instruções abrangentes sobre como usar GUI, CLI, imagens de contêiner, bibliotecas e muito mais. Os wikis estão abertos à edição pela comunidade, então você, sim, você também pode corrigir erros ou adicionar novo conteúdo à documentação.

introduzir

Video2X é uma estrutura de upscaling de vídeo e interpolação de quadros baseada em aprendizado de máquina, construída em torno de três componentes principais:

1. Modelos: Video2X usa uma variedade de modelos avançados de aprendizado profundo para realizar upscaling e interpolação de quadros.

2. Motor: O motor Video2X é responsável por processar dados de vídeo, realizar inferência de modelo e gerar vídeos de saída.

3. Interface: Video2X fornece várias interfaces, como GUI, CLI e imagens de contêiner para permitir que você use a estrutura facilmente.

Demonstração em vídeo

Ampliar: Trailer do filme Spirited Away

Snippet de teste padrão

O trecho a seguir pode ser usado para testar se sua configuração está funcionando corretamente. Este também é um trecho padrão para executar benchmarks de desempenho.

O clipe original é do anime "The Pet Girl of Sakurasou".

Os direitos autorais deste clipe pertencem à Amino Pulse Co., Ltd.

licença

Este projeto é lançado sob a licença GNU AGPL versão 3.

Copyright (C) 2018-2024 K4YT3X e colaboradores.

Este projeto inclui ou depende dos seguintes projetos:

1.opencv: https://github.com/opencv/opencv

2. waifu2x-caffe: https://github.com/nagadomi/waifu2x-caffe

3. Real-ESRGAN: https://github.com/xinntao/Real-ESRGAN

4. BasicSR: https://github.com/xinntao/BasicSR

5.GFPGAN: https://github.com/TencentARC/GFPGAN

6. RIFE: https://github.com/hzwer/arXiv2021-RIFE

7. Anime4K: https://github.com/bloc97/Anime4K

Você pode encontrar mais informações de licenciamento no arquivo NOTICE.

agradecimento especial

Agradecimentos especiais às seguintes pessoas por suas contribuições significativas para este projeto, em ordem alfabética:

1. K4YT3X: Criador do Projeto

2. Colaboradores: Obrigado a todos que contribuíram para este projeto.

Por exemplo:

Licença Apache-2.0

Índice

Estrutura de detecção de objetos Darknet e YOLO

1. Papel

2. Informações gerais

3. Versão Darknet

4. Pesos pré-treino MSCOCO

5. Construir

1. Google Colab

2. Método Linux CMake

3. Método CMake do Windows

6. Use Darknet

1.CLI

2. Treinamento

7. Outras ferramentas e links

8. Roteiro

1. Metas de curto prazo

2. Metas de médio prazo

3. Metas de longo prazo

Estrutura de detecção de objetos Darknet e YOLO

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 em tempo real de última geração executado na estrutura Darknet.

Leia como Hank.ai ajuda a comunidade Darknet/YOLO

Anunciando Darknet V3 “Jazz”

Confira o site Darknet/YOLO

Por favor, leia as perguntas frequentes da Darknet/YOLO

Junte-se ao servidor Darknet/YOLO Discord

papel

1. Artigo YOLOv7

2. Papel escalado-YOLOv4

3. Papel 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 YOLO.

A estrutura é totalmente gratuita e de código aberto. Você pode integrar Darknet/YOLO em projetos e produtos existentes (incluindo produtos comerciais) sem licenciamento ou taxas.

Darknet V3 ("Jazz"), lançado em outubro de 2024, pode executar com precisão vídeo de conjunto de dados LEGO em até 1000 FPS ao usar uma GPU NVIDIA RTX 3090, o que significa que cada quadro de vídeo leva 1 milissegundo ou menos. Lido internamente, redimensionado e processado por Darknet/ YOLO.

Se você precisar de ajuda ou quiser discutir Darknet/YOLO, entre no servidor Darknet/YOLO Discord: https://discord.gg/zSq8rtW

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 GPU compatível com CUDA da NVIDIA.

Darknet/YOLO é conhecido por rodar em Linux, Windows e Mac. Veja as instruções de construção abaixo.

Versão Darknet

As ferramentas Darknet originais escritas por Joseph Redmon em 2013-2017 não tinham números de versão. Achamos que esta é a versão 0.x.

A próxima biblioteca Darknet popular mantida por Alexey Bochkovskiy de 2017-2021 também não possui um número de versão. Achamos que esta é a versão 1.x.

A biblioteca Darknet patrocinada por Hank.ai e mantida por Stéphane Charette a partir de 2023 é a primeira biblioteca a ter um comando de versão. De 2023 até o final de 2024, retorna para a versão 2.x “OAK”.

O objetivo é se familiarizar com a base de código e, ao mesmo tempo, quebrar o mínimo possível de funcionalidades existentes.

1. Reescrevemos as etapas de construção para que agora possamos construir no Windows e Linux usando CMake.

2. Converta a base de código para usar um compilador C++.

3. Chart.png aprimorado durante o treinamento.

4. Correções de bugs e otimizações relacionadas ao desempenho, principalmente relacionadas à redução do tempo necessário para treinar a rede.

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

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

Se precisar executar um desses comandos, você sempre pode verificar a ramificação v2 anterior. Informe-nos para que possamos investigar a adição de comandos ausentes.

1. Muitos comandos antigos e não mantidos foram removidos.

2. Fiz muitas otimizações de desempenho, tanto durante o treinamento quanto na inferência.

3. Os aplicativos C API modificados que usam a API Darknet original precisarão fazer pequenas modificações: https://darknetcv.ai/api/api.html

4. 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

Por conveniência, várias versões populares do YOLO são pré-treinadas no conjunto de dados MSCOCO. O conjunto de dados contém 80 categorias e pode ser visto 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. Para obter mais informações, consulte as perguntas frequentes do Darknet/YOLO.

Os pesos pré-treinados da MSCOCO podem ser baixados de vários locais diferentes e também deste repositório:

1. YOLOv2, novembro de 2016

1. YOLOv2-minúsculo

2.YOLOv2-completo

2. YOLOv3, maio de 2018

1. YOLOv3-minúsculo

2.YOLOv3 completo

3. YOLOv4, maio de 2020

1.YOLOv4-minúsculo

2. YOLOv4 completo

4. YOLOv7, agosto de 2022

1. YOLOv7-minúsculo

2. YOLOv7-completo

Os pesos pré-treinados da MSCOCO são apenas para fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO estão localizados no diretório cfg. Comando 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 deve-se treinar sua própria rede. O MSCOCO geralmente é usado para confirmar se tudo está funcionando corretamente.

construir

Os vários métodos de construção disponíveis no passado (antes de 2023) foram fundidos numa solução unificada. Darknet requer C++17 ou superior, OpenCV e uso de 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. Existem vários notebooks Jupyter disponíveis que mostram como realizar determinadas tarefas, como treinar uma nova rede.

Confira o notebook 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 ser executado sem ele, mas se você quiser treinar uma rede personalizada, precisará de CUDA ou CUDA+cuDNN.

Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.

Visite https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#cudnn-package-manager-installation-overview para fazer download e instale o cuDNN.

Depois de instalar o CUDA, certifique-se de executar o nvcc e o nvidia-smi. Pode ser necessário modificar a variável PATH.

Se você instalou CUDA ou CUDA+cuDNN posteriormente, ou se atualizou para uma versão mais recente do software NVIDIA:

Estas instruções pressupõem (mas não exigem!) que o sistema esteja executando o Ubuntu 22.04. Se você estiver usando outra distribuição, ajuste conforme necessário.

`bash

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

mkdir ~/srccd ~/src

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

cd rede escura

compilação mkdir

compilação de CD

cmake -DCMAKEBUILDTYPE=Liberar ..

faça o pacote -j4

sudo dpkg -i darknet-VERSION.deb

`

Se estiver usando uma versão mais antiga do CMake, você precisará atualizar o CMake para executar o comando cmake acima. A atualização do CMake no Ubuntu pode ser feita com o seguinte comando:

`bash

sudo apt-get purge cmake

sudo snap install cmake --classic

`

Se você estiver usando o bash como shell de comando, será necessário reiniciá-lo neste momento. Se você estiver usando fish, ele deverá seguir o novo caminho imediatamente.

Usuários avançados:

Se você deseja construir um arquivo de instalação RPM em vez de um arquivo DEB, consulte as linhas relevantes em CM_package.cmake. Antes de executar make -j4 package você precisa editar estas duas linhas:

`bash

SET (CPACKGENERATOR "DEB")#SET (CPACKGENERATOR "RPM")

`

Para distribuições como Centos e OpenSUSE, você precisa mudar essas duas linhas em CM_package.cmake para:

`bash

DEFINIR (CPACK_GENERATOR "DEB")

DEFINIR (CPACK_GENERATOR "RPM")

`

Para instalar um pacote, use o gerenciador de pacotes normal da sua distribuição após a conclusão da construção. Por exemplo, em um sistema baseado em Debian como o Ubuntu:

`bash

sudo dpkg -i darknet-2.0.1-Linux.deb

`

A instalação do pacote .deb copiará os seguintes arquivos:

1. /usr/bin/darknet é o arquivo executável normal do Darknet. Execute a versão darknet da CLI para confirmar se ela está instalada corretamente.

2. /usr/include/darknet.h é a API Darknet para desenvolvedores C, C++ e Python.

3. /usr/include/darknet_version.h contém informações de versão para desenvolvedores.

4. /usr/lib/libdarknet.so é uma biblioteca para desenvolvedores C, C++ e Python vincularem.

5. /opt/darknet/cfg/... é onde todos os modelos .cfg são armazenados.

Você terminou agora! Darknet é construído e instalado em /usr/bin/. Execute o seguinte comando para testar: versão darknet.

Se você não tem /usr/bin/darknet, você não o instalou, apenas o construiu! Certifique-se de instalar o arquivo .deb ou .rpm conforme descrito acima.

Métodos CMake do Windows

Estas instruções pressupõem que você tenha uma instalação limpa do Windows 11 22H2.

Abra uma janela normal do prompt de comando cmd.exe e execute o seguinte comando:

`bash

winget instalar Git.Git

winget instalar Kitware.CMake

winget instalar nsis.nsis

instalar winget Microsoft.VisualStudio.2022.Community

`

Neste ponto, precisamos modificar a instalação do Visual Studio para incluir suporte para aplicativos C++:

1. Clique no menu Iniciar do Windows e execute o instalador do Visual Studio.

2. Clique em Editar.

3. Escolha o desenvolvimento de desktop usando C++.

4. Clique em Editar no canto inferior direito e clique em Sim.

Depois que tudo for baixado e instalado, clique no menu Iniciar do Windows novamente e selecione Prompt de comando do desenvolvedor para Visual Studio 2022. Não use o PowerShell para executar essas etapas, você terá problemas!

Usuários avançados:

Em vez de executar o prompt de comando do desenvolvedor, você pode fazer login no dispositivo usando um prompt de comando normal ou ssh e executar manualmente "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".

Depois de executar o prompt de comando do desenvolvedor conforme descrito acima (não o PowerShell!), Execute o seguinte comando para instalar o Microsoft VCPKG, que será usado para construir o OpenCV:

`bash

CDC:

mkdir c:srccd 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 com esta última etapa, pois pode levar muito tempo para ser executada. Requer baixar e construir muitas coisas.

Usuários avançados:

Observe que ao construir o OpenCV, pode ser necessário adicionar muitos outros módulos opcionais. Execute .vcpkg.exe e pesquise opencv para ver a lista completa.

Opcional: se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN neste momento. Se instalado, o Darknet usará sua GPU para acelerar o processamento de imagens (e vídeos).

Você deve excluir o arquivo CMakeCache.txt do diretório de construção Darknet para forçar o CMake a reencontrar todos os arquivos necessários.

Lembre-se de reconstruir o Darknet.

Darknet pode ser executado sem ele, mas se você quiser treinar uma rede personalizada, precisará de CUDA ou CUDA+cuDNN.

Visite https://developer.nvidia.com/cuda-downloads para baixar e instalar o CUDA.

Visite https://developer.nvidia.com/rdp/cudnn-download ou https://docs.nvidia.com/deeplearning/cudnn/install-guide/index.html#download-windows para baixar e instalar o cuDNN.

Depois de instalar o CUDA, certifique-se de executar nvcc.exe e nvidia-smi.exe. Pode ser necessário modificar a variável PATH.

Depois de baixar o cuDNN, descompacte e copie os diretórios bin, include e lib para C:/Arquivos de Programas/NVIDIA GPU Computing Toolkit/CUDA/[versão]/. Pode ser necessário substituir alguns arquivos.

Se você instalou CUDA ou CUDA+cuDNN posteriormente, ou se atualizou para uma versão mais recente do software NVIDIA:

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

Depois que todas as etapas anteriores forem concluídas com sucesso, você precisará clonar o Darknet e construí-lo. Nesta etapa também precisamos informar ao CMake onde o vcpkg está localizado para que ele possa encontrar o OpenCV e outras dependências:

`bash

cd c:src

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

cd rede escura

compilação mkdir

compilação de CD

cmake -DCMAKEBUILDTYPE=Liberar -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..

msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln

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

`

Se você receber um erro sobre uma DLL CUDA ou cuDNN ausente (por exemplo, cublas64_12.dll), copie manualmente o arquivo 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

`

(Este é um exemplo! Verifique se você está executando a versão e execute o comando apropriado para a versão que você instalou.)

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

`bash

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

`

Usuários avançados:

Observe que a saída do comando cmake é o arquivo de solução normal do Visual Studio Darknet.sln. Se você for um desenvolvedor de software que usa frequentemente a GUI do Visual Studio em vez de msbuild.exe para criar projetos, poderá ignorar a linha de comando e carregar o projeto Darknet no Visual Studio.

Agora você deve ter este arquivo pronto para ser executado: C: srcDarknetbuildsrc-cliReleasedarknet.exe. Execute o seguinte comando para testar: Versão C:srcDarknetbuildsrc-cliReleasedarknet.exe.

Para instalar corretamente Darknet, bibliotecas, incluir arquivos e DLLs necessárias, execute o assistente de instalação NSIS criado na etapa anterior. Verifique 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á:

1. Crie um diretório chamado Darknet, por exemplo C:Program FilesDarknet.

2. Instale o aplicativo CLI, darknet.exe e outros aplicativos de amostra.

3. Instale os arquivos .dll de terceiros necessários, como os do OpenCV.

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

5. Instale o arquivo .cfg do modelo.

Você terminou agora! Após a conclusão do assistente de instalação, Darknet será instalado em C:Program FilesDarknet. Execute o seguinte comando para testar: Versão C:Program FilesDarknetbindarknet.exe.

Se você não possui C:/Program Files/darknet/bin/darknet.exe, você não o instalou, apenas o construiu! Certifique-se de concluir cada painel do Assistente de Instalação NSIS conforme descrito na etapa anterior.

Usando Darknet

CLI

A seguir não está uma lista completa de todos os comandos suportados pelo Darknet.

Além da CLI Darknet, observe também a CLI do projeto DarkHelp, que fornece uma CLI alternativa para Darknet/YOLO. DarkHelp CLI também possui algumas melhorias não encontradas no Darknet. Você pode usar Darknet CLI e DarkHelp CLI juntos, eles não são mutuamente exclusivos.

Para a maioria dos comandos mostrados abaixo, você precisa de um arquivo .weights com os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar redes neurais que outros treinaram e estão disponíveis gratuitamente na Internet. Exemplos de conjuntos de dados de pré-treinamento incluem:

1. LEGO Gears (encontre objetos nas imagens)

2. Rolodex (encontre texto na imagem)

3. MSCOCO (detecção de alvo padrão de 80 categorias)

Os comandos a serem executados incluem:

Liste alguns comandos e opções possíveis que podem ser executados:

`bash

ajuda darknet

`

Verifique a versão:

`bash

versão darknet

`

Use imagens para fazer previsões:

`bash

V2

teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg

V3

darknet02displayannotatedimages cars.cfg image1.jpg

DarkHelp

DarkHelp carros.cfg carros.cfg carros_best.weights image1.jpg

`

Coordenadas de saída:

`bash

V2

teste de detector darknet animais.dados animais.cfg animaisbest.weights -extoutput dog.jpg

V3

darknet01inference_images animais cachorro.jpg

DarkHelp

DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg

`

Processando vídeo:

`bash

V2

demonstração do detector darknet animais.dados animais.cfg animaisbest.weights -extoutput test.mp4

V3

darknet03display_videos animais.cfg teste.mp4

DarkHelp

DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4

`

Lendo da webcam:

`bash

V2

Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0

V3

darknet08display_webcam animais

`

Salve os resultados no vídeo:

`bash

V2

demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test.mp4 -outfilename res.avi

V3

darknet05processvideosanimais multithread.cfg animais.nomes animais_best.teste de pesos.mp4

DarkHelp

DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4

`

JSON:

`bash

V2

demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput

V3

darknet06imagestojson animais imagem1.jpg

DarkHelp

DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg

`

Execute em uma GPU específica:

`bash

V2

demonstração do detector darknet animais.dados animais.cfg animais_best.weights -i 1 teste.mp4

`

Para verificar a precisão da rede neural:

`bash

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

Id Nome AvgPrecision TP FN FP TN Precisão ErrorRate Precisão Recall Especificidade FalsePosRate

------ ------------ ------ ------ ------ ------ -------- --------- --------- ------ ---------- ----------

0 veículo 91,2495 32648 3903 5826 65129 0,9095 0,0905 0,8486 0,8932 0,9179 0,0821

1 motocicleta 80,4499 2936 513 569 5393 0,8850 0,1150 0,8377 0,8513 0,9046 0,0954

2 bicicletas 89,0912 570 124 104 3548 0,9475 0,0525 0,8457 0,8213 0,9715 0,0285

3 pessoas 76,7937 7072 1727 2574 27523 0,8894 0,1106 0,7332 0,8037 0,9145 0,0855

4 muitos veículos 64,3089 1068 509 733 11288 0,9087 0,0913 0,5930 0,6772 0,9390 0,0610

5 luz verde 86,8118 1969 239 510 4116 0,8904 0,1096 0,7943 0,8918 0,8898 0,1102

6 luz amarela 82,0390 126 38 30 1239 0,9525 0,0475 0,8077 0,7683 0,9764 0,0236

7 luz vermelha 94,1033 3449 217 451 4643 0,9237 0,0763 0,8844 0,9408 0,9115 0,0885

`

Para verificar a precisão mAP@IoU=75:

`bash

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

`

O recálculo dos pontos de ancoragem é melhor feito no DarkMark, pois ele será executado 100 vezes seguidas e selecionará o melhor ponto de ancoragem de todos os pontos de ancoragem calculados. No entanto, se você deseja executar uma versão mais antiga no Darknet:

`bash

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

`

Treine uma nova rede:

`bash

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

`

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

trem

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

1. Como configuro meus arquivos e diretórios?

2. Qual perfil devo usar?

3. Quais comandos devo usar ao treinar minha própria rede?

A maneira mais fácil de criar todos os arquivos, anotações e treinamentos Darknet necessários usando DarkMark. Esta é definitivamente a forma recomendada para treinar novas redes neurais.

Se você quiser configurar manualmente os vários arquivos para treinar uma rede personalizada:

1. Crie uma nova pasta para armazenar os arquivos. Para este exemplo, você criará uma rede neural para detecção de animais, portanto será criado o seguinte diretório: ~/nn/animals/.

2. Copie um dos arquivos de configuração Darknet que deseja usar como modelo. Por exemplo, consulte cfg/yolov4-tiny.cfg. Coloque-o na pasta que você criou. Neste exemplo, agora temos ~/nn/animals/animals.cfg.

3. Crie um arquivo de texto Animals.names na mesma pasta onde você colocou o arquivo de configuração. Neste exemplo, agora temos ~/nn/animals/animals.names.

4. Use seu editor de texto para editar o arquivo pets.names. Liste as categorias que deseja usar. Você precisa de exatamente uma entrada por linha e nenhuma linha em branco ou comentários. Neste exemplo, o arquivo .names conterá exatamente 4 linhas:

`

cachorro

gato

pássaro

cavalo

`

5. Crie um arquivo de texto Animals.data na mesma pasta. Neste exemplo, o arquivo .data 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 para armazenar suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset. Cada imagem requer um arquivo .txt correspondente que descreve as anotações dessa imagem. O formato dos arquivos de comentários .txt é muito específico. Você não pode criar esses arquivos manualmente porque cada anotação precisa conter as coordenadas precisas da anotação. Consulte DarkMark ou outro software semelhante 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" nomeados no arquivo .data. Esses dois arquivos de texto precisam listar todas as imagens que Darknet deve usar para treinamento e validação (ao calcular o mAP%) respectivamente. Exatamente uma imagem por linha. Caminhos e nomes de arquivos podem ser relativos ou absolutos.

8. Use um editor de texto para modificar seu arquivo .cfg.

9. Certifique-se de lote=64.

10. Preste atenção às subdivisões. Dependendo do tamanho da rede e da quantidade de memória disponível na GPU, pode ser necessário aumentar as subdivisões. O melhor valor a ser usado é 1, então comece com 1. Se 1 não funcionar para você, consulte as perguntas frequentes do Darknet/YOLO.

11. Observe que maxbatches=.... Um bom valor para começar é 2.000 vezes o número de categorias. Neste exemplo temos 4 animais, então 4 * 2.000 = 8.000. Isso significa que usaremos maxbatches=8000.

12. Observe steps=.... Isso deve ser definido como 80% e 90% de maxbatches. Neste exemplo, como maxbatches está definido como 8.000, usaremos steps=6400,7200.

13. Observe que width=... e height=.... Estas são dimensões de rede. O FAQ Darknet/YOLO explica como calcular o tamanho ideal a ser usado.

14. Pesquise na seção [convolutional] todas as linhas classes=... antes da seção [yolo] e modifique-as com o número de classes do arquivo .names. Neste exemplo usaremos classes=4.

15. Pesquise todas as linhas filter=... na seção [convolutional] antes de cada seção [yolo]. O valor a ser usado é (número de categorias + 5) 3. Isso significa que neste exemplo, (4 + 5) 3 = 27. Portanto, usamos filtros=27 nas linhas apropriadas.

Comece a treinar! Execute o seguinte comando:

`bash

cd ~/nn/animais/

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

`

Por favor, aguarde. Os melhores pesos serão salvos como Animals_best.weights. Você pode observar o progresso do treinamento visualizando o arquivo chart.png. Consulte o FAQ Darknet/YOLO para parâmetros adicionais que você pode querer usar ao treinar uma nova rede.

Se quiser ver mais detalhes durante o treinamento, adicione o parâmetro --verbose. Por exemplo:

`bash

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

`

Outras ferramentas e links

Para gerenciar seu projeto Darknet/YOLO, anotar imagens, validar suas anotações e gerar os arquivos necessários para treinar com Darknet, consulte DarkMark.

Para uma CLI alternativa poderosa ao Darknet, para usar imagens lado a lado, rastreamento de objetos em seus vídeos ou para uma API C++ poderosa que pode ser facilmente usada em aplicativos comerciais, consulte DarkHelp.

Veja se o FAQ Darknet/YOLO pode ajudar a responder sua pergunta.

Confira os diversos tutoriais e vídeos de exemplo no canal de Stéphane no YouTube

Se você tiver alguma dúvida de suporte ou quiser conversar com outros usuários Darknet/YOLO, entre no servidor Darknet/YOLO Discord.

roteiro

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

Concluído

1. Substitua qsort() usado durante o treinamento por std::sort()