esquemaorg
Release
Bem-vindo ao Schema.org
Este é o repositório do projeto Schema.org. Ele contém todos os esquemas, exemplos e software usados para publicar o schema.org. Para o site em si, consulte Schema.org.
Nota: Grande parte do software de suporte é importado de um submódulo: 'sdopythonapp'
Questões e propostas são gerenciadas aqui por colaboradores do projeto, especialmente participantes do Grupo Comunitário W3C Schema.org. Se você estiver interessado em participar, junte-se ao grupo do W3C, apresente-se e encontre ou registre aqui questões que despertem seu interesse. Se você é novo no Git e no GitHub, há uma introdução útil ao GitHub no W3C Wiki.
Existem também testes de integração contínua para verificar solicitações pull recebidas.
O problema nº 1 no GitHub é um ponto de entrada para o planejamento de lançamento. Deve fornecer uma visão geral do trabalho futuro, em termos de temas gerais, questões específicas e marcos de lançamento. O problema nº 1 será vinculado a pontos de entrada por versão ou navegará pelos problemas por meio de rótulo ou marco no GitHub.
Cada mudança no site ocorre por meio de discussões aqui. Mudanças substanciais estão registradas em nossas notas de lançamento. Uma prévia do rascunho das novas notas de lançamento pode ser encontrada como parte do site de teste do nosso próximo lançamento. Aproximadamente a cada mês, após a revisão final pelo Grupo Diretor do Schema.org e pela comunidade em geral, fazemos um lançamento formal.
Com relação às licenças CC e de código aberto para documentos e software, consulte nossa seção de perguntas frequentes.
Estamos sempre interessados em sugestões práticas para melhorias no schema.org, e nossa coleção de esquemas tem crescido gradualmente desde o nosso lançamento em 2011. Tentamos priorizar correções simples e melhorias em nossos esquemas, exemplos e documentação existentes em vez da adição de novos vocabulário, e é mais provável que adicionemos novos esquemas quando houver evidências de que algum aplicativo consumidor (de preferência em grande escala) fará uso dos dados. Os aplicativos consumidores não precisam ser mecanismos de pesquisa; ferramentas de software (por exemplo, abordagens de código aberto e enriquecidas com marcação para análise da Web, complementos de navegador ou ferramentas de nuvem) são áreas ricas para exploração e colaboração. O importante é que haja alguma expectativa razoável de que os consumidores de dados façam bom uso das mudanças. Não é suficiente justificar acréscimos com base no fato de que os mecanismos de pesquisa geralmente tentam usar dados estruturados baseados em Schema.org. Mudanças menores e alterações compatíveis com versões anteriores são mais fáceis de incorporar.
Nota: Schema.org não tenta capturar todos os detalhes do conteúdo da Web; é necessariamente uma simplificação de uma realidade mais complexa. Isso significa que haverá muitos casos em que será possível adicionar mais detalhes ao Schema.org. No entanto, no interesse de manter o Schema.org simples e utilizável para editores e webmasters, muitas vezes optaremos por não adicionar tais detalhes.
Schema.org usa padrões da Web como JSON-LD, Microdata e RDFa para permitir extensão independente (por exemplo, consulte o vocabulário do GS1).
Também é altamente improvável que assumamos reorganizações em grande escala da terminologia do Schema.org, se elas forem motivadas apenas por considerações de elegância, "modelagem adequada", pureza ontológica ou unificação conceitual. Embora os fundadores e a equipe do projeto estejam familiarizados - e respeitem - as tradições por trás de tais preocupações, a escala, o escopo e a natureza do Schema.org exigiram que trocássemos elegância e consistência global por uma noção um tanto mais desleixada de evolução incremental e uma abordagem pragmática. tolerância para um estilo que estaria fora de lugar em uma ontologia formal. Propostas para unificar estruturas de conhecimento baseadas em lógica entre domínios podem ser melhor recebidas, por exemplo, na comunidade Ontolog.
Às vezes, introduzimos tipos sem associações de propriedades dedicadas, simplesmente por motivos de usabilidade de marcação. Em uma ontologia formal, isso é frequentemente considerado uma modelagem deficiente. No entanto, estruturas logicamente equivalentes podem resultar em muito mais erros por parte de editores/webmasters não familiarizados com os conceitos formais subjacentes ao JSON-LD ou RDF/S.
Schema.org não é um sistema fechado, e outras iniciativas (por exemplo, Wikidata ou GS1) definiram muitos outros termos que podem ser misturados com aqueles que definimos em schema.org. Também nos esforçamos para alinhar nossos projetos a padrões e iniciativas externas relevantes, mesmo quando isso reduz a elegância global do Schema.org considerado isoladamente. Por exemplo, num contexto de património bibliográfico ou cultural, podemos ser influenciados por iniciativas como MARC, BibFrame e FRBR, enquanto para o comércio eletrónico colaboramos com Good Relationships e GS1. Os termos relacionados a notícias do Schema.org foram fortemente influenciados pela incorporação do design rNews do IPTC, juntamente com colaborações com verificadores de fatos, o Trust Project e outros. Nossos vocabulários relacionados à TV e à Música são fortemente influenciados pelo trabalho com a BBC e a European Broadcasting Union, juntamente com a ontologia Music e o MusicBrainz; nossos esquemas refletem esses designs anteriores. Preferimos colaborar desta forma, melhorando o Schema.org de forma incremental e trabalhando para aperfeiçoar, integrar e combinar esses designs, em vez de produzir nosso próprio modelo puro isoladamente. O resultado pode carecer de elegância global, mas alinha o nosso trabalho com os esforços relacionados em todo o mundo.
Sempre acolhemos bem questões que rastreiem problemas de usabilidade e legibilidade, mas incentivamos o foco em situações concretas (por exemplo, como descrever eventos repetidos) em vez de preocupações filosóficas globais (por exemplo, se uma Reserva ou Ação é "realmente" um Evento). Priorizamos a coerência local (ter formas sensatas de descrever muitas situações comuns) em detrimento da elegância global (ter uma teoria global em que tudo tem um lugar sensato). Isso não significa que nunca fazemos limpezas, mas elas são equilibradas (e muitas vezes superadas) por outras considerações.
Quando adicionamos termos, muitas vezes na área “Pendente”, incentivamos fortemente o feedback que tenha uma perspectiva global: como um novo termo se relaciona com outros, como poderia ser usado juntamente com padrões pré-existentes, etc. esta fase de integração reflecte tais considerações, mas são normalmente expressas através de modestas reformulações, exemplos ou ajustes na documentação das ligações tipo/propriedade, em vez de através de grandes reestruturações.
Veja mais em "Como trabalhamos"
Para a maioria dos colaboradores, tudo o que você precisa saber sobre o software é como executá-lo. O objetivo do software é criar uma cópia estática do site Schema.org, incluindo possíveis alterações locais, para inspecionar e executar atrás de um servidor web simples em um sistema local para teste. Da mesma forma que uma versão de produção é implantada em um servidor em nuvem, sua versão local pode então ser implantada em uma máquina virtual usando gcloud para permitir a colaboração com outras pessoas.
Instruções completas estão disponíveis em SOFTWARE_README.md explicando como criar a cópia local inicial para trabalhar e depois evoluir para testar quaisquer alterações. Essencialmente, você precisará ter um ambiente semelhante ao Linux (incluindo Mac) carregado com Python versão 3.6 ou superior. Você pode então tornar compilações de teste do schema.org em execução em sua própria máquina acessíveis como http://localhost:8080/ ou publicá-las em appspot.com para colaboração. Consulte a documentação do Appengine para obter detalhes sobre os comandos gcloud relevantes.
Informações mais detalhadas sobre o software e seu uso estão disponíveis em SOFTWARE_README.md. Veja também as notas no wiki: https://github.com/schemaorg/schemaorg/wiki/Contributing
Todos os esquemas e exemplos estão em dados/em arquivos codificados em utf-8.
O arquivo de esquemas principal é data/schema.ttl (utf-8).
Ao desenvolver esquemas, usar data/sdo-somethinghere-schema.ttl pode ser útil.
O formato é baseado em RDFS W3C no formato RDF/Turtle.
Os exemplos são armazenados em data/examples.txt (utf-8) e outros arquivos .txt.
Tal como acontece com os esquemas, data/examples.txt também será lido. Pode ser útil desenvolver usando arquivos separados.
Quando o vocabulário estiver finalmente integrado ao repositório principal, os dados do esquema serão mesclados no schema.org. No entanto, os exemplos permanecerão em arquivos separados, pois isso funciona melhor com o mecanismo de comparação de arquivos do git.
A hierarquia data/releases/ é reservada para instantâneos de lançamento (consulte https://schema.org/version/).
A hierarquia ext// é reservada para extensões (consulte https://schema.org/docs/extension.html).
Não usamos mais ramificações do GitHub para trabalhos em andamento. O branch main/ é nosso mais recente candidato. Não é garantido que esteja em um estado conceitualmente consistente, mas deve estabilizar antes da circulação de um candidato a lançamento para revisão.
Esta documentação diz respeito à base de código do software e não ao próprio schema.org. No entanto, observe que rótulos, comentários e documentação devem usar o inglês dos EUA (no código e nos esquemas), se for necessária uma escolha entre variantes em inglês. Por favor, busque o inglês internacional sempre que possível.
Veja também: https://twitter.com/schemaorg_dev
Exemplo:
`
Licença Apache-2.0
Índice
Estrutura de detecção de objetos Darknet e YOLO
Artigos
Informações gerais
Versão Darknet
Pesos pré-treinados MSCOCO
Prédio
Google Colab
Método Linux CMake
Método CMake do Windows
Usando Darknet
CLI
Treinamento
Outras ferramentas e links
Roteiro
Metas de curto prazo
Metas de médio prazo
Metas de longo prazo
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 de última geração em tempo real, executado na 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
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 do YOLO.
Esta estrutura é totalmente gratuita e de código aberto. Você pode incorporar Darknet/YOLO em projetos e produtos existentes – inclusive comerciais – sem licença ou pagamento de taxa.
Darknet V3 ("Jazz") lançado em outubro de 2024 pode executar com precisão os vídeos do conjunto de dados LEGO em até 1000 FPS ao usar uma GPU NVIDIA RTX 3090, o que significa que cada quadro de vídeo é lido, redimensionado e processado por Darknet/YOLO em 1 milissegundo ou menos.
Por favor, junte-se ao servidor Darknet/YOLO Discord se precisar de ajuda ou quiser discutir Darknet/YOLO: 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 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.
Reescrevemos as etapas de construção para que tenhamos uma maneira unificada de construir usando CMake no Windows e no Linux.
Converteu a base de código para usar o 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 uma 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ç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. 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, tanto durante o treinamento quanto durante a inferência.
A API C legada foi modificada; aplicativos que usam a API Darknet original precisarão de 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
Várias versões populares do YOLO foram pré-treinadas por conveniência no conjunto de dados MSCOCO. Este conjunto de dados possui 80 classes, que podem ser vistas 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 e também estão disponíveis para download neste 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
Observe que se espera que as pessoas treinem suas próprias redes. MSCOCO normalmente é usado 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, da mesma forma que não precisa ser mecânico para dirigir um carro.
Google Colab
Linux
Windows
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 mostrando como realizar determinadas 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
Opcional: se você tiver uma GPU NVIDIA moderna, poderá instalar CUDA ou CUDA+cuDNN neste momento. Se instalado, o Darknet usará sua GPU para acelerar o processamento de imagens (e vídeos).
Você deve excluir o arquivo CMakeCache.txt do diretório de construção Darknet para forçar o CMake a reencontrar todos os arquivos necessários.
Lembre-se de reconstruir o Darknet.
Darknet pode funcionar sem ele, mas se você quiser treinar uma rede personalizada, será necessário CUDA ou CUDA+cuDNN.
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. Talvez seja necessário modificar sua variável PATH.
Se você instalar CUDA ou CUDA+cuDNN posteriormente ou atualizar para uma versão mais recente do software NVIDIA:
Estas instruções assumem (mas não exigem!) um sistema rodando Ubuntu 22.04. Adapte conforme necessário se estiver usando uma distribuição diferente.
sudo apt-get install build-essential git libopencv-dev cmake mkdir ~/srccd ~/src git clone https://github.com/hank-ai/darknetcd darknet mkdir buildcd build cmake -DCMAKEBUILDTYPE=Release .. make -j4 package sudo dpkg -i darknet-VERSION.deb
Se você estiver usando uma versão mais antiga do CMake, precisará atualizar o CMake antes de executar o comando cmake acima. A atualização do CMake no Ubuntu pode ser feita com os seguintes comandos:
sudo apt-get purge cmake sudo snap install cmake --classic
Se estiver usando o bash como seu shell de comando, você desejará reiniciá-lo neste momento. Se estiver usando peixe, ele deve seguir imediatamente o novo caminho.
Usuários avançados:
Se você 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ê precisará editar estas duas linhas:
SET (CPACKGENERATOR "DEB")#SET (CPACKGENERATOR "RPM")
Para distros como Centos e OpenSUSE, você precisará mudar essas duas linhas em CM_package.cmake para serem:
SET (CPACKGENERATOR "DEB")SET (CPACKGENERATOR "RPM")
Para instalar o pacote de instalação após a conclusão da construção, use o gerenciador de pacotes usual para sua distribuição. Por exemplo, em sistemas baseados 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 é a biblioteca de link para desenvolvedores C, C++ e Python.
/opt/darknet/cfg/... é onde todos os modelos .cfg são armazenados.
Agora você terminou! Darknet foi construído e instalado em /usr/bin/. Execute isto para testar: versão darknet.
Se você não tem /usr/bin/darknet então 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 uma nova instalação do Windows 11 22H2.
Abra uma janela normal do prompt de comando cmd.exe e execute os seguintes comandos:
winget instalar Git.Git winget instalar Kitware.CMake winget instalar nsis.nsis winget instalar 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, a seguir, 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 essas etapas, você executará em 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 executar o prompt de comando do desenvolvedor conforme descrito acima (não o PowerShell!), Execute os seguintes comandos para instalar o Microsoft VCPKG, que será usado para construir o OpenCV:
cd c:mkdir c:srccd c:src git clone 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 nesta última etapa, pois pode demorar muito para ser executado. 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 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 funcionar sem ele, mas se você quiser treinar uma rede personalizada, será 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 de instalar o CUDA, certifique-se de executar nvcc.exe e nvidia-smi.exe. Talvez seja necessário modificar sua variável PATH.
Depois de baixar o cuDNN, descompacte e copie os diretórios bin, include e lib em C:/Arquivos de Programas/NVIDIA GPU Computing Toolkit/CUDA/[versão]/. Pode ser necessário substituir alguns arquivos.
Se você instalar CUDA ou CUDA+cuDNN posteriormente ou atualizar 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 êxito, você precisará clonar o Darknet e construí-lo. Durante esta 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 git clone https://github.com/hank-ai/darknet.gitcd darknetmkdir buildcd build cmake -DCMAKEBUILDTYPE=Release -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 algumas DLLs CUDA ou cuDNN ausentes, como cublas64_12.dll, copie manualmente os arquivos CUDA .dll para o mesmo diretório de saída que Darknet.exe. Por exemplo:
copie "C:Arquivos de programasNVIDIA GPU Computing ToolkitCUDAv12.2bin*.dll" src-cliRelease
(Esse é um exemplo! Verifique qual versão você está executando e execute o comando apropriado para 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 regularmente 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 isto para testar: versão C:srcDarknetbuildsrc-cliReleasedarknet.exe.
Para instalar corretamente o Darknet, as bibliotecas, os arquivos incluídos e as DLLs necessárias, execute o assistente de instalação do NSIS que foi 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, como 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 os arquivos .cfg do modelo.
Agora você terminou! Assim que o assistente de instalação terminar, Darknet terá sido instalado em C:Program FilesDarknet. Execute isto 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 na etapa anterior.
Usando Darknet
CLI
A seguir não está a 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. O DarkHelp CLI também possui vários recursos avançados que não estão disponíveis diretamente no Darknet. Você pode usar o Darknet CLI e o DarkHelp CLI juntos, eles não são mutuamente exclusivos.
Para a maioria dos comandos mostrados abaixo, você precisará do arquivo .weights com os arquivos .names e .cfg correspondentes. Você pode treinar sua própria rede (altamente recomendado!) ou baixar uma rede neural que alguém já treinou e disponibilizou gratuitamente na internet. Exemplos de conjuntos de dados pré-treinados incluem:
LEGO Gears (encontrar objetos em uma imagem)
Rolodex (encontrar texto em uma imagem)
MSCOCO (detecção de objetos padrão de classe 80)
Os comandos a serem executados incluem:
Liste alguns comandos e opções possíveis para executar:
ajuda darknet
Confira a versão:
versão darknet
Preveja usando uma imagem:
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
Trabalhando com vídeos:
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 de uma webcam:
V2: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0
V3: animais darknet08display_webcam
Salve os resultados em um 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
Executando em uma GPU específica:
V2: demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -i 1 test.mp4
Para verificar 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
Para verificar a precisão mAP@IoU=75:
mapa detector darknet animais.dados animais.cfg animaisbest.weights -iouthresh 0,75
O recálculo das âncoras é melhor feito no DarkMark, pois ele será executado 100 vezes consecutivas e selecionará as melhores âncoras de todas as que foram calculadas. Mas se você quiser rodar a versão 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
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 é usar o DarkMark para criar todos os arquivos Darknet necessários. Esta é definitivamente a forma recomendada para treinar uma nova rede neural.
Se preferir configurar manualmente os vários arquivos para treinar uma rede personalizada:
Crie uma nova pasta onde os arquivos serão armazenados. Para este exemplo, será criada uma rede neural para detectar animais, então será criado o seguinte diretório: ~/nn/animals/.
Copie um dos arquivos de configuração Darknet que você gostaria de usar como modelo. Por exemplo, consulte cfg/yolov4-tiny.cfg. Coloque isso na pasta que você criou. Para este exemplo, agora temos ~/nn/animals/animals.cfg.
Crie um arquivo de texto Animals.names na mesma pasta onde você colocou o arquivo de configuração. Para este exemplo, agora temos ~/nn/animals/animals.names.
Edite o arquivo Animals.names com seu editor de texto. Liste as classes que você deseja usar. Você precisa ter exatamente 1 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
Crie um arquivo de texto Animals.data na mesma pasta. Para este exemplo, o arquivo .data conterá:
classes = 4 trem = /home/nome de usuário/nn/animals/animalstrain.txt válido = /home/nome de usuário/nn/animals/animalsvalid.txt nomes = /home/nome de usuário/nn/animals/animals.names backup = /home/ nome de usuário/nn/animais
Crie uma pasta onde armazenará suas imagens e anotações. Por exemplo, poderia ser ~/nn/animals/dataset. Cada imagem precisará de um arquivo .txt correspondente que descreva as anotações dessa imagem. O formato dos arquivos de anotação .txt é muito específico. Você não pode criar esses arquivos manualmente, pois cada anotação precisa conter as coordenadas exatas 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.
Crie os arquivos de texto "train" e "valid" nomeados no arquivo .data. Esses dois arquivos de texto precisam listar individualmente todas as imagens que Darknet deve usar para treinar e validar no cálculo do mAP%. Exatamente uma imagem por linha. O caminho e os nomes dos arquivos podem ser relativos ou absolutos.
Modifique seu arquivo .cfg com um editor de texto.
Certifique-se de que lote = 64.
Observe as 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 isso. Consulte o FAQ Darknet/YOLO se 1 não funcionar para você.
Nota maxbatches=.... Um bom valor para usar ao começar é 2.000 x o número de aulas. Neste exemplo, temos 4 animais, então 4 * 2.000 = 8.000. O que significa que usaremos maxbatches = 8.000.
Nota steps=.... Isso deve ser definido como 80% e 90% de maxbatches. Para este exemplo usaríamos steps=6400,7200 já que maxbatches foi definido como 8000.
Observe width=... e height=.... Estas são as dimensões da rede. O FAQ Darknet/YOLO explica como calcular o melhor tamanho a ser usado.
Procure todas as instâncias da linha classes=... e modifique-a com o número de classes em seu arquivo .names. Para este exemplo, usaríamos classes=4.
Pesquise todas as instâncias da linha filter=... na seção [convolutional] antes de cada seção [yolo]. O valor a ser usado é (numberofclasses + 5) 3. Significado para este exemplo, (4 + 5) 3 = 27. Portanto, usaríamos filter=27 nas linhas apropriadas.
Comece a treinar! Execute os seguintes comandos:
cd ~/nn/animals/ detector darknet -map -dont_show trem animais.data animais.cfg
Ser paciente. Os melhores pesos serão salvos como Animals_best.weights. E o progresso do treinamento pode ser observado visualizando o
