Sistema de consulta de pontuação universal adaptativo inteligente Asp + Csv v20210730
20210730
Sistema de consulta de pontuação universal adaptativo inteligente Asp + Csv
Hoje, o editor de Downcodes apresentará a vocês um sistema de consulta desenvolvido e publicado baseado em ASP para consultar dados em formato csv que se adapta de forma inteligente ao sistema de consulta de pontuação universal.
Este software é extremamente simples, mas é um sistema de consulta de pontuação muito versátil e conveniente que pode ser usado para consultar quase todas as tabelas de dados unidimensionais e bidimensionais do Excel.
Propósito
Este sistema é adequado para diversas consultas precisas, como notas, salários, contas de serviços públicos de propriedade, etc. que são modificadas com pouca frequência e têm baixa confidencialidade. Os cenários de uso específicos são os seguintes:
1. Sistema de consulta de pontuação: aplicável a todas as escolas, instituições educacionais, exames de instituições públicas, etc.
2. Sistema de consulta salarial: aplicável a todas as escolas, instituições de ensino, exames de instituições públicas, etc.
3. Sistema de consulta de taxas de propriedade: aplicável a todas as empresas, escolas e todas as unidades.
4. Sistema de consulta de contas de serviços públicos: adequado para comunidades, empresas imobiliárias, dormitórios universitários, etc.
5. Outros sistemas de consulta: como consulta de colocação em classe, consulta de admissão, consulta de certificado e outros sistemas de consulta com poucas modificações.
Recursos e vantagens
1. Alta versatilidade: pode ser usado em quase todas as tabelas bidimensionais e pode atender à maioria das suas necessidades.
2. Simples e conveniente: o código é pequeno e simples e pode ser modificado rapidamente para se adequar a vários cenários, como consulta conjunta de várias tabelas.
3. Flexível e fácil de usar: basta modificar alguns parâmetros para personalizar a consulta.
4. Uso rápido: A publicação de uma pontuação pode ser resolvida em dois a três minutos, no máximo.
Limitações
1. Não é adequado para modificações frequentes: Resultados, salários, contas de água e luz, etc. geralmente são divulgados de uma só vez, sem modificações. Este sistema não é adequado para cenários onde as modificações são frequentes.
2. Adequado apenas para tabelas bidimensionais: Geralmente, os bancos de dados adotam uma estrutura bidimensional, com cabeçalhos na primeira linha e nas linhas, e um dado por linha posteriormente. Este sistema atualmente não suporta dados em outras estruturas.
3. Controle recomendado do número de registros em um único banco de dados: Este sistema não limita o número de registros em um único banco de dados, mas é recomendado que o número de registros em um único banco de dados seja controlado dentro de 30.000, e os bancos de dados podem ser divididos em bancos de dados sem afetar uns aos outros.
4. Fórmulas, imagens, URLs, etc. não são suportadas por enquanto: Este sistema não suporta fórmulas, imagens, URLs, etc.
Sugestões de uso
Ele pode ser usado diretamente por upload via FTP. Recomenda-se fazer upload diretamente para teste de consulta primeiro.
Acesso front-end: http://website/directory/ (upload para uso direto sem suporte de banco de dados mysql, etc.)
Em seguida, use o notepad++ para abrir inc/conn.Asp para visualizar o relacionamento correspondente entre parâmetros e páginas da web e, em seguida, abra o banco de dados integrado padrão para comparar os resultados da consulta e visualizar o relacionamento correspondente.
Etapas de uso
Para obter detalhes, consulte o arquivo em formato HTML no pacote compactado.
Exemplo
A seguir, tomamos Darknet Object Detection Framework e YOLO como exemplo para mostrar como usar o elemento de tag de título do Markdown e alguns ajustes de layout para tornar a exibição das informações mais organizada e conveniente para a leitura dos usuários:
Estrutura de detecção de objetos Darknet e YOLO
Logotipos !darknet e hank.ai
Darknet é uma estrutura de rede neural de código aberto escrita em C, C++ e CUDA.
YOLO (You Only Look Once) é um sistema de detecção de objetos em tempo real de última geração executado na estrutura Darknet.
Artigos
Artigo YOLOv7
Papel em escala-YOLOv4
Artigo YOLOv4
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 usar 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ídeos de conjuntos 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 para ser lido, redimensionado e processado pelo Darknet. /YOLO em segundos.
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. Por favor, 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.
O próximo repositório Darknet popular mantido por Alexey Bochkovskiy de 2017-2021 também não possui um número de versão. Acreditamos que esta seja a versão 1.x.
O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette a partir de 2023 é o primeiro 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 enquanto tenta quebrar o mínimo possível de funcionalidades existentes.
Reescrevemos as etapas de construção para que tenhamos uma abordagem unificada para construção em Windows e Linux usando CMake.
Converta a base de código para usar um compilador C++.
Chart.png aprimorado durante o treinamento.
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 desta 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, com lançamento 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. Se precisar de ajuda, informe-nos para que possamos investigar a adição de comandos ausentes.
Muitos comandos antigos e não mantidos foram removidos.
Muitas otimizações de desempenho foram feitas, inclusive durante treinamento e inferência.
A antiga API C foi modificada; os aplicativos que usam a API Darknet original exigirão pequenas modificações: https://darknetcv.ai/api/api.html
Nova API Darknet V3 C e C++: https://darknetcv.ai/api/api.html
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. Consulte as perguntas frequentes do Darknet/YOLO para obter detalhes.
Os pesos pré-treinados do MSCOCO podem ser baixados de vários locais diferentes ou deste repositório:
YOLOv2, novembro de 2016
*YOLOv2-tiny
*YOLOv2-completo
YOLOv3, maio de 2018
* YOLOv3-tiny
*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 apenas para fins de demonstração. Os arquivos .cfg e .names correspondentes para MSCOCO estão localizados no diretório cfg. Comando 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
`
Observe que deve-se treinar sua própria rede. O MSCOCO geralmente é usado para confirmar se tudo está funcionando corretamente.
Prédio
Vários métodos de construção fornecidos no passado (antes de 2023) foram mesclados em uma solução unificada. Darknet requer C++17 ou mais recente, OpenCV, e usa CMake para gerar os arquivos de projeto necessários.
Você não precisa saber C++ para construir, instalar ou executar Darknet/YOLO, assim como não precisa ser mecânico para dirigir um carro.
Google Colab
As instruções para o Google Colab são as mesmas do Linux. Existem vários notebooks Jupyter disponíveis que mostram como realizar determinadas tarefas, como treinar uma nova rede.
Consulte o notebook no subdiretório colab ou siga as instruções do Linux abaixo.
Método Linux CMake
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).
Obrigatório: 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.
Obrigatório: Lembre-se de reconstruir o Darknet.
Darknet pode funcionar sem ele, mas se você quiser treinar uma rede personalizada, é necessário 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 que o CUDA estiver instalado, certifique-se de executar o nvcc e o nvidia-smi. Pode ser necessário modificar sua variável PATH.
Se você instalou CUDA ou CUDA+cuDNN posteriormente ou atualizou para uma versão mais recente do software NVIDIA:
Estas instruções pressupõem (mas não necessariamente exigem!) que o sistema esteja executando o Ubuntu 22.04. Se você estiver usando outra distribuição, ajuste conforme necessário.
`
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 buildcd
cmake -DCMAKEBUILDTYPE=Liberar ..
faça -j4
pacote
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. Para atualizar o CMake no Ubuntu você pode usar o seguinte comando:
`
sudo apt-get purge cmake
sudo snap install cmake --classic
`
Se você usar bash como shell de comando, pode ser necessário reiniciá-lo. Se você usar peixe, 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 o pacote make -j4, você precisa editar estas duas linhas:
`
SET (CPACKGENERATOR "DEB")#SET (CPACKGENERATOR "RPM")
`
Para distribuições como Centos e OpenSUSE, você precisa alterar essas duas linhas em CM_package.cmake para:
`
SET (CPACKGENERATOR "DEB")SET (CPACKGENERATOR "RPM")
`
Para instalar o pacote de instalação, uma vez compilado, use o gerenciador de pacotes usual da sua distribuição. Por exemplo, em um sistema baseado em Debian (como Ubuntu):
`
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 usual. Execute a versão darknet da CLI para confirmar se ela está instalada corretamente.
/usr/include/darknet.h é a API Darknet para desenvolvedores C, C++ e Python.
/usr/include/darknet_version.h contém informações de versão para desenvolvedores.
/usr/lib/libdarknet.so é uma biblioteca para desenvolvedores C, C++ e Python vincularem.
/opt/darknet/cfg/... é onde todos os modelos .cfg são armazenados.
Agora você terminou! Darknet foi construído e instalado em /usr/bin/. Execute o seguinte comando para testar: versão darknet.
Se você não tem /usr/bin/darknet, isso significa que você não o instalou, apenas o construiu! Certifique-se de instalar o arquivo .deb ou .rpm conforme descrito acima.
Método 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:
`
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++:
* 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 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 VS 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 usar um prompt de comando normal ou ssh no dispositivo e executar manualmente "Arquivos de programasMicrosoft Visual Studio2022CommunityCommon7ToolsVsDevCmd.bat".
Depois de seguir as instruções acima e executar o prompt de comando do desenvolvedor (não o PowerShell!), execute o seguinte comando para instalar o Microsoft VCPKG, que será usado para construir o OpenCV:
`
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
`
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 existem muitos outros módulos opcionais que você pode querer adicionar ao construir o OpenCV. 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).
Obrigatório: 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.
Obrigatório: Lembre-se de reconstruir o Darknet.
Darknet pode funcionar sem ele, mas se você quiser treinar uma rede personalizada, é necessário 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 que o CUDA estiver instalado, certifique-se de executar nvcc.exe e nvidia-smi.exe. Pode ser necessário modificar sua 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 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:
`
cd c:src
clone git https://github.com/hank-ai/darknet.gitcd darknetmkdir buildcd build
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 erros sobre algumas DLLs CUDA ou cuDNN ausentes, como cublas64_12.dll, copie manualmente o arquivo CUDA .dll no mesmo diretório de saída que Darknet.exe. Por exemplo:
`
copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
`
(Este é um exemplo! Verifique qual versão você está executando e execute o comando apropriado para a versão que você instalou.)
Depois que os arquivos forem copiados, execute novamente o último comando msbuild.exe para gerar o pacote de instalação do NSIS:
`
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ê 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 que pode ser executado: C: srcDarknetbuildsrc-cliReleasedarknet.exe. Execute o seguinte comando para testar: Versão C:srcDarknetbuildsrc-cliReleasedarknet.exe.
Para instalar corretamente o Darknet, bibliotecas, incluir arquivos e DLLs necessárias, execute o assistente de instalação NSIS criado na última etapa. Veja o arquivo darknet-VERSION.exe no diretório de construção. Por exemplo:
`
darknet-2.0.31-win64.exe
`
A instalação do pacote de instalação 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 o arquivo .cfg do modelo.
Agora você terminou! Assim que o assistente de instalação for concluído, 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, isso significa que você não o instalou, apenas o construiu! Certifique-se de passar por cada painel do assistente de instalação do 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 alguns recursos avançados não disponíveis diretamente 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ê precisará usar o arquivo .weights para os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar redes neurais da Internet que foram treinadas por outros e estão disponíveis gratuitamente. Exemplos de conjuntos de dados de pré-treinamento incluem:
LEGO Gears (encontre objetos nas imagens)
Rolodex (encontrar texto na imagem)
MSCOCO (detecção de alvo padrão de 80 categorias)
Os comandos a serem executados incluem:
Liste alguns comandos e opções que podem ser executados:
`
ajuda darknet
`
Verifique a versão:
`
versão darknet
`
Use imagens para fazer previsões:
`
V2: teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg
V3: darknet02displayannotatedimages cars.cfg image1.jpg
DarkHelp: DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg
`
Coordenadas de saída:
`
V2: teste de detector darknet Animals.data Animals.cfg Animalsbest.weights -extoutput dog.jpg
V3: darknet01inference_images animais cachorro.jpg
DarkHelp: DarkHelp --json animais.cfg animais.nomes animais_best.pesos cachorro.jpg
`
Usar vídeo:
`
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:
`
V2: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
V3: animais darknet08display_webcam
`
Salve os resultados no vídeo:
`
V2: demonstração do detector darknet animais.dados animais.cfg animaismelhores.pesos teste.mp4 -outfilename res.avi
V3: darknet05processvideosanimais multithreaded.cfg animais.nomes animais_best.teste de pesos.mp4
DarkHelp: DarkHelp animais.cfg animais.nomes animais_best.pesos teste.mp4
`
JSON:
`
V2: demonstração do detector darknet animais.dados animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput
V3: darknet06imagestojson animais image1.jpg
DarkHelp: DarkHelp --json animais.nomes animais.cfg animais_best.pesos image1.jpg
`
Execute em GPU específica:
`
V2: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -i 1 test.mp4
`
Verifique a precisão da rede neural:
`
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
`
Verifique a precisão mAP@IoU=75:
`
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. Mas se você quiser rodar uma versão mais antiga no Darknet:
`
detector darknet calcanchors animais.data -numof_clusters 6 -largura 320 -altura 256
`
Treine uma nova rede:
`
detector darknet -map -dont_show trainanimais.dataanimais.cfg (veja também a seção de treinamento abaixo)
`
Treinamento
Link rápido para a seção relevante do FAQ Darknet/YOLO:
* Como configuro meus arquivos e diretórios?
*Qual perfil devo usar?
* Quais comandos devo usar ao treinar minha própria rede?
Use DarkMark para criar todos os arquivos Darknet necessários, que é a maneira mais fácil de anotar e treinar. 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. Neste exemplo será criada uma rede neural para detectar animais, então 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. Na mesma pasta onde você colocou o arquivo de configuração, crie um arquivo de texto Animals.names. Neste caso, agora temos ~/nn/animals/animals.names.
4. Use um editor de texto para editar o arquivo pets.names. Liste as categorias que deseja usar. Você precisa ter exatamente uma entrada por linha, sem linhas em branco e sem 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/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 armazenar suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset. Cada imagem requer um arquivo .txt correspondente com anotações que descrevem essa 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 exatas da anotação. Consulte DarkMark ou outro software semelhante para anotar 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. Há 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.
* Certifique-se de lote=64.
* Preste atenção às subdivisões. Dependendo das dimensões da rede e da quantidade de memória disponível na sua GPU, pode ser necessário aumentar as subdivisões. O melhor valor a ser usado é 1, então comece com ele. Se 1 não funcionar para você, consulte as perguntas frequentes do Darknet/YOLO.
Observe que maxbatches=…. No início, um bom valor é 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.
* Nota passos =..... Isso deve ser definido como 80% e 90% de maxbatches. Neste exemplo, usaremos steps=6400,7200 já que maxbatches está definido como 8000.
* Preste atenção em largura=... e altura=..... Estas são dimensões de rede. O FAQ Darknet/YOLO explica como calcular o tamanho ideal a ser usado.
* Procure todas as instâncias que contenham a linha classes=... e modifique-as com o número de classes em seu arquivo .names. Neste exemplo usaremos classes=4.
Na seção [convolutional] antes de cada seção [yolo], procure todas as instâncias que contenham a linha filter=... . O valor a ser usado é (número de categorias + 5) 3. Isso significa, neste caso, (4 + 5) * 3 = 27. Portanto, usaremos filter=27 nas linhas apropriadas.
9. Comece a treinar! Execute o seguinte comando:
`
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:
`
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 treinamento com Darknet, consulte DarkMark.
Para obter uma CLI alternativa Darknet robusta para usar imagens lado a lado para rastreamento de objetos em vídeo ou para uma API C++ robusta que pode ser facilmente usada em aplicativos comerciais, consulte DarkHelp.
Por favor, verifique o FAQ Darknet/YOLO e veja se isso ajuda a responder sua pergunta.
Assista aos vários tutoriais e vídeos de exemplo no canal de Stéphane no YouTube.
Se você tiver dúvidas 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
Substituído qsort() usado durante o treinamento por std::sort() (alguns outros menos comuns ainda existem)
Remova check_mistakes, getchar() e system()
Converta Darknet para usar um compilador C++ (g++ no Linux, Visual Studio no Windows)
Corrigir compilação do Windows
Corrigir suporte a Python
Construir biblioteca darknet
Reativar rótulos em previsões (código "alfabeto")
Reativar código CUDA/GPU
Reativar CUDNN
Reative a metade CUDNN
Não codifique a arquitetura CUDA
Melhores informações sobre a versão CUDA
Reativar AVX
Remova a solução antiga e o Makefile
Torne o OpenCV não opcional
Remova a dependência da antiga biblioteca pthread
Excluir STB
Reescreva CMakeLists.txt 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
Construa além do código-fonte
Tem melhor saída de número de versão
Otimizações de desempenho relacionadas ao treinamento (tarefas em andamento)
Otimizações de desempenho relacionadas à inferência (tarefas em andamento)
Use referências por valor sempre que possível
Limpe arquivos .hpp
Reescrever darknet.h
Não converta cv::Mat para void, em vez disso use-o como um objeto C++ adequado
Corrija ou mantenha estruturas de imagem internas usadas de forma consistente
Corrigir compilação para dispositivos Jetson baseados em ARM
* Como a NVIDIA não suporta mais dispositivos Jetson originais, é improvável que eles sejam corrigidos (sem compilador C++17)
* Novo dispositivo Jetson Orin agora em execução
Corrigir API Python na V3
É necessário melhor suporte para Python (algum desenvolvedor de Python quer ajudar com isso?)
metas de curto prazo
Substitua printf() por std::cout (trabalho em andamento)
Confira o suporte para câmeras Zed antigas
Análise de linha de comando melhor e mais consistente (trabalho em andamento)
metas de médio prazo
Remova todos os códigos de caracteres e substitua por std::string
Não esconda avisos, limpe os avisos do compilador (trabalho em andamento)
Melhor usar cv::Mat em vez de estruturas de imagem personalizadas em C (trabalho em andamento)
Substitua funções de lista antigas por std::vector ou std::list
Correção do suporte para imagens em tons de cinza de 1 canal
Adicionado suporte para imagens de canal N onde N > 3 (por exemplo, imagens com profundidade adicional ou canais térmicos)
Limpeza de código contínua (em andamento)
objetivos de longo prazo
Corrija problemas de CUDA/CUDNN para todas as GPUs
Reescreva o código CUDA + cuDNN
Considere adicionar suporte para GPUs não NVIDIA
Caixa delimitadora girada ou alguma forma de suporte de "ângulo"
pontos-chave/esqueleto
Mapa de calor (trabalho em andamento)
segmentação
No exemplo, o elemento de tag de título Markdown é usado e algum conteúdo é logicamente complementado, polido e ajustado na composição. Por exemplo, adicionar números de série chineses, serialização de algarismos arábicos, quebras de linha e outras formatações pode tornar a exibição das informações mais ordenada e mais conveniente para os usuários verificarem.
Espero que este artigo possa ser útil para todos!
