Detecção de objetos com placas Sipeed MaiX (Kendryte K210): 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:34

Como continuação do meu artigo anterior sobre reconhecimento de imagem com placas Sipeed MaiX, decidi escrever outro tutorial, com foco na detecção de objetos. Houve alguns hardwares interessantes surgindo recentemente com o chip Kendryte K210, incluindo Seeed AI Hat for Edge Computing, M5StickV da pilha M5 e HuskyLens da DFRobot (embora este tenha firmware proprietário e mais voltado para iniciantes). Por causa de seu preço barato, o Kendryte K210 atraiu as pessoas, que desejam adicionar a visão computacional aos seus projetos. Mas como de costume com produtos de hardware chineses, falta suporte técnico e isso é algo que estou tentando melhorar com meus artigos e vídeos. Mas lembre-se de que não faço parte da equipe de desenvolvedores Kendryte ou Sipeed e não posso responder a todas as perguntas relacionadas a seus produtos.

Com isso em mente, vamos começar! Começaremos com uma visão geral curta (e simplificada) de como os modelos CNN de reconhecimento de objetos funcionam.

ATUALIZAÇÃO DE MAIO DE 2020: Vendo como meu artigo e vídeo sobre Detecção de objetos com placas K210 ainda são muito populares e entre os principais resultados do YouTube e Google, decidi atualizar o artigo para incluir as informações sobre aXeleRate, estrutura baseada em Keras para IA no Edge eu desenvolvo. AXeleRate, essencialmente, é baseado na coleção de scripts que usei para treinar modelos de reconhecimento de imagem / detecção de objetos - combinados em uma única estrutura e otimizados para fluxo de trabalho no Google Colab. É mais conveniente de usar e mais atualizado.

Para a versão antiga do artigo, você ainda pode vê-lo em steemit.com.

Etapa 1: Explicação da arquitetura do modelo de detecção de objetos

Os modelos de reconhecimento de imagem (ou classificação de imagem) tomam a imagem inteira como entrada e geram uma lista de probabilidades para cada classe que estamos tentando reconhecer. É muito útil se o objeto em que estamos interessados ocupa uma grande parte da imagem e não nos importamos muito com sua localização. Mas e se nosso projeto (digamos, câmera de rastreamento de rosto) exigir que não apenas tenhamos um conhecimento sobre o tipo de objeto na imagem, mas também sobre suas coordenadas. E o projeto que requer a detecção de vários objetos (por exemplo, para contagem)?

É aqui que os modelos de detecção de objetos são úteis. Neste artigo, usaremos a arquitetura YOLO (você só olha uma vez) e enfocaremos a explicação na mecânica interna dessa arquitetura em particular.

Estamos tentando determinar quais objetos estão presentes na imagem e quais são suas coordenadas. Já o aprendizado de máquina não é mágica e nem "uma máquina pensante", mas apenas um algoritmo que utiliza estatísticas para otimizar a função (rede neural) para melhor resolver um determinado problema. Precisamos parafrasear esse problema para torná-lo mais "otimizável". Uma abordagem ingênua aqui seria ter o algoritmo minimizando a perda (diferença) entre sua previsão e as coordenadas corretas do objeto. Isso funcionaria muito bem, desde que tenhamos apenas um objeto na imagem. Para vários objetos, adotamos uma abordagem diferente - adicionamos a grade e fazemos nossa rede prever a presença (ou ausência) do (s) objeto (s) em cada grade. Parece ótimo, mas ainda deixa muita incerteza para a rede - como gerar a previsão e o que fazer quando há vários objetos com centro dentro de uma célula da grade? Precisamos adicionar mais uma restrição - as chamadas âncoras. Âncoras são tamanhos iniciais (largura, altura) alguns dos quais (o mais próximo ao tamanho do objeto) serão redimensionados para o tamanho do objeto - usando algumas saídas da rede neural (mapa de recurso final).

Portanto, aqui está uma visão de nível superior do que está acontecendo quando a rede neural da arquitetura YOLO realiza uma detecção de objeto na imagem. De acordo com as características detectadas pela rede extratora de características, para cada célula da grade é feito um conjunto de previsões, que inclui o deslocamento das âncoras, a probabilidade da âncora e a classe da âncora. Então descartamos as previsões com baixa probabilidade e voila!

Etapa 2: preparar o ambiente

aXeleRate é baseado no maravilhoso projeto de penny4860, detector de dígitos SVHN yolo-v2. aXeleRate leva esta implementação do detector YOLO em Keras para um próximo nível e usa seu sistema de configuração conveniente para realizar treinamento e conversão de reconhecimento de imagem / detecção de objeto e redes de segmentação de imagem com vários back-ends.

Existem duas maneiras de usar aXeleRate: executando localmente na máquina Ubuntu ou no Google Colab. Para executar no Google Colab, dê uma olhada neste exemplo:

Notebook PASCAL-VOC Object Detection Colab

Treinar seu modelo localmente e exportá-lo para ser usado com aceleração de hardware também é muito mais fácil agora. Eu recomendo fortemente que você instale todas as dependências necessárias no ambiente Anaconda para manter seu projeto separado de outros e evitar conflitos.

Baixe o instalador aqui.

Após a conclusão da instalação, crie um novo ambiente:

conda criar -n yolo python = 3.7

Vamos ativar o novo ambiente

conda ativar yolo

Um prefixo antes de seu shell bash aparecerá com o nome do ambiente, indicando que você agora trabalha naquele ambiente.

Instale aXeleRate em sua máquina local com

pip install git +

Em seguida, execute-o para baixar os scripts de que você precisará para treinamento e inferência:

git clone

Você pode executar testes rápidos com tests_training.py na pasta aXeleRate. Ele executará o treinamento e a inferência para cada tipo de modelo, salvará e converterá os modelos treinados. Como ele está treinando apenas para 5 épocas e o conjunto de dados é muito pequeno, você não poderá obter modelos úteis, mas este script serve apenas para verificar a ausência de erros.

Etapa 3: treinar um modelo de detecção de objeto com Keras

Agora podemos executar um script de treinamento com o arquivo de configuração. Como a implementação do detector de objetos YOLO pelo Keras é bastante complicada, em vez de explicar cada parte relevante do código, explicarei como configurar o treinamento e também descreverei os módulos relevantes, caso você queira fazer algumas alterações neles.

Vamos começar com um exemplo de brinquedo e treinar um detector de guaxinim. Há um arquivo de configuração dentro da pasta / config, raccoon_detector.json. Escolhemos MobileNet7_5 como arquitetura (onde 7_5 é o parâmetro alfa da implementação Mobilenet original, controla a largura da rede) e 224x224 como tamanho de entrada. Vamos dar uma olhada nos parâmetros mais importantes na configuração:

O tipo é o front-end do modelo - Classifier, Detector ou SegnetArchitecture é o back-end do modelo (extrator de recursos)

- Full Yolo - Tiny Yolo - MobileNet1_0 - MobileNet7_5 - MobileNet5_0 - MobileNet2_5 - SqueezeNet - VGG16 - ResNet50

Para obter mais informações sobre âncoras, leia aqui

Rótulos são rótulos presentes em seu conjunto de dados. IMPORTANTE: liste todos os rótulos presentes no conjunto de dados.

object_scale determina quanto penalizar a previsão incorreta de confiança dos preditores de objeto

no_object_scale determina quanto penalizar a previsão errada de confiança de preditores não-objetos

coord_scale determina quanto penalizar as previsões erradas de posição e tamanho (x, y, w, h)

class_scale determina quanto penalizar a previsão de classe errada

augumentation - aumento da imagem, redimensionamento, deslocamento e desfoque da imagem, a fim de evitar overfitting e ter maior variedade no conjunto de dados.

train_times, validation_times - quantas vezes para repetir o conjunto de dados. Útil se você tiver augumentação

ativado

first_trainable_layer - permite que você congele certas camadas se estiver usando uma rede de recursos pré-treinada

Agora precisamos baixar o conjunto de dados, que compartilhei no meu Google Drive (conjunto de dados original), que é um conjunto de dados de detecção de guaxinins, contendo 150 imagens anotadas.

Certifique-se de alterar as linhas no arquivo de configuração (train_image_folder, train_annot_folder) de acordo e, em seguida, inicie o treinamento com o seguinte comando:

python axelerate / train.py -c configs / raccoon_detector.json

train.py lê a configuração do arquivo.json e treina o modelo com o script axelerate / networks / yolo / yolo_frontend.py. yolo / backend / loss.py é onde a função de perda personalizada é implementada e yolo / backend / network.py é onde o modelo é criado (entrada, extrator de recurso e camadas de detecção reunidas). axelerate / networks / common_utils / fit.py é um script que implementa o processo de treinamento e axelerate / networks / common_utils / feature.py contém extratores de recursos. Se você pretende usar um modelo treinado com chip K210 e firmware Micropython, devido às limitações de memória, você pode escolher entre MobileNet (2_5, 5_0 e 7_5) e TinyYolo, mas descobri que o MobileNet oferece melhor precisão de detecção.

Por ser um exemplo de brinquedo e conter apenas 150 imagens de guaxinins, o processo de treinamento deve ser bem rápido, mesmo sem GPU, embora a precisão esteja longe de ser estelar. Para projetos relacionados ao trabalho, treinei um detector de sinais de trânsito e um detector de números, ambos os conjuntos de dados incluídos mais de alguns milhares de exemplos de treinamento.

Etapa 4: converta para o formato.kmodel

Com aXeleRate, a conversão do modelo é realizada automaticamente - esta é provavelmente a maior diferença da versão antiga dos scripts de treinamento! Além disso, você obtém os arquivos de modelo e gráfico de treinamento salvos ordenadamente na pasta do projeto. Também descobri que a precisão do vaiidation às vezes falha em fornecer estimativas sobre o desempenho real do modelo para detecção de objetos e é por isso que adicionei o mAP como uma métrica de validação para modelos de detecção de objetos. Você pode ler mais sobre o mAP aqui.

Se o mAP, a precisão média média (nossa métrica de validação) não melhorar por 20 épocas, o treinamento será interrompido prematuramente. Cada vez que o mAP melhora, o modelo é salvo na pasta do projeto. Após o término do treinamento, aXeleRate converte automaticamente o melhor modelo para os formatos especificados - você pode escolher "tflite", "k210" ou "edgetpu" a partir de agora.

Agora para a última etapa, realmente rodando nosso modelo no hardware Sipeed!

Etapa 5: execute no firmware Micropython

É possível executar inferência com nosso modelo de detecção de objeto com código C, mas por uma questão de conveniência, usaremos o firmware Micropython e o IDE MaixPy.

Baixe o IDE MaixPy aqui e o firmware do micropython aqui. Você pode usar o script python kflash.py para gravar o firmware ou baixar a ferramenta de flash GUI separada aqui.

Copie model.kmodel para a raiz de um cartão SD e insira o cartão SD no Sipeed Maix Bit (ou outro dispositivo K210). Alternativamente, você pode gravar.kmodel na memória flash do dispositivo. Meu script de exemplo lê.kmodel da memória flash. Se você estiver usando um cartão SD, altere esta linha

tarefa = kpu.load (0x200000)

para

tarefa = kpu.load ("/ sd / model.kmodel")

Abra o IDE MaixPy e pressione o botão de conexão. Abra o script raccoon_detector.py da pasta example_scripts / k210 / detector e pressione o botão Iniciar. Você deve estar vendo uma transmissão ao vivo da câmera com caixas delimitadoras ao redor … bem, guaxinins. Você pode aumentar a precisão do modelo fornecendo mais exemplos de treinamento, mas tenha em mente que é um modelo pequeno (1,9 M) e terá problemas para detectar objetos pequenos (devido à baixa resolução).

Uma das perguntas que recebi em comentários ao meu artigo anterior sobre reconhecimento de imagem é como enviar os resultados da detecção por UART / I2C para outro dispositivo conectado a placas de desenvolvimento Sipeed. Em meu repositório github, você poderá encontrar outro script de exemplo, raccoon_detector_uart.py, que (você adivinhou) detecta guaxinins e envia as coordenadas das caixas delimitadoras pelo UART. Lembre-se de que os pinos usados para comunicação UART são diferentes em placas diferentes; isso é algo que você precisa verificar na documentação.

Etapa 6: Resumo

Kendryte K210 é um chip sólido para visão computacional, flexível, embora com memória limitada disponível. Até agora, em meus tutoriais, cobrimos como usá-lo para reconhecer objetos personalizados, detectar objetos personalizados e executar algumas tarefas de visão computacional baseadas em OpenMV. Eu sei que também é adequado para reconhecimento de rosto e com alguns ajustes deve ser possível fazer detecção de pose e segmentação de imagem (você pode usar aXeleRate para treinar o modelo de segmentação semântica, mas ainda não implementei a inferência com K210). Sinta-se à vontade para dar uma olhada nos problemas do repositório aXeleRate e fazer um PR se você acha que há algumas melhorias com as quais você pode contribuir!

Aqui estão alguns artigos que usei ao escrever este tutorial, dê uma olhada se você quiser aprender mais sobre a detecção de objetos com redes neurais:

Detectores de objetos de caixa delimitadora: entendendo o YOLO, você parece apenas uma vez

Entendendo YOLO (mais matemática)

Guia suave sobre como a localização de objetos YOLO funciona com Keras (Parte 2)

Detecção de objetos em tempo real com YOLO, YOLOv2 e agora YOLOv3

Espero que você possa usar o conhecimento que tem agora para construir alguns projetos incríveis com visão de máquina! Você pode comprar placas Sipeed aqui, elas estão entre as opções mais baratas disponíveis para ML em sistemas embarcados.

Adicione-me no LinkedIn se tiver alguma dúvida e inscreva-se no meu canal no YouTube para ser notificado sobre projetos mais interessantes envolvendo aprendizado de máquina e robótica.