marmite
0.1.7
Marmita
Marmite [Markdown faz sites] é um gerador de sites estáticos muito simples.
O editor de Downcodes disse: "Marmite é um gerador de site estático muito simples. Costumo usar outros SSGs, mas sempre acho muito complicado configurá-los do zero. Apenas um diretório de arquivos markdown e a execução de um comando podem gerar um site. Isso parece realmente conveniente."
Como usar
Marmite faz uma coisa simples:
Converter arquivo markdown em HTML
Ele também pode lidar com a geração ou cópia de arquivos estáticos ou arquivos de mídia para o diretório de saída.
Instalar
Instale usando carga:
`bash
carga instalar marmite
`
Ou baixe os binários pré-compilados na página de lançamentos.
usar
É tão fácil de usar!
`bash
$ pasta marmite com markdownfiles caminho para site gerado
`
O site será gerado no diretório pathtogenerated_site/.
CLI
`bash
❯ marmite --ajuda
Marmite é o gerador de sites estáticos mais fácil.
Uso: marmite [OPÇÕES]
Argumentos:
Opções:
--serve Servir o site com um servidor HTTP integrado
--watch Detecta alterações e reconstrui o site automaticamente
--vincular
Endereço para vincular o servidor [padrão: localhost:8000]
--config
Caminho para o arquivo de configuração personalizado [padrão: marmite.yaml]
--debug Imprime mensagens de depuração
--init-templates Inicializa modelos no projeto
--start-theme Inicializa um tema com modelos e ativos estáticos
-h, --help Imprimir ajuda
-V, --version Versão para impressão
`
Comece
Leia o tutorial para saber como começar a usar o Marmite https://rochacbruno.github.io/marmite/getting-started.html e gaste alguns minutos criando seu blog.
documento
Leia mais sobre como personalizar modelos, adicionar comentários e muito mais em https://rochacbruno.github.io/marmite/.
Resumir
Marmite é muito simples.
Se essa simplicidade não atender às suas necessidades, existem outros excelentes geradores de sites estáticos por aí. Aqui estão alguns que recomendo:
Jekyll
Hugo
Gatsby
Próximo.js
Estrutura de detecção de objetos Darknet e YOLO
Visão geral
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.
Links importantes:
Como Hank.ai ajuda a comunidade Darknet/YOLO
Site Darknet/YOLO
Perguntas frequentes sobre Darknet/YOLO
Servidor de Discord Darknet/YOLO
papel
Artigo YOLOv7
Papel escalado-YOLOv4
Artigo YOLOv4
Artigo YOLOv3
informações gerais
A estrutura Darknet/YOLO supera consistentemente outras estruturas e versões YOLO em termos de velocidade e precisão.
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ídeos de conjuntos de dados LEGO em até 1000 FPS ao usar uma GPU NVIDIA RTX 3090, o que significa que Darknet/YOLO lê em 1 milissegundo ou menos Buscar, redimensionar e processar cada quadro de vídeo .
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 roda 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 é a versão 0.x.
O próximo repositório Darknet popular mantido por Alexey Bochkovskiy de 2017-2021 também não tinha número de versão. Acreditamos que seja a versão 1.x.
O repositório Darknet patrocinado por Hank.ai e mantido por Stéphane Charette desde 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 é quebrar o mínimo possível a funcionalidade existente enquanto se familiariza com a base de código.
Reescrevemos as etapas de construção para que tenhamos uma maneira unificada de construir no 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ê pode verificar a ramificação v2 anterior. 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, incluindo otimizações durante treinamento e inferência.
Aplicativos API C antigos modificados que usam a API Darknet original requerem 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 usando o conjunto de dados MSCOCO. Este 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 do MSCOCO podem ser baixados de alguns locais diferentes ou deste repositório:
YOLOv2 (novembro de 2016)
- yolov2-tiny.pesos
- yolov2-full.weights
YOLOv3 (maio de 2018)
- yolov3-tiny.pesos
- yolov3-full.weights
YOLOv4 (maio de 2020)
- yolov4-tiny.pesos
- yolov4-full.weights
YOLOv7 (agosto de 2022)
- yolov7-tiny.pesos
- yolov7-full.weights
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. MSCOCO é frequentemente usado para confirmar se está tudo bem.
Construir
Vários métodos de construção do passado (pré-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. São fornecidos vários notebooks Jupyter mostrando como executar 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
1. Instale o software necessário:
`bash
sudo apt-get install build-essential git libopencv-dev cmake
`
2. Clone o repositório Darknet:
`bash
clone do git https://github.com/hank-ai/darknet
`
3. Crie o diretório de construção:
`bash
cd rede escura
compilação mkdir
compilação de CD
`
4. Use CMake para gerar arquivos de construção:
`bash
cmake -DCMAKEBUILDTYPE=Liberar ..
`
5. Construir Darknet:
`bash
faça -j4
`
6. Instale Darknet (opcional):
`bash
fazer pacote
sudo dpkg -i darknet-VERSION.deb
`
Perceber:
Se você tiver uma GPU NVIDIA instalada em seu sistema, poderá instalar CUDA ou CUDA+cuDNN para acelerar o processamento de imagem (e vídeo).
Se você instalar CUDA ou CUDA+cuDNN ou atualizar o software NVIDIA, será necessário excluir o arquivo CMakeCache.txt no diretório de construção e reconstruir o Darknet.
Você pode usar o comando darknet version para verificar se o Darknet foi instalado com sucesso.
Métodos CMake do Windows
1. Instale o software necessário:
`bash
winget instalar Git.Git
winget instalar Kitware.CMake
winget instalar nsis.nsis
instalar winget Microsoft.VisualStudio.2022.Community
`
2. Modifique a instalação do Visual Studio:
- Abra o menu Iniciar do Windows e execute o instalador do Visual Studio.
- Clique em "Editar".
- Selecione "Desenvolvimento desktop usando C++".
- Clique em “Editar” no canto inferior direito e depois clique em “Sim”.
3. Instale o Microsoft VCPKG:
`bash
CDC:
mkdir c:src
cd c:src
clone do git https://github.com/microsoft/vcpkg
CD vcpkg
bootstrap-vcpkg.bat
.vcpkg.exe integrar instalação
.vcpkg.exe integrar powershell
.vcpkg.exe instalar opencv[contrib,dnn,freetype,jpeg,openmp,png,webp,world]:x64-windows
`
4. Clone o repositório Darknet:
`bash
cd c:src
clone do git https://github.com/hank-ai/darknet.git
cd rede escura
compilação mkdir
compilação de CD
`
5. Use CMake para gerar arquivos de construção:
`bash
cmake -DCMAKEBUILDTYPE=Liberar -DCMAKETOOLCHAINFILE=C:/src/vcpkg/scripts/buildsystems/vcpkg.cmake ..
`
6. Construir Darknet:
`bash
msbuild.exe /property:Platform=x64;Configuration=Release /target:Build -maxCpuCount -verbosity:normal -detailedSummary darknet.sln
msbuild.exe /property:Platform=x64;Configuration=Liberar PACKAGE.vcxproj
`
7. Instale o Darknet:
- Execute o arquivo darknet-VERSION.exe no diretório de construção para iniciar o assistente de instalação do NSIS.
Perceber:
Se você tiver uma GPU NVIDIA instalada em seu sistema, poderá instalar CUDA ou CUDA+cuDNN para acelerar o processamento de imagem (e vídeo).
Se você instalar CUDA ou CUDA+cuDNN ou atualizar o software NVIDIA, será necessário excluir o arquivo CMakeCache.txt no diretório de construção e reconstruir o Darknet.
Você pode usar o comando de versão darknet.exe para verificar se o Darknet foi instalado com sucesso.
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 vários recursos avançados não disponíveis no Darknet. Você pode usar Darknet CLI e DarkHelp CLI ao mesmo tempo, eles não são mutuamente exclusivos.
Para a maioria dos comandos mostrados abaixo, você precisa usar o arquivo .weights correspondente aos arquivos .names e .cfg. Você pode treinar sua própria rede (altamente recomendado!) ou baixar redes neurais que outras pessoas treinaram e postaram gratuitamente na Internet. Exemplos de conjuntos de dados de pré-treinamento incluem:
LEGO Gears (encontre objetos nas imagens)
Rolodex (encontrar texto na imagem)
MSCOCO (detecção padrão de objetos de 80 categorias)
Os comandos a serem executados incluem:
Ajuda darknet: exibe informações de ajuda.
versão darknet: Verifique a versão.
teste de detector darknet cars.data cars.cfg cars_best.weights image1.jpg: Use imagens para previsão (V2).
darknet02displayannotatedimages cars.cfg image1.jpg: Previsão usando imagens (V3).
DarkHelp cars.cfg cars.cfg cars_best.weights image1.jpg: Previsão usando imagens (DarkHelp).
teste de detector darknet animais.data animais.cfg animaisbest.weights -extoutput dog.jpg: Coordenadas de saída (V2).
darknet01inference_images animais dog.jpg: Coordenadas de saída (V3).
DarkHelp --json Animals.cfg Animals.names Animals_best.weights Dog.jpg: Coordenadas de saída (DarkHelp).
demonstração do detector darknet animais.data animais.cfg animaisbest.weights -extoutput test.mp4: Processamento de vídeo (V2).
darknet03display_videosanimais.cfg test.mp4: Processando vídeos (V3).
DarkHelp Animals.cfg Animals.names Animals_best.weights Test.mp4: Processando vídeo (DarkHelp).
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -c 0: Leia da webcam (V2).
darknet08display_webcam animais: Leia da webcam (V3).
demonstração do detector darknet animais.data animais.cfg animaisbest.weights test.mp4 -outfilename res.avi: Salva os resultados em vídeo (V2).
darknet05processvideosmultithreaded Animals.cfg Animals.names Animals_best.weights Test.mp4: Salve os resultados em vídeo (V3).
DarkHelp Animals.cfg Animals.names Animals_best.weights Test.mp4: Salve os resultados em vídeo (DarkHelp).
demonstração do detector darknet animais.data animais.cfg animaisbest.weights test50.mp4 -jsonport 8070 -mjpegport 8090 -extoutput: Use o formato JSON (V2).
darknet06imagestojson animais image1.jpg: Use o formato JSON (V3).
DarkHelp --jsonanimais.namesanimais.cfganimais_best.weights image1.jpg: Use o formato JSON (DarkHelp).
Demonstração do detector darknet Animals.data Animals.cfg Animals_best.weights -i 1 test.mp4: Executar em GPU específico.
mapa do detector darknet driving.data driving.cfg driving_best.weights ...: Verifique a precisão da rede neural.
Mapa do detector darknet Animals.data Animals.cfg Animalsbest.weights -iouthresh 0,75: Verifique a precisão de mAP@IoU=75.
detector darknet calcanchors Animals.data -numof_clusters 6 -width 320 -height 256: Recalcular pontos de ancoragem.
detector darknet -map -dont_show treinar animais.data animais.cfg: Treine uma nova rede.
trem
Como configuro meus arquivos e diretórios?
Qual perfil devo usar?
Quais comandos devo usar ao treinar minha própria rede?
Usar anotação e treinamento DarkMark é o método mais simples, que cria todos os arquivos Darknet necessários. Esta é definitivamente a forma recomendada para treinar novas redes neurais.
Se preferir configurar manualmente os vários arquivos para treinar uma rede personalizada, siga estas etapas:
1. Crie uma nova pasta para armazenar os arquivos. Por exemplo, você criará uma rede neural para detecção de animais, então o seguinte diretório será criado: ~/nn/animals/.
2. Copie um arquivo de configuração Darknet que deseja usar como modelo. Veja, por exemplo, cfg/yolov4-tiny.cfg. Coloque-o na pasta que você criou. Para este 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. Para este exemplo, agora temos ~/nn/animals/animals.names.
4. Use um editor de texto para editar o arquivo pets.names. Liste as categorias que deseja usar. Cada linha deve conter exatamente um item, sem linhas em branco ou comentários. Para este exemplo, o arquivo .names conterá as 4 linhas a seguir:
`
cachorro
gato
pássaro
cavalo
`
5. Crie um arquivo de texto Animals.data na mesma pasta. Para este 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 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. 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 GPU, pode ser necessário aumentar as subdivisões. O valor ideal é 1, então comece com isso. Se 1 não funcionar para você, consulte as Perguntas frequentes do Darknet/YOLO.
- Nota maxbatches=…. Um bom valor para começar é o número de categorias multiplicado por 2.000. Neste exemplo, temos 4 animais, então 4 * 2.000 = 8.000. Isso significa que usaremos maxbatches=8000.
- Observe as etapas =…. Isso deve ser definido como 80% e 90% de maxbatches. Para este exemplo, como maxbatches está definido como 8.000, usaremos steps=6400,7200.
- Observe 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 linhas classes=... e modifique-as com o número de classes em seu arquivo .names. Para este exemplo usaremos classes=4.
- Encontre 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, para este exemplo, (4 + 5) 3 = 27. Portanto, usamos filtros=27 nas linhas apropriadas.
9. 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 obter uma CLI alternativa poderosa ao Darknet para trabalhar com imagens lado a lado, rastreamento de objetos em vídeo ou uma API C++ poderosa que pode ser facilmente usada em aplicativos comerciais, consulte DarkHelp.
Consulte o FAQ Darknet/YOLO para ver se ele 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 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() por std::sort() durante o treinamento (algumas outras substituições obscuras 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 instrumentação CUDA
Removido o antigo código do "alfabeto" e excluído mais de 700 imagens em dados/rótulos
Construir código-fonte externo
Tenha 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 em void*, em vez disso use-o como um objeto C++ correto
Corrija ou mantenha estruturas de imagem internas usadas de forma consistente
Corrigir compilação para dispositivos Jetson de arquitetura ARM
- É improvável que os dispositivos Jetson originais sejam consertados, pois não são mais suportados pela NVIDIA (sem compilador C++ 17)
- Novo dispositivo Jetson Orin em execução
Corrigir API Python na V3
- Precisa de melhor suporte para Python (há algum desenvolvedor de Python disposto a ajudar com esse problema?)
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 char* e substitua por std::string
Não oculte avisos e limpe os avisos do compilador (trabalho em andamento)
Melhor uso de 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 canal único
Adicionado suporte para imagens de canal N onde N > 3 (por exemplo, imagens com profundidade extra ou canais térmicos)
Limpeza de código contínua (em andamento)
objetivos de longo prazo
Corrija problemas de CUDA/CUDNN relacionados a 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
