Isso é uma mão? (Câmera Raspberry Pi + Rede Neural) Parte 1/2: 16 etapas (com imagens)

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

Há alguns dias, machuquei o pulso da mão direita na academia. Depois disso, toda vez que eu usava o mouse do computador, ele causava muita dor por causa do ângulo inclinado do pulso.

Foi quando me dei conta "não seria ótimo se pudéssemos converter qualquer superfície em um trackpad" e não sei por quê, mas por alguma razão pensei nela, o filme ELA, vou deixar vocês descobrirem Fora. Foi um pensamento emocionante, mas eu não sabia se conseguiria, decidi tentar.

Este artigo captura o que saiu disso.

Antes de começar, tenho uma isenção de responsabilidade -

“No final deste artigo, não consegui converter nenhuma superfície em trackpad, mas não aprendi muito e adicionei grandes ferramentas ao meu arsenal. Espero que isso aconteça com você também '

Vamos começar.

Etapa 1: Vídeo

Aqui está um pequeno vídeo de 5 minutos cobrindo todas as etapas. Dê uma olhada.

Etapa 2: Hardware

Eu configurei um pi de framboesa junto com uma câmera pi de framboesa a uma altura de cerca de 45 cm. Isso nos dá uma área de monitoramento de cerca de 25x25 cm embaixo da câmera.

Raspberry pi e raspberry pi camera estão facilmente disponíveis, basta pesquisar no Google e você deverá encontrar uma loja local.

Dê uma olhada neste link ou em uma de minhas listas de reprodução de pi do Raspberry para colocar seu pi sem cabeça para funcionar.

Seguindo essa configuração, precisamos de um código que decida se há uma mão na área que a câmera está monitorando e, se houver, onde ela está.

Etapa 3: Código

Um pedaço de código que nos permite decidir se há uma mão na área de interesse usa algo chamado Rede Neural. Eles se enquadram na categoria de programação em que não definimos regras para tomar decisões, mas mostramos à rede neural dados suficientes para que ela descubra as regras por conta própria.

Em nosso caso, em vez de codificar a aparência da mão, mostramos imagens de rede neural capturadas do raspberry pi que contém mão e não contém mão. Esta fase é chamada de treinamento de rede neural e as imagens utilizadas são chamadas de conjunto de dados de treinamento.

Etapa 4: Obter imagens

Eu loguei remotamente no meu raspberry pi e capturei um monte de imagens usando o seguinte comando.

sudo raspistill -w 640 -h 480 -rot 90 -t 250000 -t1 5000 -o frame% 04d.jpg

Capturei 80 imagens com a mão e 80 imagens que não contém a mão. 160 imagens não são suficientes para treinar adequadamente uma rede neural, mas devem ser suficientes para a prova de conceito.

Além de 160 imagens, capturei mais 20 imagens para testar nossa rede depois de treinada.

Assim que o conjunto de dados estava pronto, comecei a escrever código para rede neural.

Etapa 5: Ferramentas e idioma usado

Eu escrevi minha rede neural na biblioteca de aprendizagem profunda python chamada Keras e o código é escrito no notebook jupyter do navegador anaconda.

Etapa 6: Preparação do conjunto de dados para treinamento

Primeiro (Imagem # 1) incluí todas as bibliotecas necessárias para este projeto, que inclui PIL, matplotlib, numpy, os e Keras. Na segunda célula do caderno Python (Imagem # 2), defino os caminhos para o conjunto de dados e imprimo a contagem de amostra. Agora precisamos carregar todas as imagens em uma matriz numpy, portanto, na terceira célula (Imagem # 2) criei uma matriz numpy de 82 (número da amostra da mão) +75 (número da amostra não manual), ou seja, 157x100x100x3. 157 é o número total de imagens que tenho, 100x100 é a dimensão da imagem redimensionada e 3 é para as camadas de cor vermelha, verde e azul na imagem.

Na quarta e quinta células, carregamos imagens contendo mão seguida por imagens que não contêm mão na matriz numpy. Na sexta célula, dividimos cada valor por 255, portanto, limitando o intervalo de valores de 0 a 1. (Imagem # 3)

Lamento se as imagens anexadas não forem boas o suficiente. Aqui está um link para o repositório GITHUB para você examinar o código. Não se esqueça de substituir os nomes do caminho do diretório pelo seu caminho:).

Seguindo em frente.

Em seguida, precisamos rotular cada imagem, então, criamos um array numpy unidimensional de 157 de comprimento. As primeiras 82 entradas são definidas como 1 e as 75 entradas restantes são definidas como 0, transmitindo a rede neural que as primeiras 82 imagens são de uma classe e as restantes são de outra. (Imagem nº 4)

Agora vamos criar uma rede neural.

Etapa 7: Rede Neural

Na nona célula, definimos nossa rede neural. Ele contém três repetições de camada de convolução seguidas por camadas de maxpool com 8, 12 e 16 filtros de convolução, respectivamente. Em seguida, temos duas redes neurais densas. Anexando duas imagens para esta etapa. O primeiro é o código que cria a rede neural e o segundo é a representação pictórica da rede neural com dimensão de saída e operações anotadas.

Etapa 8: treinamento de rede neural

Na décima célula, configuramos o otimizador de rede neural como 'adam' e a função de perda como 'binary_crossentropy'. Eles desempenham um papel importante em como os pesos da rede são atualizados. Finalmente, quando executamos a décima primeira célula, a rede neural começa a treinar. Enquanto a rede está treinando, observe a função de perda e certifique-se de que ela esteja diminuindo.

Etapa 9: Teste de rede neural

Uma vez que a rede neural é treinada, precisamos preparar o conjunto de dados de teste. Repetimos o procedimento feito para preparar o conjunto de treinamento na 3ª, 4ª, 5ª e 6ª células nos dados de teste para criar o conjunto de teste. Também preparamos o rótulo para o conjunto de teste, mas desta vez executamos o modelo nesses conjuntos de dados para obter previsões e não para treinar.

Etapa 10: Resultado e próxima parte…

Eu obtive uma precisão de teste de 88%, mas peguei isso com uma pitada de sal, pois o conjunto de dados usado para treinar e testar este modelo é muito pequeno e inadequado para treinar adequadamente este modelo.

De qualquer forma, espero que você tenha gostado deste artigo. Minha intenção por trás deste exercício ainda não está completa e esteja atento para a 2ª parte. Vou fazer o upload assim que puder.

Na próxima parte, treinaremos outra rede neural que nos dirá a localização da mão em uma imagem detectada pela mão.

Todas as consultas são bem-vindas.

Se alguém estiver interessado em usar meu minúsculo conjunto de dados, deixe-me saber nos comentários. Eu vou disponibilizar.

Obrigado pela leitura. Vejo você em breve com a segunda parte até então por que você não cria e treina uma rede neural.

Editar: - Os próximos passos são para a segunda parte.

Etapa 11: Detecção de objeto

Nas etapas anteriores, criamos um NN que nos diz se a imagem de teste contém mão ou não. Bem, o que vem a seguir? Se NN classificar a imagem como contendo mão, gostaríamos de saber a localização da mão. Isso é chamado de detecção de objetos na literatura de visão computacional. Então, vamos treinar NN que faz exatamente o mesmo.

Etapa 12: Vídeo

Um vídeo de 3 minutos explicando todas as etapas restantes. Dê uma olhada.

Etapa 13: Rotulagem

Se você quiser que uma rede neural produza a localização da mão, precisamos treiná-la de tal forma, ou seja, ao contrário da rede neural anterior, onde cada imagem era rotulada como com a mão e sem a mão. Desta vez, todas as imagens com a mão terão quatro rótulos correspondentes às coordenadas diagonais da caixa delimitadora ao redor da mão nessa imagem.

A imagem anexada do arquivo csv contém um rótulo para cada imagem. Observe que as coordenadas são normalizadas com a dimensão da imagem, ou seja, se a coordenada X superior estiver no 320º pixel na imagem com largura de 640 pixels, iremos rotulá-la como 0,5.

Etapa 14: GUI de rotulagem

Você deve estar se perguntando como consegui rotular todas as 82 imagens, bem, eu escrevi uma GUI em python que me ajudou nessa tarefa. Uma vez que a imagem é carregada na GUI. Cliquei com o botão esquerdo na coordenada superior e cliquei com o botão direito na coordenada inferior da provável caixa delimitadora ao redor da mão. Essas coordenadas são então gravadas em um arquivo após clicar no botão Avançar para carregar a próxima imagem. Repeti este procedimento para todas as 82 imagens de trem e 4 imagens de teste. Depois que os rótulos estavam prontos, era hora de treinar.

Etapa 15: Bibliotecas necessárias

Primeiro, precisamos carregar todas as bibliotecas necessárias. Que inclui

• PIL para manipulação de imagem,
• matplotlib para plotagem,
• numpy para operação de matriz,
• OS para funcionalidade dependente do sistema operacional e
• keras para rede neural.

Etapa 16: células restantes

Na 2ª, 3ª, 4ª e 5ª células, carregamos as imagens em um array numpy e criamos um array de quatro dimensões a partir do arquivo csv para atuar como rótulos. Na célula número 6, criamos nossa rede neural. Sua arquitetura é idêntica à rede neural usada para classificação, exceto a dimensão da camada de saída que é 4 e não 1. Outra diferença vem da função de perda usada, que é o erro quadrático médio. Na célula número 8, começamos o treinamento de nossa rede neural, uma vez treinada, executei este modelo no conjunto de testes para obter previsões para a caixa delimitadora em coordenadas sobrepostas da caixa delimitadora que pareciam muito precisas.

Obrigado pela leitura.