Índice:
2025 Autor: John Day | [email protected]. Última modificação: 2025-01-13 06:58
Este instrutível é baseado no meu projeto universitário. O objetivo era criar um sistema em que uma rede neural analisasse uma imagem e, então, com base no reconhecimento, diria a um robô arduino para se mover via Ros.
Por exemplo, se um sinal de virar à direita for reconhecido, o robô irá virar à direita; se um sinal de virar à esquerda for reconhecido, o robô irá virar à esquerda; se nenhum for reconhecido, o robô continuará em frente. O conjunto de dados que será usado é o reconhecimento de sinais de trânsito oficial do INI (2019) (Institut Fur Neuroinformatik), este conjunto de dados tem 43 classes, no entanto, apenas duas são necessárias; As pastas 00033 e 00034 no conjunto de dados são sinais de mudança de direção à esquerda e à direita.
Etapa 1: Requisitos
Os requisitos para este projeto são os seguintes:
Um robô arduino. (basicamente um arduino uno, um driver de motor e motores) (não necessário se você não estiver usando um robô)
Uma framboesa pi 4.
Uma câmera pi.
Software necessário:
Python 3.
OpenCV 4.
Tensorflow.
IDE arduino (não é necessário se você não estiver usando um robô)
Ros (não é necessário se você não estiver usando um robô)
Seja qual for o seu ide python favorito (no pi framboesa, eu uso Thonny).
Para configurar o OpenCV e o Tensorflow, siga as instruções de Adrian. Link:
Eu recomendo olhar o máximo possível de seus tutoriais, eles são realmente interessantes e úteis tanto para iniciantes quanto para intermediários.
Etapa 2: treinamento de dados
O script do trem é projetado para acessar o conjunto de dados que compila cerca de 50.000 imagens de 43 classes. O script é escrito em python, usando uma variedade de bibliotecas: os - serve para vincular o script python ao diretório correto onde o conjunto de dados está localizado. Matplotlib - serve para exibir os dados do modelo de treinamento. Tensorflow e keras - essas são as bibliotecas usadas para criar o modelo de rede neural artificial, elas são usadas para projetar o modelo. Numpy - esta biblioteca serve para transformar imagens em um array que pode então ser colocado no modelo para recuperar uma previsão.
O script anexado é o código Python para fazer um modelo do conjunto de dados. Este consiste em uma convolução 2D com uma entrada (5, 5) e uma ativação de relu então pooling, uma vez feito isso a entrada passa por outra convolução com uma entrada (3, 3) com a mesma ativação e pooling. Isso acontece uma última vez antes de ser aplainado e então a densidade é aplicada à quantidade de classes que existem, neste caso 43.
A próxima etapa foi compilar o modelo. Esta é a parte que define o otimizador, um sgd foi o mais adequado, pois era semelhante ao otimizador usado na atribuição 1. Sgd significa descida gradiente estocástica. Além disso, dentro do compilador, a perda precisa ser definida, escolher uma perda sparse_categorical_crossentropy é o melhor ajuste, uma vez que as categorias são inteiras e o modelo irá gerar uma previsão para cada classe como um float entre 0 e 1. 1 sendo 100% de precisão.
Assim que o compilador estiver concluído, um gerador precisa ser aplicado para que o modelo comece a processar as entradas da imagem. O gerador consiste em várias partes: training_set - este é o link para o conjunto de dados usado para treinamento, steps_per_epoch - este é o número de passos por época que são necessários, épocas - estas são quantas vezes o programa irá iterar através de um conjunto completo de dados, validation_data - este é o link para o conjunto de dados usado para validação, validation_steps - o número de etapas usadas para validação, a validação acontece no final de cada época.
Geralmente, uma limpeza completa de todo o conjunto de dados precisa ser concluída por época. Portanto, por exemplo, um conjunto de dados de 1024 imagens exigirá: Tamanho do lote = 32, Etapas por época = 32, épocas = 1. Cada etapa inclui todo o tamanho do lote, portanto, com um tamanho de lote de 32, as etapas serão 32. Por outro Por outro lado, é melhor ter um tamanho de lote maior do que o número de classes, isso porque se o tamanho do lote for menor, então cada etapa não pode incluir uma imagem de cada classe.
Uma vez que o modelo tenha terminado o treinamento, usando matplotlib o programa fará um gráfico das saídas, isto mostra o histórico do treinamento do início ao fim. O gráfico consiste em exatidão, exatidão de validação, perda e perda de validação, isto é dividido por época para mostrar como o treinamento progrediu. A etapa final é salvar o modelo como um arquivo.h5 que pode ser acessado posteriormente para o processo de predição. Salvar o modelo significa que cada vez que o programa de previsão é executado, o programa de treinamento não precisa ser executado novamente. O programa de treinamento pode levar até 10 minutos por época em um pi de framboesa.
Em anexo está o script de treinamento:
Etapa 3: Implementando as previsões da câmera Pi
O próximo programa é a previsão e o script do editor.
O primeiro estágio é carregar o modelo usando model.load (). O segundo estágio é iterar através dos quadros da câmera pi usando opencv e, em seguida, redimensionar o quadro para o mesmo tamanho que os tamanhos de entrada usados no estágio de treinamento, 32 x 32 pixels. Uma vez feito isso, o novo quadro redimensionado é colocado no modelo usando model.predict () que gera uma matriz, cada elemento da matriz é um flutuante de 0 a 1, o índice do elemento é o mesmo da classe que está representando, portanto o primeiro elemento é a classe um e o número é a previsão da certeza de que a imagem é dessa classe. Por exemplo.
NOTA: Se você não estiver usando o lado do robô. Basta remover as linhas:
"import rospy"
def locutor (direção):
mensagem = String ()
pub = rospy. Publisher ('robot', String, queue_size = 10)
rospy.init_node ('talker', anonymous = True)
mensagem = direção
rospy.loginfo (mensagem)
pub.publish (mensagem)"
"locutor (direção)"
Em anexo está o script da câmera Pi.
Etapa 4: Robô Arduino
A última etapa é o script do programa do robô.
Ele foi escrito em C ++ e é um arquivo.ino para o arduino uno. O programa requer a biblioteca ros, que pode ser encontrada no gerenciador de bibliotecas do ide. Depois de importado, há arquivos de exemplo, optei por expandir no arquivo de piscar do led, pois isso faria um objetivo semelhante ao que eu precisava. O programa continua em loop até que a energia seja desconectada, primeiro ele escuta o tópico robô, quando ele pega um comando daquele tópico, ele terá uma instrução if para ver o que o comando diz. Se o comando for deixado, o script executa o método virar à esquerda; se o comando estiver certo, ele executará o método virar à direita e então executará o método forward. Esses três métodos são muito semelhantes entre si, eles dizem aos pinos digitais para serem BAIXOS (terra) ou 100 (PWM) para que o robô não seja muito rápido, dizendo ao driver do motor para deixar apenas um pouco de tensão fora. A ordem dessas saídas é o que faz com que o robô gire para a esquerda e para a direita ou avance, isso se deve à orientação da tensão que vai para os motores.
Em anexo está o script.ino para arduino.
Etapa 5: Teste
As Imagens anexadas acompanham o projeto do início ao fim. A primeira imagem mostra o treinamento em andamento. Depois de concluído, é mostrada uma impressão do modelo feito. A terceira imagem mostra uma previsão do script de treinamento. esta é a última etapa do script de treinamento. Se você olhar na pasta onde está o script de treinamento, um gráfico e um modelo foram feitos. O gráfico deve ser semelhante à imagem 4 aqui, que mostra o histórico do treinamento do início ao fim.
A imagem final é durante a execução do script da câmera pi, é uma transmissão ao vivo da câmera pi. uma previsão é feita em cada quadro e a previsão é impressa no terminal. O quadro mostra o que a câmera está vendo.
Em anexo está meu relatório da Universidade para este projeto. Por favor, leia para mais detalhes do projeto.
Etapa 6: todos os arquivos adicionais
Alguns deles foram arquivos de teste que fiz ao longo do caminho.